ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/AppsController.java

   1 /*-
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal
   4  * ===================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ===================================================================
   7  *
   8  * Unless otherwise specified, all software contained herein is licensed
   9  * under the Apache License, Version 2.0 (the "License");
  10  * you may not use this software except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *             http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * Unless otherwise specified, all documentation contained herein is licensed
  22  * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
  23  * you may not use this documentation except in compliance with the License.
  24  * You may obtain a copy of the License at
  25  *
  26  *             https://creativecommons.org/licenses/by/4.0/
  27  *
  28  * Unless required by applicable law or agreed to in writing, documentation
  29  * distributed under the License is distributed on an "AS IS" BASIS,
  30  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  31  * See the License for the specific language governing permissions and
  32  * limitations under the License.
  33  *
  34  * ============LICENSE_END============================================
  35  *
  36  *
  37  */
  38 package org.onap.portalapp.portal.controller;
  39
  40 import java.io.IOException;
  41 import java.util.List;
  42 import java.util.Set;
  43
  44 import javax.servlet.http.HttpServletRequest;
  45 import javax.servlet.http.HttpServletResponse;
  46
  47 import org.onap.portalapp.controller.EPRestrictedBaseController;
  48 import org.onap.portalapp.portal.domain.AdminUserApplications;
  49 import org.onap.portalapp.portal.domain.AppIdAndNameTransportModel;
  50 import org.onap.portalapp.portal.domain.AppsResponse;
  51 import org.onap.portalapp.portal.domain.EPApp;
  52 import org.onap.portalapp.portal.domain.EPUser;
  53 import org.onap.portalapp.portal.domain.EcompApp;
  54 import org.onap.portalapp.portal.domain.UserRoles;
  55 import org.onap.portalapp.portal.logging.aop.EPAuditLog;
  56 import org.onap.portalapp.portal.service.AdminRolesService;
  57 import org.onap.portalapp.portal.service.EPAppService;
  58 import org.onap.portalapp.portal.service.EPLeftMenuService;
  59 import org.onap.portalapp.portal.transport.EPAppsManualPreference;
  60 import org.onap.portalapp.portal.transport.EPAppsSortPreference;
  61 import org.onap.portalapp.portal.transport.EPDeleteAppsManualSortPref;
  62 import org.onap.portalapp.portal.transport.EPWidgetsSortPreference;
  63 import org.onap.portalapp.portal.transport.FieldsValidator;
  64 import org.onap.portalapp.portal.transport.LocalRole;
  65 import org.onap.portalapp.portal.transport.OnboardingApp;
  66 import org.onap.portalapp.portal.utils.EcompPortalUtils;
  67 import org.onap.portalapp.portal.utils.PortalConstants;
  68 import org.onap.portalapp.util.EPUserUtils;
  69 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
  70 import org.onap.portalsdk.core.util.SystemProperties;
  71 import org.onap.portalsdk.core.web.support.AppUtils;
  72 import org.springframework.beans.factory.annotation.Autowired;
  73 import org.springframework.context.annotation.EnableAspectJAutoProxy;
  74 import org.springframework.http.HttpEntity;
  75 import org.springframework.http.HttpHeaders;
  76 import org.springframework.http.MediaType;
  77 import org.springframework.web.bind.annotation.PathVariable;
  78 import org.springframework.web.bind.annotation.RequestBody;
  79 import org.springframework.web.bind.annotation.RequestMapping;
  80 import org.springframework.web.bind.annotation.RequestMethod;
  81 import org.springframework.web.bind.annotation.RestController;
  82
  83 @RestController
  84 @EnableAspectJAutoProxy
  85 @EPAuditLog
  86 public class AppsController extends EPRestrictedBaseController {
  87         private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(AppsController.class);
  88
  89         @Autowired
  90         private AdminRolesService adminRolesService;
  91
  92         @Autowired
  93         private EPAppService appService;
  94
  95         @Autowired
  96         private EPLeftMenuService leftMenuService;
  97
  98         /**
  99          * RESTful service method to fetch all Applications available to current
 100          * user
 101          *
 102          * @param request
 103          *            HttpServletRequest
 104          * @param response
 105          *            HttpServletResponse
 106          * @return List<EcompApp>
 107          */
 108         @RequestMapping(value = { "/portalApi/userApps" }, method = RequestMethod.GET, produces = "application/json")
 109         public List<EcompApp> getUserApps(HttpServletRequest request, HttpServletResponse response) {
 110                 EPUser user = EPUserUtils.getUserSession(request);
 111                 List<EcompApp> ecompApps = null;
 112
 113                 try {
 114                         if (user == null) {
 115                                 EcompPortalUtils.setBadPermissions(user, response, "getUserApps");
 116                         } else {
 117                                 ecompApps = appService.transformAppsToEcompApps(appService.getUserApps(user));
 118                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/userApps", "GET result =", ecompApps);
 119                         }
 120                 } catch (Exception e) {
 121                         logger.error(EELFLoggerDelegate.errorLogger, "getUserApps failed", e);
 122                 }
 123
 124                 return ecompApps;
 125         }
 126
 127         /**
 128          * RESTful service method to fetch all applications accessible to the
 129          * current user, with personalizations.
 130          *
 131          * @param request
 132          *            HttpServletRequest
 133          * @param response
 134          *            HttpServletResponse
 135          * @return List<EcompApp>
 136          * @throws IOException
 137          *             if sendError fails
 138          */
 139         @RequestMapping(value = { "/portalApi/persUserApps" }, method = RequestMethod.GET, produces = "application/json")
 140         public List<EcompApp> getPersUserApps(HttpServletRequest request, HttpServletResponse response) throws IOException {
 141                 EPUser user = EPUserUtils.getUserSession(request);
 142                 List<EcompApp> ecompApps = null;
 143                 try {
 144                         if (user == null) {
 145                                 EcompPortalUtils.setBadPermissions(user, response, "getPersUserApps");
 146                         } else {
 147                                 List<EPApp> apps = null;
 148                                 if (adminRolesService.isSuperAdmin(user))
 149                                         apps = appService.getPersAdminApps(user);
 150                                 else
 151                                         apps = appService.getPersUserApps(user);
 152                                 ecompApps = appService.transformAppsToEcompApps(apps);
 153                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/userPersApps", "GET result =", ecompApps);
 154                         }
 155                 } catch (Exception e) {
 156                         logger.error(EELFLoggerDelegate.errorLogger, "getPersUserApps failed", e);
 157                         response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.toString());
 158                 }
 159                 return ecompApps;
 160         }
 161
 162         /**
 163          * RESTful service method to fetch applications for which the current user
 164          * is an Administrator
 165          *
 166          * @param request
 167          *            HttpServletRequest
 168          * @param response
 169          *            HttpServletResponse
 170          * @return List<AppIdAndNameTransportModel>
 171          */
 172         @RequestMapping(value = { "/portalApi/adminApps" }, method = RequestMethod.GET, produces = "application/json")
 173         public List<AppIdAndNameTransportModel> getAdminApps(HttpServletRequest request, HttpServletResponse response) {
 174                 EPUser user = EPUserUtils.getUserSession(request);
 175                 List<AppIdAndNameTransportModel> adminApps = null;
 176
 177                 try {
 178                         if (!adminRolesService.isAccountAdmin(user)) {
 179                                 EcompPortalUtils.setBadPermissions(user, response, "getAdminApps");
 180                         } else {
 181                                 adminApps = appService.getAdminApps(user);
 182                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/adminApps", "GET result =", adminApps);
 183                         }
 184                 } catch (Exception e) {
 185                         logger.error(EELFLoggerDelegate.errorLogger, "getAdminApps failed", e);
 186                 }
 187
 188                 return adminApps;
 189         }
 190
 191         /**
 192          * RESTful service method to fetch Applications for user who is super admin
 193          * and/or app admin.
 194          *
 195          * @param request
 196          *            HttpServletRequest
 197          * @param response
 198          *            HttpServletResponse
 199          * @return List<AppIdAndNameTransportModel>
 200          */
 201         @RequestMapping(value = {
 202                         "/portalApi/appsForSuperAdminAndAccountAdmin" }, method = RequestMethod.GET, produces = "application/json")
 203         public List<AppIdAndNameTransportModel> getAppsForSuperAdminAndAccountAdmin(HttpServletRequest request,
 204                         HttpServletResponse response) {
 205                 EPUser user = EPUserUtils.getUserSession(request);
 206                 List<AppIdAndNameTransportModel> adminApps = null;
 207
 208                 try {
 209                         if (!adminRolesService.isSuperAdmin(user) && !adminRolesService.isAccountAdmin(user)) {
 210                                 EcompPortalUtils.setBadPermissions(user, response, "getAdminApps");
 211                         } else {
 212                                 adminApps = appService.getAppsForSuperAdminAndAccountAdmin(user);
 213                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/appsForSuperAdminAndAccountAdmin",
 214                                                 "GET result =", adminApps);
 215                         }
 216                 } catch (Exception e) {
 217                         logger.error(EELFLoggerDelegate.errorLogger, "getAppsForSuperAdminAndAccountAdmin failed", e);
 218                 }
 219
 220                 return adminApps;
 221         }
 222
 223         /**
 224          * RESTful service method to fetch left menu items from the user's session.
 225          *
 226          * @param request
 227          *            HttpServletRequest
 228          * @param response
 229          *            HttpServletResponse
 230          * @return JSON with left menu
 231          */
 232         @SuppressWarnings({ "rawtypes", "unchecked" })
 233         @RequestMapping(value = { "/portalApi/leftmenuItems" }, method = RequestMethod.GET, produces = "application/json")
 234         public String getLeftMenuItems(HttpServletRequest request, HttpServletResponse response) {
 235                 String menuList = null;
 236                 Set menuSet = (Set) AppUtils.getSession(request)
 237                                 .getAttribute(SystemProperties.getProperty(SystemProperties.APPLICATION_MENU_ATTRIBUTE_NAME));
 238
 239                 Set roleFunctionSet = (Set) AppUtils.getSession(request)
 240                                 .getAttribute(SystemProperties.getProperty(SystemProperties.ROLE_FUNCTIONS_ATTRIBUTE_NAME));
 241
 242                 EPUser user = EPUserUtils.getUserSession(request);
 243
 244                 try {
 245                         menuList = leftMenuService.getLeftMenuItems(user, menuSet, roleFunctionSet);
 246                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/leftmenuItems", "GET result =", menuList);
 247                 } catch (Exception e) {
 248                         logger.error(EELFLoggerDelegate.errorLogger, "getLeftMenuItems failed", e);
 249                 }
 250                 return menuList;
 251         }
 252
 253         @RequestMapping(value = {
 254                         "/portalApi/userAppsOrderBySortPref" }, method = RequestMethod.GET, produces = "application/json")
 255         public List<EcompApp> getUserAppsOrderBySortPref(HttpServletRequest request, HttpServletResponse response) {
 256                 EPUser user = EPUserUtils.getUserSession(request);
 257                 List<EcompApp> ecompApps = null;
 258                 try {
 259                         if (user == null) {
 260                                 EcompPortalUtils.setBadPermissions(user, response, "getUserAppsOrderBySortPref");
 261                         } else {
 262                                 String usrSortPref = request.getParameter("mparams");
 263                                 if (usrSortPref.equals("")) {
 264                                         usrSortPref = "N";
 265                                 }
 266                                 switch (usrSortPref) {
 267                                 case "N":
 268                                         ecompApps = appService.transformAppsToEcompApps(appService.getAppsOrderByName(user));
 269                                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/userAppsOrderBySortPref", "GET result =",
 270                                                         ecompApps);
 271                                         break;
 272                                 case "L":
 273                                         ecompApps = appService.transformAppsToEcompApps(appService.getAppsOrderByLastUsed(user));
 274                                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/userAppsOrderBySortPref", "GET result =",
 275                                                         ecompApps);
 276                                         break;
 277                                 case "F":
 278                                         ecompApps = appService.transformAppsToEcompApps(appService.getAppsOrderByMostUsed(user));
 279                                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/userAppsOrderBySortPref", "GET result =",
 280                                                         ecompApps);
 281                                         break;
 282                                 case "M":
 283                                         ecompApps = appService.transformAppsToEcompApps(appService.getAppsOrderByManual(user));
 284                                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/userAppsOrderBySortPref", "GET result =",
 285                                                         ecompApps);
 286                                         break;
 287                                 default:
 288                                         logger.error(EELFLoggerDelegate.errorLogger,
 289                                                         "getUserAppsOrderBySortPref failed: no match for " + usrSortPref);
 290                                 }
 291                         }
 292                 } catch (Exception e) {
 293                         logger.error(EELFLoggerDelegate.errorLogger, "getUserAppsOrderBySortPref failed", e);
 294                 }
 295                 return ecompApps;
 296         }
 297
 298         /**
 299          * Sets the user apps manual sort preference
 300          *
 301          * @param request
 302          *            HTTP servlet request
 303          * @param response
 304          *            HTTP servlet response
 305          * @param epAppsManualPref
 306          *            sort pref
 307          * @return FieldsValidator
 308          */
 309         @RequestMapping(value = {
 310                         "/portalApi/saveUserAppsSortingManual" }, method = RequestMethod.PUT, produces = "application/json")
 311         public FieldsValidator putUserAppsSortingManual(HttpServletRequest request,
 312                         @RequestBody List<EPAppsManualPreference> epAppsManualPref, HttpServletResponse response) {
 313                 FieldsValidator fieldsValidator = null;
 314                 try {
 315                         EPUser user = EPUserUtils.getUserSession(request);
 316                         fieldsValidator = appService.saveAppsSortManual(epAppsManualPref, user);
 317                         response.setStatus(fieldsValidator.httpStatusCode.intValue());
 318                 } catch (Exception e) {
 319                         logger.error(EELFLoggerDelegate.errorLogger, "putUserAppsSortingManual failed", e);
 320                 }
 321                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/saveUserAppsSortingManual", "PUT result =",
 322                                 response.getStatus());
 323                 return fieldsValidator;
 324         }
 325
 326         @RequestMapping(value = {
 327                         "/portalApi/saveUserWidgetsSortManual" }, method = RequestMethod.PUT, produces = "application/json")
 328         public FieldsValidator putUserWidgetsSortManual(HttpServletRequest request,
 329                         @RequestBody List<EPWidgetsSortPreference> saveManualWidgetSData, HttpServletResponse response) {
 330                 FieldsValidator fieldsValidator = null;
 331                 try {
 332                         EPUser user = EPUserUtils.getUserSession(request);
 333                         fieldsValidator = appService.saveWidgetsSortManual(saveManualWidgetSData, user);
 334                         response.setStatus(fieldsValidator.httpStatusCode.intValue());
 335                 } catch (Exception e) {
 336                         logger.error(EELFLoggerDelegate.errorLogger, "putUserWidgetsSortManual failed", e);
 337                 }
 338                 // return fieldsValidator;
 339                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/putUserWidgetsSortManual", "PUT result =",
 340                                 response.getStatus());
 341                 return fieldsValidator;
 342         }
 343
 344         @RequestMapping(value = {
 345                         "/portalApi/updateWidgetsSortPref" }, method = RequestMethod.PUT, produces = "application/json")
 346         public FieldsValidator putUserWidgetsSortPref(HttpServletRequest request,
 347                         @RequestBody List<EPWidgetsSortPreference> delManualWidgetData, HttpServletResponse response) {
 348                 FieldsValidator fieldsValidator = null;
 349                 try {
 350                         EPUser user = EPUserUtils.getUserSession(request);
 351                         fieldsValidator = appService.deleteUserWidgetSortPref(delManualWidgetData, user);
 352                         response.setStatus(fieldsValidator.httpStatusCode.intValue());
 353                 } catch (Exception e) {
 354                         logger.error(EELFLoggerDelegate.errorLogger, "putUserWidgetsSortPref failed", e);
 355
 356                 }
 357                 // return fieldsValidator;
 358                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/putUserWidgetsSortPref", "PUT result =",
 359                                 response.getStatus());
 360                 return fieldsValidator;
 361         }
 362
 363         /**
 364          * Deletes the user app manual sort preference record
 365          *
 366          * @param request
 367          *            HTTP servlet request
 368          * @param response
 369          *            HTTP servlet response
 370          * @param delManualAppData
 371          *            data to delete
 372          * @return FieldsValidator
 373          */
 374         @RequestMapping(value = {
 375                         "/portalApi/UpdateUserAppsSortManual" }, method = RequestMethod.PUT, produces = "application/json")
 376         public FieldsValidator deleteUserAppSortManual(HttpServletRequest request,
 377                         @RequestBody EPDeleteAppsManualSortPref delManualAppData, HttpServletResponse response) {
 378                 FieldsValidator fieldsValidator = null;
 379                 try {
 380                         EPUser user = EPUserUtils.getUserSession(request);
 381                         fieldsValidator = appService.deleteUserAppSortManual(delManualAppData, user);
 382                         response.setStatus(fieldsValidator.httpStatusCode.intValue());
 383                 } catch (Exception e) {
 384                         logger.error(EELFLoggerDelegate.errorLogger, "deleteUserAppSortManual failed", e);
 385
 386                 }
 387                 // return fieldsValidator;
 388                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/deleteUserAppSortManual", "PUT result =",
 389                                 response.getStatus());
 390                 return fieldsValidator;
 391         }
 392
 393         @RequestMapping(value = {
 394                         "/portalApi/saveUserAppsSortingPreference" }, method = RequestMethod.PUT, produces = "application/json")
 395         public FieldsValidator putUserAppsSortingPreference(HttpServletRequest request,
 396                         @RequestBody EPAppsSortPreference userAppsValue, HttpServletResponse response) {
 397                 FieldsValidator fieldsValidator = null;
 398                 try {
 399                         EPUser user = EPUserUtils.getUserSession(request);
 400                         fieldsValidator = appService.saveAppsSortPreference(userAppsValue, user);
 401                         response.setStatus(fieldsValidator.httpStatusCode.intValue());
 402                 } catch (Exception e) {
 403                         logger.error(EELFLoggerDelegate.errorLogger, "putUserAppsSortingPreference failed", e);
 404
 405                 }
 406
 407                 // return fieldsValidator;
 408                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/putUserAppsSortingPreference", "PUT result =",
 409                                 response.getStatus());
 410                 return fieldsValidator;
 411         }
 412
 413         @RequestMapping(value = {
 414                         "/portalApi/userAppsSortTypePreference" }, method = RequestMethod.GET, produces = "application/String")
 415         public String getUserAppsSortTypePreference(HttpServletRequest request, HttpServletResponse response) {
 416                 EPUser user = EPUserUtils.getUserSession(request);
 417                 String userSortPreference = null;
 418
 419                 try {
 420                         if (user == null) {
 421                                 EcompPortalUtils.setBadPermissions(user, response, "userAppsSortTypePreference");
 422                         } else {
 423                                 userSortPreference = appService.getUserAppsSortTypePreference(user);
 424                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/userAppsSortTypePreference", "GET result =",
 425                                                 userSortPreference);
 426                         }
 427                 } catch (Exception e) {
 428                         logger.error(EELFLoggerDelegate.errorLogger, "getUserAppsSortTypePreference failed", e);
 429                 }
 430
 431                 return userSortPreference;
 432         }
 433
 434         /**
 435          * RESTful service method to fetch Application Administrators to Super
 436          * Administrator user. Attention: Users which have Super Administrator roles
 437          * only are not included!
 438          *
 439          * @param request
 440          *            HTTP servlet request
 441          * @param response
 442          *            HTTP servlet response
 443          * @return List<AdminUserApplications>
 444          */
 445         @RequestMapping(value = { "/portalApi/accountAdmins" }, method = RequestMethod.GET, produces = "application/json")
 446         public List<AdminUserApplications> getAppsAdministrators(HttpServletRequest request, HttpServletResponse response) {
 447                 EPUser user = EPUserUtils.getUserSession(request);
 448                 List<AdminUserApplications> admins = null;
 449                 try {
 450                         if (!adminRolesService.isSuperAdmin(user)) {
 451                                 EcompPortalUtils.setBadPermissions(user, response, "getAppsAdministrators");
 452                         } else {
 453                                 admins = appService.getAppsAdmins();
 454                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/accountAdmins", "GET result =", admins);
 455                         }
 456                 } catch (Exception e) {
 457                         logger.error(EELFLoggerDelegate.errorLogger, "getAppsAdministrators failed", e);
 458                 }
 459
 460                 return admins;
 461         }
 462
 463         @RequestMapping(value = { "/portalApi/availableApps" }, method = RequestMethod.GET, produces = "application/json")
 464         public List<AppsResponse> getApps(HttpServletRequest request, HttpServletResponse response) {
 465                 EPUser user = EPUserUtils.getUserSession(request);
 466                 List<AppsResponse> apps = null;
 467                 try {
 468                         if (!adminRolesService.isSuperAdmin(user)) {
 469                                 EcompPortalUtils.setBadPermissions(user, response, "getApps");
 470                         } else {
 471                                 apps = appService.getAllApps(false);
 472                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/availableApps", "GET result =", apps);
 473                         }
 474                 } catch (Exception e) {
 475                         logger.error(EELFLoggerDelegate.errorLogger, "getApps failed", e);
 476                 }
 477
 478                 return apps;
 479         }
 480
 481         /**
 482          * Gets all apps, both active and inactive; i.e., all on-boarded apps,
 483          * regardless of enabled status.
 484          *
 485          * @param request
 486          *            HTTP servlet request
 487          * @param response
 488          *            HTTP servlet response
 489          * @return List of applications
 490          */
 491         @RequestMapping(value = {
 492                         "/portalApi/allAvailableApps" }, method = RequestMethod.GET, produces = "application/json")
 493         public List<AppsResponse> getAllApps(HttpServletRequest request, HttpServletResponse response) {
 494                 EPUser user = EPUserUtils.getUserSession(request);
 495                 List<AppsResponse> apps = null;
 496                 try {
 497                         if (!adminRolesService.isSuperAdmin(user)) {
 498                                 EcompPortalUtils.setBadPermissions(user, response, "getApps");
 499                         } else {
 500                                 apps = appService.getAllApps(true);
 501                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/availableApps", "GET result =", apps);
 502                         }
 503                 } catch (Exception e) {
 504                         logger.error(EELFLoggerDelegate.errorLogger, "getAllApps failed", e);
 505                 }
 506
 507                 return apps;
 508         }
 509
 510         /**
 511          *
 512          * @param request
 513          *            HTTP servlet request
 514          * @param response
 515          *            HTTP servlet response
 516          * @return List of applications
 517          */
 518         @RequestMapping(value = { "/portalApi/appsFullList" }, method = RequestMethod.GET, produces = "application/json")
 519         public List<EcompApp> getAppsFullList(HttpServletRequest request, HttpServletResponse response) {
 520                 EPUser user = EPUserUtils.getUserSession(request);
 521                 List<EcompApp> ecompApps = null;
 522                 if (user == null) {
 523                         EcompPortalUtils.setBadPermissions(user, response, "getAppsFullList");
 524                 } else {
 525                         ecompApps = appService.getEcompAppAppsFullList();
 526                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/appsFullList", "GET result =", ecompApps);
 527                 }
 528                 return ecompApps;
 529         }
 530
 531         /**
 532          *
 533          * @param request
 534          *            HTTP servlet request
 535          * @param response
 536          *            HTTP servlet response
 537          * @return UserRoles
 538          */
 539         @RequestMapping(value = { "/portalApi/userProfile" }, method = RequestMethod.GET, produces = "application/json")
 540         public UserRoles getUserProfile(HttpServletRequest request, HttpServletResponse response) {
 541                 EPUser user = EPUserUtils.getUserSession(request);
 542                 UserRoles userAndRoles = null;
 543                 try {
 544                         if (user == null) {
 545                                 EcompPortalUtils.setBadPermissions(user, response, "getUserProfile");
 546                         } else {
 547                                 userAndRoles = appService.getUserProfileNormalized(user);
 548                         }
 549                 } catch (Exception e) {
 550                         logger.error(EELFLoggerDelegate.errorLogger, "getUserProfile failed", e);
 551                 }
 552
 553                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/userProfile", "getUserProfile result =",
 554                                 userAndRoles);
 555                 return userAndRoles;
 556         }
 557
 558         /**
 559          *
 560          * @param request
 561          *            HTTP servlet request
 562          * @param appId
 563          *            application ID
 564          * @return List<LocalRole>
 565          */
 566         @RequestMapping(value = { "/portalApi/appRoles/{appId}" }, method = {
 567                         RequestMethod.GET }, produces = "application/json")
 568         public List<LocalRole> getAppRoles(HttpServletRequest request, @PathVariable("appId") Long appId,
 569                         HttpServletResponse response) {
 570                 List<LocalRole> roleList = null;
 571                 EPUser user = EPUserUtils.getUserSession(request);
 572                 EPApp requestedApp = appService.getApp(appId);
 573                 if (user != null && (adminRolesService.isAccountAdminOfApplication(user, requestedApp)
 574                                 || (adminRolesService.isSuperAdmin(user) && requestedApp.getId() == PortalConstants.PORTAL_APP_ID))) {
 575                         try {
 576                                 roleList = appService.getAppRoles(appId);
 577                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/appRoles/" + appId, "GET result =",
 578                                                 roleList);
 579                         } catch (Exception e) {
 580                                 logger.error(EELFLoggerDelegate.errorLogger, "getAppRoles failed", e);
 581                         }
 582                 } else {
 583                         EcompPortalUtils.setBadPermissions(user, response, "getAppRoles");
 584                 }
 585                 return roleList;
 586         }
 587
 588         /**
 589          *
 590          * Return single app information with appName as parameter
 591          *
 592          * @param request
 593          * @param response
 594          * @return EPApp object
 595          */
 596         @RequestMapping(value = { "/portalApi/singleAppInfo" }, method = {
 597                         RequestMethod.GET }, produces = "application/json")
 598         public EPApp getSingleAppInfo(HttpServletRequest request, HttpServletResponse response) {
 599                 EPApp app = null;
 600                 EPUser user = EPUserUtils.getUserSession(request);
 601                 try {
 602                         String appName = request.getParameter("appParam");
 603                         app = appService.getAppDetailByAppName(appName);
 604                         if (user != null && (adminRolesService.isAccountAdminOfApplication(user, app)
 605                                         || (adminRolesService.isSuperAdmin(user) && app.getId() == PortalConstants.PORTAL_APP_ID)))
 606                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/singleAppInfo" + appName, "GET result =", app);
 607                         else{
 608                                 app= null;
 609                                 EcompPortalUtils.setBadPermissions(user, response, "createAdmin");
 610                         }
 611
 612                 } catch (Exception e) {
 613                         logger.error(EELFLoggerDelegate.errorLogger, "getSingleAppInfo failed", e);
 614                 }
 615                 return app;
 616         }
 617
 618         /**
 619          *
 620          * Return single app information with appId as parameter
 621          *
 622          * @param request
 623          * @param response
 624          * @return EPApp object
 625          */
 626         @RequestMapping(value = { "/portalApi/singleAppInfoById" }, method = {
 627                         RequestMethod.GET }, produces = "application/json")
 628         public EPApp getSingleAppInfoById(HttpServletRequest request, HttpServletResponse response) {
 629                 EPApp app = null;
 630                 EPUser user = EPUserUtils.getUserSession(request);
 631                 try {
 632                         String appId = request.getParameter("appParam");
 633                         app = appService.getApp(Long.valueOf(appId));
 634                         if(!EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
 635                                 app.setCentralAuth(false);
 636                         }
 637                         if (user != null && (adminRolesService.isAccountAdminOfApplication(user, app)
 638                                         || (adminRolesService.isSuperAdmin(user) && app.getId() == PortalConstants.PORTAL_APP_ID)))
 639                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/singleAppInfoById" + appId, "GET result =", app);
 640                         else{
 641                                 app= null;
 642                                 EcompPortalUtils.setBadPermissions(user, response, "createAdmin");
 643                         }
 644
 645                 } catch (Exception e) {
 646                         logger.error(EELFLoggerDelegate.errorLogger, "getSingleAppInfo failed", e);
 647                 }
 648                 return app;
 649         }
 650
 651         /**
 652          *
 653          * @param request
 654          *            HTTP servlet request
 655          * @param response
 656          *            HTTP servlet response
 657          * @return List<OnboardingApp>
 658          */
 659         @RequestMapping(value = { "/portalApi/onboardingApps" }, method = RequestMethod.GET, produces = "application/json")
 660         public List<OnboardingApp> getOnboardingApps(HttpServletRequest request, HttpServletResponse response) {
 661                 EPUser user = EPUserUtils.getUserSession(request);
 662                 List<OnboardingApp> onboardingApps = null;
 663                 try {
 664                         if (!adminRolesService.isSuperAdmin(user)) {
 665                                 EcompPortalUtils.setBadPermissions(user, response, "getOnboardingApps");
 666                         } else {
 667                                 onboardingApps = appService.getOnboardingApps();
 668                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/onboardingApps", "GET result =",
 669                                                 "onboardingApps of size " + onboardingApps.size());
 670                         }
 671                 } catch (Exception e) {
 672                         logger.error(EELFLoggerDelegate.errorLogger, "getOnboardingApps failed", e);
 673                 }
 674
 675                 return onboardingApps;
 676         }
 677
 678         /**
 679          *
 680          * @param request
 681          *            HTTP servlet request
 682          * @param response
 683          *            HTTP servlet response
 684          * @param modifiedOnboardingApp
 685          *            app to update
 686          * @return FieldsValidator
 687          */
 688         @RequestMapping(value = { "/portalApi/onboardingApps" }, method = RequestMethod.PUT, produces = "application/json")
 689         public FieldsValidator putOnboardingApp(HttpServletRequest request,
 690                         @RequestBody OnboardingApp modifiedOnboardingApp, HttpServletResponse response) {
 691                 FieldsValidator fieldsValidator = null;
 692                 try {
 693                         EPUser user = EPUserUtils.getUserSession(request);
 694                         if (!adminRolesService.isSuperAdmin(user)) {
 695                                 EcompPortalUtils.setBadPermissions(user, response, "putOnboardingApp");
 696                         } else {
 697                                 modifiedOnboardingApp.normalize();
 698                                 fieldsValidator = appService.modifyOnboardingApp(modifiedOnboardingApp, user);
 699                                 response.setStatus(fieldsValidator.httpStatusCode.intValue());
 700                         }
 701                 } catch (Exception e) {
 702                         logger.error(EELFLoggerDelegate.errorLogger, "putOnboardingApps failed", e);
 703                 }
 704
 705                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/onboardingApps", "PUT result =",
 706                                 response.getStatus());
 707                 return fieldsValidator;
 708         }
 709
 710         /**
 711          *
 712          * @param request
 713          *            HTTP servlet request
 714          * @param response
 715          *            HTTP servlet response
 716          * @param newOnboardingApp
 717          *            app to add
 718          * @return FieldsValidator
 719          */
 720         @RequestMapping(value = { "/portalApi/onboardingApps" }, method = RequestMethod.POST, produces = "application/json")
 721         public FieldsValidator postOnboardingApp(HttpServletRequest request, @RequestBody OnboardingApp newOnboardingApp,
 722                         HttpServletResponse response) {
 723                 FieldsValidator fieldsValidator = null;
 724                 try {
 725                         EPUser user = EPUserUtils.getUserSession(request);
 726                         if (!adminRolesService.isSuperAdmin(user)) {
 727                                 EcompPortalUtils.setBadPermissions(user, response, "postOnboardingApps");
 728                         } else {
 729                                 newOnboardingApp.normalize();
 730                                 fieldsValidator = appService.addOnboardingApp(newOnboardingApp, user);
 731                                 response.setStatus(fieldsValidator.httpStatusCode.intValue());
 732                         }
 733                 } catch (Exception e) {
 734                         logger.error(EELFLoggerDelegate.errorLogger, "postOnboardingApp failed", e);
 735                 }
 736
 737                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/onboardingApps", "POST result =",
 738                                 response.getStatus());
 739                 return fieldsValidator;
 740         }
 741
 742         /**
 743          * REST endpoint to process a request to delete an on-boarded application.
 744          *
 745          * @param request
 746          *            HTTP servlet request
 747          * @param response
 748          *            HTTP servlet response
 749          * @param appId
 750          *            ID of app to delete
 751          * @return FieldsValidator
 752          */
 753         @RequestMapping(value = { "/portalApi/onboardingApps/{appId}" }, method = {
 754                         RequestMethod.DELETE }, produces = "application/json")
 755         public FieldsValidator deleteOnboardingApp(HttpServletRequest request, @PathVariable("appId") Long appId,
 756                         HttpServletResponse response) {
 757                 FieldsValidator fieldsValidator = null;
 758                 try {
 759                         EPUser user = EPUserUtils.getUserSession(request);
 760                         if (!adminRolesService.isSuperAdmin(user)) {
 761                                 EcompPortalUtils.setBadPermissions(user, response, "deleteOnboardingApps");
 762                         } else {
 763                                 fieldsValidator = appService.deleteOnboardingApp(user, appId);
 764                                 response.setStatus(fieldsValidator.httpStatusCode.intValue());
 765                         }
 766                 } catch (Exception e) {
 767                         logger.error(EELFLoggerDelegate.errorLogger, "deleteOnboardingApp failed", e);
 768                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 769                 }
 770
 771                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/onboardingApps" + appId, "DELETE result =",
 772                                 response.getStatus());
 773                 return fieldsValidator;
 774         }
 775
 776         /**
 777          * Gets the application thumbnail image; sets status 404 if none exists.
 778          *
 779          * @param request
 780          *            HTTP servlet request
 781          * @param response
 782          *            HTTP servlet response
 783          * @param appId
 784          *            Application ID
 785          * @return Bytes with the app thumbnail image; null if not available.
 786          */
 787         @RequestMapping(value = { "/portalApi/appThumbnail/{appId}" }, method = { RequestMethod.GET })
 788         public HttpEntity<byte[]> getAppThumbnail(HttpServletRequest request, @PathVariable("appId") Long appId,
 789                         HttpServletResponse response) {
 790                 EPApp app = appService.getApp(appId);
 791                 if (app == null || app.getImageUrl() == null || app.getThumbnail() == null || app.getThumbnail().length == 0) {
 792                         logger.debug(EELFLoggerDelegate.debugLogger,
 793                                         "getAppThumbnail: no app and/or no thumbnail for app " + appId);
 794                         response.setStatus(HttpServletResponse.SC_NOT_FOUND);
 795                         return null;
 796                 }
 797                 String url = app.getImageUrl();
 798                 int indexOfDot = url.lastIndexOf('.');
 799                 String urlSuffix = indexOfDot > 0 ? url.substring(indexOfDot + 1).toLowerCase() : "UNK";
 800                 // Default to JPG if no usable suffix.
 801                 MediaType mediaType = MediaType.IMAGE_JPEG;
 802                 if ("png".equals(urlSuffix))
 803                         mediaType = MediaType.IMAGE_PNG;
 804                 else if ("gif".equals(urlSuffix))
 805                         mediaType = MediaType.IMAGE_GIF;
 806                 HttpHeaders header = new HttpHeaders();
 807                 header.setContentType(mediaType);
 808                 header.setContentLength(app.getThumbnail().length);
 809                 return new HttpEntity<byte[]>(app.getThumbnail(), header);
 810         }
 811
 812 }