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

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