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