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