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