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