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