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

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