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