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