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