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