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

   1 /*-
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal
   4  * ===================================================================
   5  * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * ===================================================================
   7  *  Modification Copyright © 2020 IBM.
   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
  43 import java.io.IOException;
  44 import java.util.ArrayList;
  45 import java.util.HashMap;
  46 import java.util.List;
  47 import java.util.Map;
  48 import java.util.Set;
  49 import java.util.TreeSet;
  50
  51 import javax.servlet.http.HttpServletRequest;
  52 import javax.servlet.http.HttpServletResponse;
  53
  54 import org.apache.commons.lang.StringUtils;
  55 import org.onap.portalapp.portal.domain.CentralV2RoleFunction;
  56 import org.onap.portalapp.portal.domain.EPApp;
  57 import org.onap.portalapp.portal.domain.EPUser;
  58 import org.onap.portalapp.portal.domain.EcompAuditLog;
  59 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
  60 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  61 import org.onap.portalapp.portal.exceptions.InvalidRoleException;
  62 import org.onap.portalapp.portal.logging.aop.EPAuditLog;
  63 import org.onap.portalapp.portal.logging.aop.EPEELFLoggerAdvice;
  64 import org.onap.portalapp.portal.logging.logic.EPLogUtil;
  65 import org.onap.portalapp.portal.service.ExternalAccessRolesService;
  66 import org.onap.portalsdk.core.service.UserService;
  67 import org.onap.portalapp.portal.transport.CentralRole;
  68 import org.onap.portalapp.portal.transport.CentralRoleFunction;
  69 import org.onap.portalapp.portal.transport.CentralUser;
  70 import org.onap.portalapp.portal.transport.CentralV2Role;
  71 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
  72 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
  73 import org.onap.portalapp.portal.utils.EcompPortalUtils;
  74 import org.onap.portalapp.portal.utils.PortalConstants;
  75 import org.onap.portalapp.validation.DataValidator;
  76 import org.onap.portalapp.validation.SecureString;
  77 import org.onap.portalsdk.core.domain.AuditLog;
  78 import org.onap.portalsdk.core.domain.Role;
  79 import org.onap.portalsdk.core.domain.User;
  80 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
  81 import org.onap.portalsdk.core.restful.domain.EcompRole;
  82 import org.onap.portalsdk.core.restful.domain.EcompUser;
  83 import org.onap.portalsdk.core.service.AuditService;
  84 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
  85 import org.onap.portalsdk.core.util.SystemProperties;
  86 import org.onap.portalsdk.core.web.support.UserUtils;
  87 import org.slf4j.MDC;
  88 import org.springframework.beans.BeanUtils;
  89 import org.springframework.beans.factory.annotation.Autowired;
  90 import org.springframework.context.annotation.EnableAspectJAutoProxy;
  91 import org.springframework.http.ResponseEntity;
  92 import org.springframework.web.bind.annotation.PathVariable;
  93 import org.springframework.web.bind.annotation.RequestBody;
  94 import org.springframework.web.bind.annotation.RequestMapping;
  95 import org.springframework.web.bind.annotation.GetMapping;
  96 import org.springframework.web.bind.annotation.PostMapping;
  97 import org.springframework.web.bind.annotation.PutMapping;
  98 import org.springframework.web.bind.annotation.DeleteMapping;
  99 import org.springframework.web.bind.annotation.RequestMethod;
 100 import org.springframework.web.bind.annotation.RestController;
 101
 102 import com.fasterxml.jackson.databind.DeserializationFeature;
 103 import com.fasterxml.jackson.databind.ObjectMapper;
 104 import com.fasterxml.jackson.databind.type.TypeFactory;
 105
 106 import io.swagger.annotations.ApiOperation;
 107
 108 @RestController
 109 @RequestMapping("/auxapi")
 110 @org.springframework.context.annotation.Configuration
 111 @EnableAspectJAutoProxy
 112 @EPAuditLog
 113 public class ExternalAccessRolesController implements BasicAuthenticationController {
 114         private static final String ROLE_INVALID_CHARS = "%=():,\"\"";
 115         private static final String SUCCESSFULLY_DELETED = "Successfully Deleted";
 116         private static final String INVALID_UEB_KEY = "Invalid credentials!";
 117         private static final String LOGIN_ID = "LoginId";
 118         private static final String UEBKEY = "uebkey";
 119
 120         private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ExternalAccessRolesController.class);
 121         private static final DataValidator DATA_VALIDATOR = new DataValidator();
 122
 123         @Autowired
 124         private AuditService auditService;
 125
 126         @Autowired
 127         private ExternalAccessRolesService externalAccessRolesService;
 128
 129         @Autowired
 130         private UserService userservice =  new UserServiceCentalizedImpl();
 131
 132         @ApiOperation(value = "Gets user role for an application.", response = CentralUser.class, responseContainer="List")
 133         @GetMapping(value = {
 134                         "/user/{loginId}" }, produces = "application/json")
 135         public CentralUser getUser(HttpServletRequest request, HttpServletResponse response,
 136                         @PathVariable("loginId") String loginId) throws Exception {
 137                 if (!DATA_VALIDATOR.isValid(new SecureString(loginId))){
 138                         sendErrorResponse(response, new Exception("Data is not valid"));
 139                         logger.error(EELFLoggerDelegate.errorLogger, "getUser not valid data");
 140                         return null;
 141                 }
 142                 CentralUser answer = null;
 143                 try {
 144                         fieldsValidation(request);
 145                         answer = externalAccessRolesService.getUserRoles(loginId, request.getHeader(UEBKEY));
 146                 } catch (Exception e) {
 147                         sendErrorResponse(response, e);
 148                         logger.error(EELFLoggerDelegate.errorLogger, "getUser failed", e);
 149                 }
 150                 return answer;
 151         }
 152
 153         @ApiOperation(value = "Gets user roles for an application which is upgraded to newer version.", response = String.class, responseContainer="List")
 154         @GetMapping(value = {
 155                         "/v1/user/{loginId}" }, produces = "application/json")
 156         public String getV2UserList(HttpServletRequest request, HttpServletResponse response,
 157                         @PathVariable("loginId") String loginId) throws Exception {
 158                 if (!DATA_VALIDATOR.isValid(new SecureString(loginId))){
 159                         sendErrorResponse(response, new Exception("Data is not valid"));
 160                         logger.error(EELFLoggerDelegate.errorLogger, "getV2UserList not valid data");
 161                         return "Data is not valid";
 162                 }
 163                 String answer = null;
 164                 try {
 165                         fieldsValidation(request);
 166                         answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
 167                 } catch (Exception e) {
 168                         sendErrorResponse(response, e);
 169                         logger.error(EELFLoggerDelegate.errorLogger, "getV2UserList failed", e);
 170                 }
 171                 return answer;
 172         }
 173
 174         @ApiOperation(value = "Gets roles for an application.", response = CentralRole.class, responseContainer="Json")
 175         @GetMapping(value = {
 176                         "/roles" }, produces = "application/json")
 177         public List<CentralRole> getRolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
 178                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRolesForApp");
 179                 List<CentralV2Role> v2CenRole = null;
 180                 List<CentralRole> cenRole = null;
 181                 try {
 182                         fieldsValidation(request);
 183                         EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 184                         // Sync all roles from external system into ONAP portal DB
 185                         logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
 186                         externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
 187                         logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
 188                         v2CenRole = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
 189                         cenRole = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(v2CenRole);
 190                 } catch (Exception e) {
 191                         sendErrorResponse(response, e);
 192                         logger.error(EELFLoggerDelegate.errorLogger, "getRolesForApp failed", e);
 193                 }
 194                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRolesForApp");
 195                 return cenRole;
 196         }
 197
 198         @ApiOperation(value = "Gets roles for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
 199         @GetMapping(value = {
 200                         "/v1/roles" }, produces = "application/json")
 201         public List<CentralV2Role> getV2RolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
 202                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RolesForApp");
 203                 List<CentralV2Role> answer = null;
 204                 try {
 205                         fieldsValidation(request);
 206                         EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 207                         // Sync all roles from external system into ONAP portal DB
 208                         logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Entering into syncApplicationRolesWithEcompDB");
 209                         externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
 210                         logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Finished syncApplicationRolesWithEcompDB");
 211                         answer = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
 212                 } catch (Exception e) {
 213                         sendErrorResponse(response, e);
 214                         logger.error(EELFLoggerDelegate.errorLogger, "getV2RolesForApp failed", e);
 215                 }
 216                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RolesForApp");
 217                 return answer;
 218         }
 219
 220         @ApiOperation(value = "Gets all role functions for an application for older version.", response = CentralRoleFunction.class, responseContainer="Json")
 221         @GetMapping(value = {
 222                         "/functions" }, produces = "application/json")
 223         public List<CentralRoleFunction> getRoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
 224                         throws Exception {
 225                 List<CentralV2RoleFunction> answer = null;
 226                 List<CentralRoleFunction> roleFuncList = null;
 227                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleFunctionsList");
 228                 try {
 229                         fieldsValidation(request);
 230                         EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 231                         // Sync all functions from external system into ONAP portal DB
 232                         logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
 233                         externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
 234                         logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
 235                         answer = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
 236                         roleFuncList = externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(answer);
 237                 } catch (Exception e) {
 238                         sendErrorResponse(response, e);
 239                         logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunctionsList failed", e);
 240                 }
 241                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleFunctionsList");
 242                 return roleFuncList;
 243         }
 244
 245         @ApiOperation(value = "Gets all role functions for an application which is upgraded to newer version.", response = CentralV2RoleFunction.class, responseContainer="Json")
 246         @GetMapping(value = {
 247                         "/v1/functions" }, produces = "application/json")
 248         public List<CentralV2RoleFunction> getV2RoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
 249                         throws Exception {
 250                 List<CentralV2RoleFunction> cenRoleFuncList = null;
 251                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleFunctionsList");
 252                 try {
 253                         fieldsValidation(request);
 254                         EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 255                         // Sync all functions from external system into ONAP portal DB
 256                         logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
 257                         externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
 258                         logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
 259                         cenRoleFuncList = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
 260                 } catch (Exception e) {
 261                         sendErrorResponse(response, e);
 262                         logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunctionsList failed", e);
 263                 }
 264                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleFunctionsList");
 265                 return cenRoleFuncList;
 266         }
 267
 268
 269         @ApiOperation(value = "Gets role information for an application.", response = CentralRole.class, responseContainer="Json")
 270         @GetMapping(value = {
 271                         "/role/{role_id}" }, produces = "application/json")
 272         public CentralRole getRoleInfo(HttpServletRequest request, HttpServletResponse response,
 273                         @PathVariable("role_id") Long roleId) throws Exception {
 274                 CentralV2Role answer = null;
 275                 CentralRole cenRole = null;
 276                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleInfo");
 277                 try {
 278                         fieldsValidation(request);
 279                         answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
 280                         cenRole = externalAccessRolesService.convertV2CentralRoleToOldVerisonCentralRole(answer);
 281                 } catch (Exception e) {
 282                         sendErrorResponse(response, e);
 283                         logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo failed", e);
 284                 }
 285                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleInfo");
 286                 return cenRole;
 287         }
 288
 289         @ApiOperation(value = "Gets v2 role information for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
 290         @GetMapping(value = {
 291                         "/v1/role/{role_id}" }, produces = "application/json")
 292         public CentralV2Role getV2RoleInfo(HttpServletRequest request, HttpServletResponse response,
 293                         @PathVariable("role_id") Long roleId) throws Exception {
 294                 CentralV2Role answer = null;
 295                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleInfo");
 296                 try {
 297                         fieldsValidation(request);
 298                         answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
 299                 } catch (Exception e) {
 300                         sendErrorResponse(response, e);
 301                         logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleInfo failed", e);
 302                 }
 303                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleInfo");
 304                 return answer;
 305         }
 306
 307         @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralRoleFunction.class, responseContainer = "Json")
 308         @GetMapping(value = { "/function/{code}" }, produces = "application/json")
 309         public CentralRoleFunction getRoleFunction(HttpServletRequest request, HttpServletResponse response,
 310                         @PathVariable("code") String code) throws Exception {
 311                 CentralV2RoleFunction centralV2RoleFunction = null;
 312                 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
 313                 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
 314                         sendErrorResponse(response, new Exception("Data is not valid"));
 315                         logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunction failed", new Exception("Data is not valid"));
 316                 }
 317                 try {
 318                         fieldsValidation(request);
 319                         centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
 320                         if(centralV2RoleFunction != null && EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
 321                                 BeanUtils.copyProperties(centralV2RoleFunction, centralRoleFunction, "type","action");
 322                         }
 323                 } catch (Exception e) {
 324                         sendErrorResponse(response, e);
 325                         logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunction failed", e);
 326                 }
 327                 return centralRoleFunction;
 328         }
 329
 330         @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralV2RoleFunction.class, responseContainer = "Json")
 331         @GetMapping(value = { "/v1/function/{code}" }, produces = "application/json")
 332         public CentralV2RoleFunction getV2RoleFunction(HttpServletRequest request, HttpServletResponse response,
 333                         @PathVariable("code") String code) throws Exception {
 334                 CentralV2RoleFunction centralV2RoleFunction = null;
 335                 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
 336                         sendErrorResponse(response, new Exception("Data is not valid"));
 337                         logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunction failed", new Exception("Data is not valid"));
 338                 }
 339                 try {
 340                         fieldsValidation(request);
 341                         centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
 342                         if(centralV2RoleFunction == null || !EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
 343                                 centralV2RoleFunction = new CentralV2RoleFunction();
 344                         }
 345                 } catch (Exception e) {
 346                         sendErrorResponse(response, e);
 347                         logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunction failed", e);
 348                 }
 349                 return centralV2RoleFunction;
 350         }
 351
 352         @ApiOperation(value = "Saves role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 353         @PostMapping(value = { "/roleFunction" }, produces = "application/json")
 354         public PortalRestResponse<String> saveRoleFunction(HttpServletRequest request, HttpServletResponse response,
 355                         @RequestBody String roleFunc) {
 356                 String status = "Successfully saved!";
 357                 if(!DATA_VALIDATOR.isValid(new SecureString(roleFunc))){
 358                         logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed");
 359                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
 360                                 "Failed to roleFunc, not valid data.", "Failed");
 361                 }
 362                 try {
 363                         fieldsValidation(request);
 364                ObjectMapper mapper = new ObjectMapper();
 365                         List<EPApp> applicationList = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
 366                         EPApp requestedApp = applicationList.get(0);
 367                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 368                         CentralV2RoleFunction availableRoleFunction = mapper.readValue(roleFunc, CentralV2RoleFunction.class);
 369                         CentralV2RoleFunction domainRoleFunction = null;
 370                         boolean isCentralV2Version = false;
 371                         if(availableRoleFunction.getType()!=null && availableRoleFunction.getAction()!= null) {
 372                                 isCentralV2Version = true;
 373                         }
 374                         if(isCentralV2Version) {
 375                                 String code = availableRoleFunction.getType()+"|"+availableRoleFunction.getCode()+"|"+availableRoleFunction.getAction();
 376                                 domainRoleFunction = externalAccessRolesService.getRoleFunction(code,
 377                                                 requestedApp.getUebKey());
 378                         } else {
 379                                 domainRoleFunction = externalAccessRolesService.getRoleFunction(availableRoleFunction.getCode(),
 380                                                 requestedApp.getUebKey());
 381                         }
 382
 383                         boolean saveOrUpdateResponse = false;
 384                         if (domainRoleFunction != null && isCentralV2Version && domainRoleFunction.getCode().equals(availableRoleFunction.getCode())
 385                                         && domainRoleFunction.getType().equals(availableRoleFunction.getType())
 386                                         && domainRoleFunction.getAction().equals(availableRoleFunction.getAction())) {
 387                                 domainRoleFunction.setName(availableRoleFunction.getName());
 388                                 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(domainRoleFunction,
 389                                                 requestedApp);
 390                         } else {
 391                                 availableRoleFunction.setAppId(requestedApp.getId());
 392                                 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(availableRoleFunction,
 393                                                 requestedApp);
 394                         }
 395
 396                         if(domainRoleFunction != null) {
 397                                 status = "Successfully updated!";
 398                         }
 399                         if (saveOrUpdateResponse) {
 400                                 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
 401                                 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 402                                 String activityCode = (!status.equals("Successfully updated!"))
 403                                                 ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_FUNCTION
 404                                                 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_FUNCTION;
 405                                 logger.info(EELFLoggerDelegate.applicationLogger, "saveRoleFunction: succeeded for app {}, function {}",
 406                                                 app.getId(), availableRoleFunction.getCode());
 407                                 AuditLog auditLog = new AuditLog();
 408                                 auditLog.setUserId(user.getId());
 409                                 auditLog.setActivityCode(activityCode);
 410                                 auditLog.setComments(
 411                                                 EcompPortalUtils.truncateString(
 412                                                                 "saveRoleFunction role for app:" + app.getId() + " and function:'"
 413                                                                                 + availableRoleFunction.getCode() + "'",
 414                                                                 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
 415                                 auditLog.setAffectedRecordId(user.getOrgUserId());
 416                                 auditService.logActivity(auditLog, null);
 417                                 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 418                                 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 419                                 EcompPortalUtils.calculateDateTimeDifferenceForLog(
 420                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
 421                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
 422                                 logger.info(EELFLoggerDelegate.auditLogger,
 423                                                 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRoleFunction", activityCode,
 424                                                                 String.valueOf(user.getId()), user.getOrgUserId(), availableRoleFunction.getCode()));
 425                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
 426                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
 427                                 MDC.remove(SystemProperties.MDC_TIMER);
 428                         } else {
 429                                 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed");
 430                                 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
 431                         "Failed to saveRoleFunction for '" + availableRoleFunction.getCode() + "'", "Failed");
 432                         }
 433                 } catch (Exception e) {
 434                         if (e.getMessage() == null ||e.getMessage().contains(INVALID_UEB_KEY)) {
 435                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 436                         }else {
 437                                 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 438                         }
 439                         logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed", e);
 440                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
 441                 }
 442                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, status, "Success");
 443         }
 444
 445         @ApiOperation(value = "Deletes role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 446         @DeleteMapping(value = { "/roleFunction/{code}" }, produces = "application/json")
 447         public PortalRestResponse<String> deleteRoleFunction(HttpServletRequest request, HttpServletResponse response,
 448                         @PathVariable("code") String code) {
 449                 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
 450                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
 451                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
 452                                 "Failed to deleteRoleFunction, not valid data.", "Failed");
 453                 }
 454                 try {
 455                         fieldsValidation(request);
 456                         EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
 457                         EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 458                         boolean getDelFuncResponse = externalAccessRolesService.deleteCentralRoleFunction(code, app);
 459                         if (getDelFuncResponse) {
 460                                 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRoleFunction: succeeded for app {}, role {}",
 461                                                 app.getId(), code);
 462                                 AuditLog auditLog = new AuditLog();
 463                                 auditLog.setUserId(user.getId());
 464                                 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION);
 465                                 auditLog.setComments(EcompPortalUtils.truncateString(
 466                                                 "Deleted function for app:" + app.getId() + " and function code:'" + code + "'",
 467                                                 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
 468                                 auditLog.setAffectedRecordId(user.getOrgUserId());
 469                                 auditService.logActivity(auditLog, null);
 470                                 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 471                                 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 472                                 EcompPortalUtils.calculateDateTimeDifferenceForLog(
 473                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
 474                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
 475                                 logger.info(EELFLoggerDelegate.auditLogger,
 476                                                 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRoleFunction",
 477                                                                 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION, String.valueOf(user.getId()),
 478                                                                 user.getOrgUserId(), code));
 479                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
 480                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
 481                                 MDC.remove(SystemProperties.MDC_TIMER);
 482                         } else {
 483                                 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
 484                                 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
 485                         "Failed to deleteRoleFunction for '" + code + "'", "Failed");
 486                         }
 487                 } catch (Exception e) {
 488                         if (e.getMessage().contains(INVALID_UEB_KEY)) {
 489                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 490                         } else {
 491                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 492                         }
 493                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed", e);
 494                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
 495                 }
 496                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
 497
 498         }
 499
 500         @ApiOperation(value = "Saves role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 501         @PostMapping(value = { "/role" }, produces = "application/json")
 502         public PortalRestResponse<String> saveRole(HttpServletRequest request, HttpServletResponse response,
 503                         @RequestBody Role role) {
 504                 try {
 505                         fieldsValidation(request);
 506                         ExternalRequestFieldsValidator saveRoleResult = null;
 507                         EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
 508                         EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 509                         if(role.getId()!=null && StringUtils.containsAny(role.getName(), ROLE_INVALID_CHARS)) {
 510                                 throw new InvalidRoleException("Invalid role name found for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed");
 511                         }
 512                         saveRoleResult = externalAccessRolesService.saveRoleForApplication(role, request.getHeader(UEBKEY));
 513                         if (saveRoleResult.isResult()) {
 514                                 String activityCode = (role.getId() == null) ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_ROLE
 515                                                 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_ROLE_AND_FUNCTION;
 516                                 logger.info(EELFLoggerDelegate.applicationLogger, "saveRole: succeeded for app {}, role {}",
 517                                                 app.getId(), role.getName());
 518                                 AuditLog auditLog = new AuditLog();
 519                                 auditLog.setUserId(user.getId());
 520                                 auditLog.setActivityCode(activityCode);
 521                                 auditLog.setComments(EcompPortalUtils.truncateString(
 522                                                 "saveRole role for app:" + app.getId() + " and role:'" + role.getName() + "'",
 523                                                 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
 524                                 auditLog.setAffectedRecordId(user.getOrgUserId());
 525                                 auditService.logActivity(auditLog, null);
 526                                 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 527                                 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 528                                 EcompPortalUtils.calculateDateTimeDifferenceForLog(
 529                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
 530                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
 531                                 logger.info(EELFLoggerDelegate.auditLogger,
 532                                                 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRole", activityCode,
 533                                                                 String.valueOf(user.getId()), user.getOrgUserId(), role.getName()));
 534                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
 535                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
 536                                 MDC.remove(SystemProperties.MDC_TIMER);
 537                         } else {
 538                                 if(saveRoleResult.getDetailMessage().contains("406")){
 539                                         response.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
 540                                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
 541                                         "Failed to create a role for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed"
 542                                                 , "Failed");
 543                                 } else{
 544                                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 545                                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
 546                                                         "Failed to saveRole for '" + role.getName() + "'", "Failed");
 547                                 }
 548                         }
 549                 } catch (Exception e) {
 550                         if (e.getMessage().contains(INVALID_UEB_KEY)) {
 551                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 552                         }else {
 553                                 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 554                         }
 555                         logger.error(EELFLoggerDelegate.errorLogger, "saveRole failed", e);
 556                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
 557                 }
 558                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
 559         }
 560
 561         @ApiOperation(value = "Deletes role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 562         @DeleteMapping(value = { "/deleteRole/{code}" }, produces = "application/json")
 563         public  PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
 564                         @PathVariable String code) {
 565                 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
 566                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
 567                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
 568                                 "Failed to deleteRole, not valid data.", "Failed");
 569                 }
 570                 try {
 571                         fieldsValidation(request);
 572                         boolean deleteResponse = externalAccessRolesService.deleteRoleForApplication(code,
 573                                         request.getHeader(UEBKEY));
 574                         if (deleteResponse) {
 575                                 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
 576                                 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 577                                 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRole: succeeded for app {}, role {}",
 578                                                 app.getId(), code);
 579                                 AuditLog auditLog = new AuditLog();
 580                                 auditLog.setUserId(user.getId());
 581                                 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE);
 582                                 auditLog.setComments(EcompPortalUtils.truncateString(
 583                                                 "Deleted role for app:" + app.getId() + " and role:'" + code + "'",
 584                                                 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
 585                                 auditLog.setAffectedRecordId(user.getOrgUserId());
 586                                 auditService.logActivity(auditLog, null);
 587                                 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 588                                 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 589                                 EcompPortalUtils.calculateDateTimeDifferenceForLog(
 590                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
 591                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
 592                                 logger.info(EELFLoggerDelegate.auditLogger,
 593                                                 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRole",
 594                                                                 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE, String.valueOf(user.getId()),
 595                                                                 user.getOrgUserId(), code));
 596                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
 597                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
 598                                 MDC.remove(SystemProperties.MDC_TIMER);
 599                         } else {
 600                                 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
 601                                 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
 602                         "Failed to deleteRole for '" + code + "'", "Failed");
 603                         }
 604                 } catch (Exception e) {
 605                         if (e.getMessage().contains(INVALID_UEB_KEY)) {
 606                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 607                         } else {
 608                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 609                         }
 610                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
 611                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
 612                 }
 613                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
 614         }
 615
 616         @ApiOperation(value = "Gets active roles for an application.", response = CentralRole.class, responseContainer = "Json")
 617         @GetMapping(value = { "/activeRoles" }, produces = "application/json")
 618         public  List<CentralRole> getActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
 619                 List<CentralRole> roles = null;
 620                 try {
 621                         fieldsValidation(request);
 622                         List<CentralV2Role> cenRoles= externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
 623                         roles = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles);
 624                 } catch (Exception e) {
 625                         sendErrorResponse(response, e);
 626                         logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
 627                 }
 628                 return roles;
 629
 630         }
 631
 632         @ApiOperation(value = "Gets active roles for an application.", response = CentralV2Role.class, responseContainer = "Json")
 633         @GetMapping(value = { "/v1/activeRoles" }, produces = "application/json")
 634         public  List<CentralV2Role> getV2ActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
 635                 List<CentralV2Role> cenRole = null;
 636                 try {
 637                         fieldsValidation(request);
 638                         cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
 639                 } catch (Exception e) {
 640                         sendErrorResponse(response, e);
 641                         logger.error(EELFLoggerDelegate.errorLogger, "getV2ActiveRoles failed", e);
 642                 }
 643                 return cenRole;
 644
 645         }
 646
 647         @ApiOperation(value = "deletes user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 648         @DeleteMapping(value = { "/deleteDependcyRoleRecord/{roleId}" }, produces = "application/json")
 649         public PortalRestResponse<String> deleteDependencyRoleRecord(HttpServletRequest request, HttpServletResponse response,
 650                         @PathVariable("roleId") Long roleId) {
 651                 ExternalRequestFieldsValidator removeResult = null;
 652                 try {
 653                         fieldsValidation(request);
 654                         removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
 655                                         request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
 656                         if (!removeResult.isResult()) {
 657                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 658                                 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteDependencyRoleRecord",
 659                                                 "Failed");
 660                         }
 661                 } catch (Exception e) {
 662                         if (e.getMessage().contains(INVALID_UEB_KEY)) {
 663                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 664                         } else {
 665                                 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 666                         }
 667                         logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord failed", e);
 668                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
 669                 }
 670                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
 671         }
 672
 673
 674         @ApiOperation(value = "deletes  roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 675         @DeleteMapping(value = { "/v2/deleteRole/{roleId}" }, produces = "application/json")
 676         public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
 677                         @PathVariable("roleId") Long roleId) {
 678                 ExternalRequestFieldsValidator removeResult = null;
 679                 try {
 680                         fieldsValidation(request);
 681                         removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
 682                                         request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
 683                         if (!removeResult.isResult()) {
 684                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 685                                 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteRole",
 686                                                 "Failed");
 687                         }
 688                 } catch (Exception e) {
 689                         if (e.getMessage().contains(INVALID_UEB_KEY)) {
 690                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 691                         } else {
 692                                 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 693                         }
 694                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
 695                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
 696                 }
 697                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
 698         }
 699
 700
 701         @ApiOperation(value = "Bulk upload functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 702         @PostMapping(value = { "/upload/portal/functions" }, produces = "application/json")
 703         public  PortalRestResponse<String> bulkUploadFunctions(HttpServletRequest request, HttpServletResponse response) {
 704                 Integer result = 0;
 705                 try {
 706                         result = externalAccessRolesService.bulkUploadFunctions(request.getHeader(UEBKEY));
 707                 } catch (Exception e) {
 708                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 709                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
 710                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
 711                 }
 712                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
 713         }
 714
 715         @ApiOperation(value = "Bulk upload roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 716         @PostMapping(value = { "/upload/portal/roles" }, produces = "application/json")
 717         public  PortalRestResponse<String> bulkUploadRoles(HttpServletRequest request, HttpServletResponse response) {
 718                 Integer result = 0;
 719                 try {
 720                         result = externalAccessRolesService.bulkUploadRoles(request.getHeader(UEBKEY));
 721                 } catch (Exception e) {
 722                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 723                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
 724                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
 725                 }
 726                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
 727         }
 728
 729         @ApiOperation(value = "Bulk upload role functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 730         @PostMapping(value = { "/upload/portal/roleFunctions" }, produces = "application/json")
 731         public  PortalRestResponse<String> bulkUploadRoleFunctions(HttpServletRequest request, HttpServletResponse response) {
 732                 Integer result = 0;
 733                 try {
 734                         result = externalAccessRolesService.bulkUploadRolesFunctions(request.getHeader(UEBKEY));
 735                 } catch (Exception e) {
 736                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 737                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoleFunctions failed", e);
 738                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoleFunctions", "Failed");
 739                 }
 740                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
 741         }
 742
 743         @ApiOperation(value = "Bulk upload user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 744         @PostMapping(value = { "/upload/portal/userRoles" }, produces = "application/json")
 745         public  PortalRestResponse<String> bulkUploadUserRoles(HttpServletRequest request, HttpServletResponse response) {
 746                 Integer result = 0;
 747                 try {
 748                         result = externalAccessRolesService.bulkUploadUserRoles(request.getHeader(UEBKEY));
 749                 } catch (Exception e) {
 750                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 751                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUserRoles failed", e);
 752                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUserRoles", "Failed");
 753                 }
 754                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
 755         }
 756
 757         @ApiOperation(value = "Bulk upload users for renamed role of an application.", response = PortalRestResponse.class, responseContainer = "Json")
 758         @PostMapping(value = { "/upload/portal/userRole/{roleId}" }, produces = "application/json")
 759         public  PortalRestResponse<String> bulkUploadUsersSingleRole(HttpServletRequest request, HttpServletResponse response, @PathVariable Long roleId) {
 760                 Integer result = 0;
 761                 try {
 762                         String roleName = request.getHeader("RoleName");
 763                         result = externalAccessRolesService.bulkUploadUsersSingleRole(request.getHeader(UEBKEY), roleId, roleName);
 764                 } catch (Exception e) {
 765                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 766                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUsersSingleRole failed", e);
 767                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUsersSingleRole", "Failed");
 768                 }
 769                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
 770         }
 771
 772         @ApiOperation(value = "Bulk upload functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
 773         @PostMapping(value = { "/upload/partner/functions" }, produces = "application/json")
 774         public  PortalRestResponse<String> bulkUploadPartnerFunctions(HttpServletRequest request, HttpServletResponse response) {
 775                 Integer addedFunctions = 0;
 776                 try {
 777                         addedFunctions = externalAccessRolesService.bulkUploadPartnerFunctions(request.getHeader(UEBKEY));
 778                 } catch (Exception e) {
 779                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 780                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
 781                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
 782                 }
 783                 return new PortalRestResponse<>(PortalRestStatusEnum.OK,
 784                 "Successfully added: '" + addedFunctions + "' functions", "Success");
 785         }
 786
 787         @ApiOperation(value = "Bulk upload roles for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
 788         @PostMapping(value = { "/upload/partner/roles" }, produces = "application/json")
 789         public  PortalRestResponse<String> bulkUploadPartnerRoles(HttpServletRequest request, HttpServletResponse response, @RequestBody List<Role> upload) {
 790                 try {
 791                         externalAccessRolesService.bulkUploadPartnerRoles(request.getHeader(UEBKEY), upload);
 792                 } catch (Exception e) {
 793                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 794                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
 795                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
 796                 }
 797                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added", "Success");
 798         }
 799
 800         @ApiOperation(value = "Bulk upload role functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
 801         @PostMapping(value = { "/upload/partner/roleFunctions" }, produces = "application/json")
 802         public  PortalRestResponse<String> bulkUploadPartnerRoleFunctions(HttpServletRequest request, HttpServletResponse response) {
 803                 Integer addedRoleFunctions = 0;
 804                 try {
 805                         addedRoleFunctions = externalAccessRolesService.bulkUploadPartnerRoleFunctions(request.getHeader(UEBKEY));
 806                 } catch (Exception e) {
 807                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 808                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadPartnerRoleFunctions failed", e);
 809                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadPartnerRoleFunctions",
 810                     "Failed");
 811                 }
 812                 return new PortalRestResponse<>(PortalRestStatusEnum.OK,
 813                 "Successfully added: '" + addedRoleFunctions + "' role functions", "Success");
 814         }
 815
 816         @ApiOperation(value = "Gets all functions along with global functions", response = List.class, responseContainer = "Json")
 817         @GetMapping(value = { "/menuFunctions" }, produces = "application/json")
 818         public  List<String> getMenuFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
 819                 List<String> functionsList = null;
 820                 try {
 821                         fieldsValidation(request);
 822                         functionsList = externalAccessRolesService.getMenuFunctionsList(request.getHeader(UEBKEY));
 823                 } catch (Exception e) {
 824                         sendErrorResponse(response, e);
 825                         logger.error(EELFLoggerDelegate.errorLogger, "getMenuFunctions failed", e);
 826                 }
 827                 return functionsList;
 828         }
 829
 830         @ApiOperation(value = "Gets all active Users of application", response = String.class, responseContainer = "Json")
 831         @GetMapping(value = { "/users" }, produces = "application/json")
 832         public  List<EcompUser> getUsersOfApplication(HttpServletRequest request, HttpServletResponse response) throws Exception {
 833                 List<EcompUser> users = null;
 834                 try {
 835                         fieldsValidation(request);
 836                         users = externalAccessRolesService.getAllAppUsers(request.getHeader(UEBKEY));
 837                 } catch (Exception e) {
 838                         sendErrorResponse(response, e);
 839                         logger.error(EELFLoggerDelegate.errorLogger, "getUsersOfApplication failed", e);
 840                 }
 841                 return users;
 842         }
 843
 844         /**
 845          *
 846          * It checks the input uebkey of the application and throws exception if it is invalid key
 847          *
 848          * @param request
 849          * @throws Exception
 850          */
 851         private void  fieldsValidation(HttpServletRequest request) throws Exception{
 852                 List<EPApp> app = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
 853                 if(app.isEmpty()){
 854                         throw new Exception(INVALID_UEB_KEY);
 855                 }
 856                 if(!app.isEmpty() && app.get(0).getCentralAuth()){
 857                         ResponseEntity<String> response = externalAccessRolesService.getNameSpaceIfExists(app.get(0));
 858                         if (response.getStatusCode().value() == HttpServletResponse.SC_NOT_FOUND)
 859                                 throw new Exception("Invalid NameSpace");
 860                 }
 861         }
 862
 863         /**
 864          *
 865          * It returns http response with appropriate message
 866          *
 867          * @param response
 868          * @param e
 869          * @throws IOException
 870          */
 871         private void sendErrorResponse(HttpServletResponse response, Exception e) throws IOException {
 872                 response.setContentType("application/json");
 873                 response.setCharacterEncoding("UTF-8");
 874                 final Map<String,String> uebkeyResponse = new HashMap<>();
 875                 ObjectMapper mapper = new ObjectMapper();
 876                 String reason = "";
 877                 if (e.getMessage().contains(INVALID_UEB_KEY)) {
 878                         uebkeyResponse.put("error",INVALID_UEB_KEY);
 879                         reason = mapper.writeValueAsString(uebkeyResponse);
 880                         response.getWriter().write(reason);
 881                         response.setStatus(HttpServletResponse.SC_NOT_FOUND);
 882                 } else {
 883                         uebkeyResponse.put("error",e.getMessage());
 884                         reason = mapper.writeValueAsString(uebkeyResponse);
 885                         response.getWriter().write(reason);
 886                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 887                 }
 888         }
 889
 890         @ApiOperation(value = "Gets ecompUser of an application.", response = CentralUser.class, responseContainer = "List")
 891         @GetMapping(value = { "/v2/user/{loginId}" }, produces = "application/json")
 892         public String getEcompUser(HttpServletRequest request, HttpServletResponse response,
 893                         @PathVariable("loginId") String loginId) throws Exception {
 894                 if(!DATA_VALIDATOR.isValid(new SecureString(loginId))){
 895                         sendErrorResponse(response, new Exception("getEcompUser failed"));
 896                         logger.error(EELFLoggerDelegate.errorLogger, "getEcompUser failed", new Exception("getEcompUser failed"));
 897                 }
 898                 EcompUser user = new EcompUser();
 899                 ObjectMapper mapper = new ObjectMapper();
 900                 String answer = null;
 901                 try {
 902                         fieldsValidation(request);
 903
 904                         answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
 905                         if (answer != null) {
 906                 User ecompUser = userservice.userMapper(answer);
 907                                 user = UserUtils.convertToEcompUser(ecompUser);
 908                             List<EcompRole> missingRolesOfUser = externalAccessRolesService.missingUserApplicationRoles(request.getHeader(UEBKEY), loginId, user.getRoles());
 909                                 if (missingRolesOfUser.size() > 0) {
 910                                         Set<EcompRole> roles = new TreeSet<>(missingRolesOfUser);
 911                                         user.getRoles().addAll(roles);
 912                                 }
 913                         }
 914                 } catch (Exception e) {
 915                         sendErrorResponse(response, e);
 916                         logger.error(EELFLoggerDelegate.errorLogger, "getEcompUser failed", e);
 917                 }
 918                 return mapper.writeValueAsString(user);
 919         }
 920
 921         @ApiOperation(value = "Gets user ecomp role for an application.", response = CentralUser.class, responseContainer = "List")
 922         @GetMapping(value = { "/v2/roles" }, produces = "application/json")
 923         public List<EcompRole> getEcompRolesOfApplication(HttpServletRequest request, HttpServletResponse response)
 924                         throws Exception {
 925                 List<EcompRole> ecompRoles = null;
 926                 ObjectMapper mapper = new ObjectMapper();
 927                 List<CentralV2Role> cenRole = null;
 928                 try {
 929                         fieldsValidation(request);
 930                         EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 931                         // Sync all roles from external system into ONAP portal DB
 932                         logger.debug(EELFLoggerDelegate.debugLogger,
 933                                         "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
 934                         externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
 935                         logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
 936                         cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
 937                 } catch (Exception e) {
 938                         sendErrorResponse(response, e);
 939                         logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
 940                 }
 941                 if (cenRole != null) {
 942                         String res = mapper.writeValueAsString(cenRole);
 943                         ecompRoles = new ArrayList<>();
 944                         List<Role> roles = mapper.readValue(res,
 945                                         TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
 946                         for (Role role : roles)
 947                                 ecompRoles.add(UserUtils.convertToEcompRole(role));
 948                         logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getEcompRolesOfApplication");
 949                 }
 950                 return ecompRoles;
 951         }
 952 }