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