ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/AppsControllerExternalRequest.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 io.swagger.annotations.ApiOperation;
  41 import java.util.List;
  42 import javax.servlet.http.HttpServletRequest;
  43 import javax.servlet.http.HttpServletResponse;
  44 import javax.validation.Valid;
  45 import lombok.NoArgsConstructor;
  46 import org.onap.portalapp.portal.domain.EPApp;
  47 import org.onap.portalapp.portal.domain.EPUser;
  48 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
  49 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  50 import org.onap.portalapp.portal.logging.aop.EPAuditLog;
  51 import org.onap.portalapp.portal.service.AdminRolesService;
  52 import org.onap.portalapp.portal.service.EPAppService;
  53 import org.onap.portalapp.portal.service.PortalAdminService;
  54 import org.onap.portalapp.portal.service.UserService;
  55 import org.onap.portalapp.portal.transport.FieldsValidator;
  56 import org.onap.portalapp.portal.transport.OnboardingApp;
  57 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
  58 import org.onap.portalapp.portal.utils.EcompPortalUtils;
  59 import org.onap.portalapp.portal.utils.PortalConstants;
  60 import org.onap.portalapp.validation.DataValidator;
  61 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
  62 import org.springframework.beans.factory.annotation.Autowired;
  63 import org.springframework.context.annotation.Configuration;
  64 import org.springframework.context.annotation.EnableAspectJAutoProxy;
  65 import org.springframework.web.bind.annotation.PathVariable;
  66 import org.springframework.web.bind.annotation.RequestBody;
  67 import org.springframework.web.bind.annotation.RequestMapping;
  68 import org.springframework.web.bind.annotation.GetMapping;
  69 import org.springframework.web.bind.annotation.PutMapping;
  70 import org.springframework.web.bind.annotation.PostMapping;
  71 import org.springframework.web.bind.annotation.ResponseBody;
  72 import org.springframework.web.bind.annotation.RestController;
  73
  74 /**
  75  * Processes requests from external systems (i.e., not the front-end web UI).
  76  * First use case is ONAP Controller, which has to create an admin and onboard
  77  * itself upon launch of a fresh Portal.
  78  *
  79  * Listens on the "auxapi" path prefix. Provides alternate implementations of
  80  * methods in several existing controllers because an EPUser object is not
  81  * available in the session for these requests.
  82  *
  83  * Checks credentials sent via HTTP Basic Authentication. The Portal's basic
  84  * HTTP authentication system requires that the user names and endpoints are
  85  * registered together.
  86  */
  87 @RestController
  88 @RequestMapping(PortalConstants.REST_AUX_API)
  89 @Configuration
  90 @EnableAspectJAutoProxy
  91 @EPAuditLog
  92 @NoArgsConstructor
  93 public class AppsControllerExternalRequest implements BasicAuthenticationController {
  94         private static final String ONBOARD_APP = "/onboardApp";
  95         private static final String DATA_IS_NOT_VALID = "Data is not valid";
  96         private static final String REQUEST = "request";
  97         private static final String RESPONSE = "response";
  98
  99         private static final DataValidator DATA_VALIDATOR = new DataValidator();
 100         private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(AppsControllerExternalRequest.class);
 101
 102         private AdminRolesService adminRolesService;
 103         private EPAppService appService;
 104         private PortalAdminService portalAdminService;
 105         private UserService userService;
 106
 107         @Autowired
 108         public AppsControllerExternalRequest(AdminRolesService adminRolesService,
 109                 EPAppService appService, PortalAdminService portalAdminService,
 110                 UserService userService) {
 111                 this.adminRolesService = adminRolesService;
 112                 this.appService = appService;
 113                 this.portalAdminService = portalAdminService;
 114                 this.userService = userService;
 115         }
 116
 117
 118         /**
 119          * Creates a new user as a Portal administrator.
 120          *
 121          * <PRE>
 122          * { "loginId" : "abc123", "loginPwd": "", "email":"ecomp@controller" }
 123          * </PRE>
 124          *
 125          * @param request HttpServletRequest
 126          * @param epUser User details; the email and orgUserId fields are mandatory
 127          * @param response HttpServletResponse
 128          * @return PortalRestResponse with success or failure
 129          */
 130         @ApiOperation(value = "Creates a new user as a Portal administrator.", response = PortalRestResponse.class)
 131         @PostMapping(value = "/portalAdmin", produces = "application/json")
 132         @ResponseBody
 133         public PortalRestResponse<String> postPortalAdmin(HttpServletRequest request, HttpServletResponse response,
 134                 @Valid @RequestBody EPUser epUser) {
 135                 EcompPortalUtils.logAndSerializeObject(logger, "postPortalAdmin", REQUEST, epUser);
 136                 PortalRestResponse<String> portalResponse = new PortalRestResponse<>();
 137                 if (epUser == null) {
 138                         portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 139                         portalResponse.setMessage("User can not be NULL");
 140                         return portalResponse;
 141                 } else if (!DATA_VALIDATOR.isValid(epUser)) {
 142                                 portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 143                                 portalResponse.setMessage(DATA_IS_NOT_VALID);
 144                                 return portalResponse;
 145                 }
 146
 147                 if (epUser.getEmail() == null || epUser.getEmail().trim().length() == 0 //
 148                         || epUser.getLoginId() == null || epUser.getLoginId().trim().length() == 0 //
 149                         || epUser.getLoginPwd() == null) {
 150                         portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 151                         portalResponse.setMessage("Missing required field: email, loginId, or loginPwd");
 152                         return portalResponse;
 153                 }
 154
 155                 try {
 156                         // Check for existing user; create if not found.
 157                         List<EPUser> userList = userService.getUserByUserId(epUser.getOrgUserId());
 158                         if (userList == null || userList.isEmpty()) {
 159                                 // Create user with first, last names etc.; do check for
 160                                 // duplicates.
 161                                 String userCreateResult = userService.saveNewUser(epUser, "Yes");
 162                                 if (!"success".equals(userCreateResult)) {
 163                                         portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 164                                         portalResponse.setMessage(userCreateResult);
 165                                         return portalResponse;
 166                                 }
 167                         }
 168
 169                         // Check for Portal admin status; promote if not.
 170             if (adminRolesService.isSuperAdmin(epUser)) {
 171                 portalResponse.setStatus(PortalRestStatusEnum.OK);
 172             } else {
 173                 FieldsValidator fv;
 174                                 fv = portalAdminService.createPortalAdmin(epUser.getOrgUserId());
 175                                 if (fv != null && fv.httpStatusCode.intValue() == HttpServletResponse.SC_OK) {
 176                     portalResponse.setStatus(PortalRestStatusEnum.OK);
 177                 } else {
 178                     portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 179                     if (fv != null) {
 180                         portalResponse.setMessage(fv.toString());
 181                     }
 182                 }
 183             }
 184                 } catch (Exception ex) {
 185                         // Uncaught exceptions yield 404 and an empty error page
 186                         logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage(), ex);
 187                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 188                         portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 189                         portalResponse.setMessage(ex.toString());
 190                 }
 191
 192                 EcompPortalUtils.logAndSerializeObject(logger, "postPortalAdmin", RESPONSE, portalResponse);
 193                 return portalResponse;
 194         }
 195
 196         /**
 197          * Gets the specified application that is on-boarded in Portal.
 198          *
 199          * @param request HttpServletRequest
 200          * @param appId Application ID to get
 201          * @param response httpServletResponse
 202          * @return OnboardingApp objects
 203          */
 204         @ApiOperation(value = "Gets the specified application that is on-boarded in Portal.", response = OnboardingApp.class)
 205         @GetMapping(value = {ONBOARD_APP + "/{appId}"}, produces = "application/json")
 206         @ResponseBody
 207         public OnboardingApp getOnboardAppExternal(HttpServletRequest request, HttpServletResponse response,
 208                 @PathVariable("appId") Long appId) {
 209                 EPApp epApp = appService.getApp(appId);
 210                 OnboardingApp obApp = new OnboardingApp();
 211                 epApp.setAppPassword(EPCommonSystemProperties.APP_DISPLAY_PASSWORD); //to hide password from get request
 212                 appService.createOnboardingFromApp(epApp, obApp);
 213                 EcompPortalUtils.logAndSerializeObject(logger, "getOnboardAppExternal", RESPONSE, obApp);
 214                 return obApp;
 215         }
 216
 217         /**
 218          * Adds a new application to Portal. The My Logins App Owner in the request must be the organization user ID of a
 219          * person who is a Portal administrator.
 220          *
 221          * <pre>
 222          * {
 223          * "myLoginsAppOwner" : "abc123",
 224          * "name": "dashboard",
 225          * "url": "http://k8s/something",
 226          * "restUrl" : "http://targeturl.com",
 227          * "restrictedApp" : true,
 228          * "isOpen" : true,
 229          * "isEnabled": false
 230          * }
 231          * </pre>
 232          *
 233          * @param request HttpServletRequest
 234          * @param response httpServletResponse
 235          * @param newOnboardApp Message with details about the app to add
 236          * @return PortalRestResponse
 237          */
 238         @ApiOperation(value = "Adds a new application to Portal.", response = PortalRestResponse.class)
 239         @PostMapping(value = {ONBOARD_APP}, produces = "application/json")
 240         @ResponseBody
 241         public PortalRestResponse<String> postOnboardAppExternal(HttpServletRequest request, HttpServletResponse response,
 242                 @Valid @RequestBody OnboardingApp newOnboardApp) {
 243                 EcompPortalUtils.logAndSerializeObject(logger, "postOnboardAppExternal", REQUEST, newOnboardApp);
 244                 PortalRestResponse<String> portalResponse = new PortalRestResponse<>();
 245                 if (newOnboardApp == null) {
 246                         portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 247                         portalResponse.setMessage("newOnboardApp can not be NULL");
 248                         return portalResponse;
 249                 } else if (!DATA_VALIDATOR.isValid(newOnboardApp)) {
 250                                 portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 251                                 portalResponse.setMessage(DATA_IS_NOT_VALID);
 252                                 return portalResponse;
 253                 }
 254                 // Validate fields
 255                 if (newOnboardApp.id != null) {
 256                         portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 257                         portalResponse.setMessage("Unexpected field: id");
 258                         return portalResponse;
 259                 }
 260                 if (checkOnboardingApp(newOnboardApp)) {
 261                         portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 262                         portalResponse.setMessage(
 263                                 "Missing required field: name, url, restUrl, restrictedApp, isOpen, isEnabled, myLoginsAppOwner");
 264                         return portalResponse;
 265                 }
 266
 267                 try {
 268                     List<EPUser> userList;
 269                         userList = userService.getUserByUserId(newOnboardApp.myLoginsAppOwner);
 270                         if (userList == null || userList.size() != 1) {
 271                 portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 272                                 portalResponse.setMessage("Failed to find user: " + newOnboardApp.myLoginsAppOwner);
 273
 274                                 return portalResponse;
 275                         }
 276
 277                         EPUser epUser = userList.get(0);
 278                         // Check for Portal admin status
 279                         if (!adminRolesService.isSuperAdmin(epUser)) {
 280                                 portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 281                                 portalResponse.setMessage("User lacks Portal admin role: " + epUser.getLoginId());
 282                                 return portalResponse;
 283                         }
 284
 285                         newOnboardApp.normalize();
 286                         FieldsValidator fv = appService.addOnboardingApp(newOnboardApp, epUser);
 287                         if (fv.httpStatusCode.intValue() == HttpServletResponse.SC_OK) {
 288                                 portalResponse.setStatus(PortalRestStatusEnum.OK);
 289                         } else {
 290                                 portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 291                                 portalResponse.setMessage(fv.toString());
 292                         }
 293                 } catch (Exception ex) {
 294                         // Uncaught exceptions yield 404 and an empty error page
 295                         logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage(), ex);
 296                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 297                         portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 298                         portalResponse.setMessage(ex.toString());
 299                 }
 300                 EcompPortalUtils.logAndSerializeObject(logger, "postOnboardAppExternal", RESPONSE, portalResponse);
 301                 return portalResponse;
 302         }
 303
 304         /**
 305          * Updates information about an on-boarded application in Portal. The My Logins App Owner in the request must be
 306          * the organization user ID of a person who is a Portal administrator.
 307          * <pre>
 308          * {
 309          * "id" : 123,
 310          * "myLoginsAppOwner" : "abc123",
 311          * "name": "dashboard",
 312          * "url": "http://k8s/something",
 313          * "restUrl" : "http://targeturl.com",
 314          * "restrictedApp" : true,
 315          * "isOpen" : true,
 316          * "isEnabled": false
 317          * }
 318          * </pre>
 319          *
 320          * @param request HttpServletRequest
 321          * @param response httpServletResponse
 322          * @param appId application id
 323          * @param oldOnboardApp Message with details about the app to add
 324          * @return PortalRestResponse
 325          */
 326         @ApiOperation(value = "Updates information about an on-boarded application in Portal.", response = PortalRestResponse.class)
 327         @PutMapping(value = {ONBOARD_APP + "/{appId}"}, produces = "application/json")
 328         @ResponseBody
 329         public PortalRestResponse<String> putOnboardAppExternal(HttpServletRequest request, HttpServletResponse response,
 330                 @PathVariable("appId") Long appId, @Valid @RequestBody OnboardingApp oldOnboardApp) {
 331                 EcompPortalUtils.logAndSerializeObject(logger, "putOnboardAppExternal", REQUEST, oldOnboardApp);
 332                 PortalRestResponse<String> portalResponse = new PortalRestResponse<>();
 333
 334                 if (oldOnboardApp == null){
 335                         portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 336                         portalResponse.setMessage("OnboardingApp can not be NULL");
 337                         return portalResponse;
 338                 }else if (!DATA_VALIDATOR.isValid(oldOnboardApp)) {
 339                                 portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 340                                 portalResponse.setMessage(DATA_IS_NOT_VALID);
 341                                 return portalResponse;
 342                 }
 343
 344                 // Validate fields.
 345
 346                 if (appId == null || !appId.equals(oldOnboardApp.id)) {
 347                         portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 348                         portalResponse.setMessage("Unexpected value for field: id");
 349                         return portalResponse;
 350                 }
 351                 if (checkOnboardingApp(oldOnboardApp)) {
 352
 353                         portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 354                         portalResponse.setMessage(
 355                                 "Missing required field: name, url, restUrl, restrictedApp, isOpen, isEnabled, myLoginsAppOwner");
 356                         return portalResponse;
 357                 }
 358
 359                 try {
 360             List<EPUser> userList;
 361                         userList = userService.getUserByUserId(oldOnboardApp.myLoginsAppOwner);
 362                         if (userList == null || userList.size() != 1) {
 363                 portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 364                                 portalResponse.setMessage("Failed to find user: " + oldOnboardApp.myLoginsAppOwner);
 365
 366                                 return portalResponse;
 367             }
 368
 369                         EPUser epUser = userList.get(0);
 370                         // Check for Portal admin status
 371                         if (!adminRolesService.isSuperAdmin(epUser)) {
 372                                 portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 373                                 portalResponse.setMessage("User lacks Portal admin role: " + epUser.getLoginId());
 374                                 return portalResponse;
 375                         }
 376
 377                         oldOnboardApp.normalize();
 378                         FieldsValidator fv = appService.modifyOnboardingApp(oldOnboardApp, epUser);
 379                         if (fv.httpStatusCode.intValue() == HttpServletResponse.SC_OK) {
 380                                 portalResponse.setStatus(PortalRestStatusEnum.OK);
 381                         } else {
 382                                 portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 383                                 portalResponse.setMessage(fv.toString());
 384                         }
 385                 } catch (Exception ex) {
 386                         // Uncaught exceptions yield 404 and an empty error page
 387                         logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage(), ex);
 388                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 389                         portalResponse.setStatus(PortalRestStatusEnum.ERROR);
 390                         portalResponse.setMessage(ex.toString());
 391                 }
 392                 EcompPortalUtils.logAndSerializeObject(logger, "putOnboardAppExternal", RESPONSE, portalResponse);
 393                 return portalResponse;
 394         }
 395
 396         private boolean checkOnboardingApp(OnboardingApp onboardingApp) {
 397                 return checkIfFieldsAreNull(onboardingApp) || checkIfFieldsAreEmpty(onboardingApp);
 398         }
 399
 400         private boolean checkIfFieldsAreNull(OnboardingApp onboardingApp) {
 401                 return onboardingApp.name == null || onboardingApp.url == null || onboardingApp.restUrl == null
 402                         || onboardingApp.myLoginsAppOwner == null || onboardingApp.restrictedApp == null
 403                         || onboardingApp.isOpen == null || onboardingApp.isEnabled == null;
 404         }
 405
 406         private boolean checkIfFieldsAreEmpty(OnboardingApp onboardingApp) {
 407                 return onboardingApp.name.trim().isEmpty()
 408                         || onboardingApp.url.trim().isEmpty()
 409                         || onboardingApp.restUrl.trim().isEmpty()
 410                         || onboardingApp.myLoginsAppOwner.trim().isEmpty();
 411         }
 412 }