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

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