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

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