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

   1 package org.openecomp.portalapp.portal.controller;
   2
   3
   4 import java.util.ArrayList;
   5 import java.util.List;
   6
   7 import javax.servlet.http.HttpServletRequest;
   8 import javax.servlet.http.HttpServletResponse;
   9
  10 import org.openecomp.portalapp.portal.domain.CentralRoleFunction;
  11 import org.openecomp.portalapp.portal.domain.EPApp;
  12 import org.openecomp.portalapp.portal.domain.EPUser;
  13 import org.openecomp.portalapp.portal.domain.EcompAuditLog;
  14 import org.openecomp.portalapp.portal.ecomp.model.PortalRestResponse;
  15 import org.openecomp.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  16 import org.openecomp.portalapp.portal.logging.aop.EPAuditLog;
  17 import org.openecomp.portalapp.portal.logging.aop.EPEELFLoggerAdvice;
  18 import org.openecomp.portalapp.portal.logging.logic.EPLogUtil;
  19 import org.openecomp.portalapp.portal.service.ExternalAccessRolesService;
  20 import org.openecomp.portalapp.portal.transport.CentralRole;
  21 import org.openecomp.portalapp.portal.utils.EPCommonSystemProperties;
  22 import org.openecomp.portalapp.portal.utils.EcompPortalUtils;
  23 import org.openecomp.portalapp.portal.utils.PortalConstants;
  24 import org.openecomp.portalsdk.core.domain.AuditLog;
  25 import org.openecomp.portalsdk.core.domain.Role;
  26 import org.openecomp.portalsdk.core.domain.RoleFunction;
  27 import org.openecomp.portalsdk.core.logging.logic.EELFLoggerDelegate;
  28 import org.openecomp.portalsdk.core.service.AuditService;
  29 import org.openecomp.portalsdk.core.util.SystemProperties;
  30 import org.slf4j.MDC;
  31 import org.springframework.beans.factory.annotation.Autowired;
  32 import org.springframework.context.annotation.EnableAspectJAutoProxy;
  33 import org.springframework.web.bind.annotation.PathVariable;
  34 import org.springframework.web.bind.annotation.RequestBody;
  35 import org.springframework.web.bind.annotation.RequestMapping;
  36 import org.springframework.web.bind.annotation.RequestMethod;
  37 import org.springframework.web.bind.annotation.RestController;
  38 import org.springframework.web.client.HttpClientErrorException;
  39
  40 import com.fasterxml.jackson.databind.ObjectMapper;
  41
  42 import io.swagger.annotations.ApiOperation;
  43
  44 @RestController
  45 @RequestMapping("/auxapi")
  46 @org.springframework.context.annotation.Configuration
  47 @EnableAspectJAutoProxy
  48 @EPAuditLog
  49 public class ExternalAccessRolesController implements BasicAuthenticationController {
  50
  51         private static final String LOGIN_ID = "LoginId";
  52
  53         @Autowired
  54         private AuditService auditService;
  55
  56         private static final String UEBKEY = "uebkey";
  57
  58         private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ExternalAccessRolesController.class);
  59
  60         @Autowired
  61         private ExternalAccessRolesService externalAccessRolesService;
  62
  63         @ApiOperation(value = "Gets user role for an application.", response = String.class, responseContainer="List")
  64         @RequestMapping(value = {
  65                         "/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
  66         public String getUser(HttpServletRequest request, HttpServletResponse response, @PathVariable("loginId") String loginId) throws Exception {
  67
  68                 String answer = null;
  69                 try {
  70                         answer = externalAccessRolesService.getUserWithRoles(loginId, request.getHeader(UEBKEY));
  71                 } catch (Exception e) {
  72                         logger.error(EELFLoggerDelegate.errorLogger, "getUser failed", e);
  73                 }
  74         return answer;
  75         }
  76
  77         @ApiOperation(value = "Gets roles for an application.", response = CentralRole.class, responseContainer="Json")
  78         @RequestMapping(value = {
  79                         "/roles" }, method = RequestMethod.GET, produces = "application/json")
  80         public List<CentralRole> getRolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
  81                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRolesForApp");
  82                 List<EPApp> applicationList=new ArrayList<>();
  83                 applicationList = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
  84                 EPApp app = applicationList.get(0);
  85         externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
  86                 List<CentralRole> answer = null;
  87                 try {
  88                         answer = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
  89                 } catch (HttpClientErrorException e) {
  90                         if("Application not found".equalsIgnoreCase(e.getMessage())){
  91                                 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
  92                         }
  93                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
  94                         logger.error(EELFLoggerDelegate.errorLogger, "getRolesForApp failed", e);
  95                 }
  96                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRolesForApp");
  97                 return answer;
  98         }
  99
 100         @ApiOperation(value = "Gets all role functions for an application.", response = CentralRoleFunction.class, responseContainer="Json")
 101         @RequestMapping(value = {
 102                         "/functions" }, method = RequestMethod.GET, produces = "application/json")
 103         public List<CentralRoleFunction> getRoleFunctionsList(HttpServletRequest request, HttpServletResponse response) throws Exception {
 104                 List<CentralRoleFunction> answer = null;
 105                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleFunctionsList");
 106                 try {
 107                         answer = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
 108                 } catch (HttpClientErrorException e) {
 109                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 110                         logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunctionsList failed", e);
 111                 }
 112                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleFunctionsList");
 113                 return answer;
 114         }
 115
 116         @ApiOperation(value = "Gets role information for an application.", response = CentralRole.class, responseContainer="Json")
 117         @RequestMapping(value = {
 118                         "/role/{role_id}" }, method = RequestMethod.GET, produces = "application/json")
 119         public CentralRole getRoleInfo(HttpServletRequest request, HttpServletResponse response, @PathVariable("role_id") Long roleId) throws Exception {
 120                 CentralRole answer = null;
 121                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleInfo");
 122
 123                 try {
 124                         answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
 125                 } catch (HttpClientErrorException e) {
 126                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 127                         logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo failed", e);
 128                 }
 129                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleInfo");
 130                 return answer;
 131         }
 132
 133         @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralRoleFunction.class, responseContainer = "Json")
 134         @RequestMapping(value = { "/function/{code}" }, method = RequestMethod.GET, produces = "application/json")
 135         public CentralRoleFunction getRoleFunction(HttpServletRequest request, HttpServletResponse response,
 136                         @PathVariable("code") String code) throws Exception {
 137                 CentralRoleFunction centralRoleFunction = null;
 138                 try {
 139                         centralRoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
 140                 } catch (HttpClientErrorException e) {
 141                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 142                         logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo failed", e);
 143                 }
 144                 return centralRoleFunction;
 145         }
 146
 147         @ApiOperation(value = "Saves role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 148         @RequestMapping(value = { "/roleFunction" }, method = RequestMethod.POST, produces = "application/json")
 149         public PortalRestResponse<String> saveRoleFunction(HttpServletRequest request, HttpServletResponse response,
 150                         @RequestBody String roleFunc) throws Exception {
 151
 152                 ObjectMapper mapper = new ObjectMapper();
 153                 List<EPApp> applicationList = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
 154                 EPApp requestedApp = applicationList.get(0);
 155                 Long appId = requestedApp.getId();
 156                 try {
 157                          String data = roleFunc;
 158                         CentralRoleFunction availableRoleFunction = mapper.readValue(data, CentralRoleFunction.class);
 159                         availableRoleFunction.setAppId(appId);
 160                         boolean saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(availableRoleFunction, requestedApp);
 161                         if(saveOrUpdateResponse){
 162                                 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
 163                                 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 164                                 CentralRoleFunction function = externalAccessRolesService.getRoleFunction(availableRoleFunction.getCode(), request.getHeader(UEBKEY));
 165                                 String activityCode = (function.getCode() == null) ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_FUNCTION: EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_FUNCTION;
 166                                 logger.info(EELFLoggerDelegate.applicationLogger, "saveRoleFunction: succeeded for app {}, function {}",
 167                                                 app.getId(), availableRoleFunction.getCode());
 168                                 AuditLog auditLog = new AuditLog();
 169                                 auditLog.setUserId(user.getId());
 170                                 auditLog.setActivityCode(activityCode);
 171                                 auditLog.setComments(EcompPortalUtils.truncateString("saveRoleFunction role for app:"+app.getId()+" and function:'"+availableRoleFunction.getCode()+"'", PortalConstants.AUDIT_LOG_COMMENT_SIZE));
 172                                 auditLog.setAffectedRecordId(user.getOrgUserId());
 173                                 auditService.logActivity(auditLog, null);
 174                                 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP,
 175                                                 EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 176                                 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP,
 177                                                 EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 178                                 EcompPortalUtils.calculateDateTimeDifferenceForLog(
 179                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
 180                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
 181                                 logger.info(EELFLoggerDelegate.auditLogger,
 182                                                 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRoleFunction",
 183                                                                 activityCode, String.valueOf(user.getId()),
 184                                                                 user.getOrgUserId(), availableRoleFunction.getCode()));
 185                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
 186                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
 187                                 MDC.remove(SystemProperties.MDC_TIMER);
 188                         } else{
 189                                 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed");
 190                                 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to saveRoleFunction for '"+availableRoleFunction.getCode()+"'", "Failed");
 191                         }
 192                 } catch (Exception e) {
 193                         logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed", e);
 194                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
 195                 }
 196                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
 197         }
 198
 199         @ApiOperation(value = "Deletes role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 200         @RequestMapping(value = { "/roleFunction/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
 201         public  PortalRestResponse<String> deleteRoleFunction(HttpServletRequest request, HttpServletResponse response, @PathVariable("code") String code) throws Exception {
 202                 try {
 203                         EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
 204                         EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 205                         boolean getDelFuncResponse = externalAccessRolesService.deleteCentralRoleFunction(code, app);
 206                         if(getDelFuncResponse){
 207                                 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRoleFunction: succeeded for app {}, role {}",
 208                                                 app.getId(), code);
 209                                 AuditLog auditLog = new AuditLog();
 210                                 auditLog.setUserId(user.getId());
 211                                 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION);
 212                                 auditLog.setComments(EcompPortalUtils.truncateString("Deleted function for app:"+app.getId()+" and function code:'"+code+"'", PortalConstants.AUDIT_LOG_COMMENT_SIZE));
 213                                 auditLog.setAffectedRecordId(user.getOrgUserId());
 214                                 auditService.logActivity(auditLog, null);
 215                                 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP,
 216                                                 EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 217                                 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP,
 218                                                 EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 219                                 EcompPortalUtils.calculateDateTimeDifferenceForLog(
 220                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
 221                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
 222                                 logger.info(EELFLoggerDelegate.auditLogger,
 223                                                 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRoleFunction",
 224                                                                 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION, String.valueOf(user.getId()),
 225                                                                 user.getOrgUserId(), code));
 226                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
 227                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
 228                                 MDC.remove(SystemProperties.MDC_TIMER);
 229                         } else{
 230                                 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
 231                                 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to deleteRoleFunction for '"+code+"'", "Failed");
 232                         }
 233                 } catch (HttpClientErrorException e) {
 234                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 235                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed", e);
 236                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteRoleFunction for '"+code+"'", "Failed");
 237                 }
 238                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully Deleted", "Success");
 239
 240         }
 241
 242         @ApiOperation(value = "Saves role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 243         @RequestMapping(value = { "/role" }, method = RequestMethod.POST, produces = "application/json")
 244         public PortalRestResponse<String> saveRole(HttpServletRequest request, HttpServletResponse response,
 245                         @RequestBody Role role) throws Exception {
 246                 try {
 247                         EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
 248                         EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 249                         boolean getAddResponse = externalAccessRolesService.saveRoleForApplication(role, request.getHeader(UEBKEY));
 250                         if (getAddResponse) {
 251                                 String activityCode = (role.getId() == null) ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_ROLE
 252                                                 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_ROLE_AND_FUNCTION;
 253                                 logger.info(EELFLoggerDelegate.applicationLogger, "saveRole: succeeded for app {}, role {}",
 254                                                 app.getId(), role.getName());
 255                                 AuditLog auditLog = new AuditLog();
 256                                 auditLog.setUserId(user.getId());
 257                                 auditLog.setActivityCode(activityCode);
 258                                 auditLog.setComments(EcompPortalUtils.truncateString("saveRole role for app:" + app.getId() + " and role:'" + role.getName()+"'", PortalConstants.AUDIT_LOG_COMMENT_SIZE));
 259                                 auditLog.setAffectedRecordId(user.getOrgUserId());
 260                                 auditService.logActivity(auditLog, null);
 261                                 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 262                                 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 263                                 EcompPortalUtils.calculateDateTimeDifferenceForLog(
 264                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
 265                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
 266                                 logger.info(EELFLoggerDelegate.auditLogger,
 267                                                 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRole", activityCode,
 268                                                                 String.valueOf(user.getId()), user.getOrgUserId(), role.getName()));
 269                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
 270                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
 271                                 MDC.remove(SystemProperties.MDC_TIMER);
 272                         } else {
 273                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 274                                 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to saveRole for '"+role.getName()+"'", "Failed");
 275
 276                         }
 277                 } catch (Exception e) {
 278                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 279                         logger.error(EELFLoggerDelegate.errorLogger, "saveRole failed", e);
 280                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to saveRole", "Failed");
 281                 }
 282                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
 283         }
 284
 285         @ApiOperation(value = "Deletes role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 286         @RequestMapping(value = { "/deleteRole/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
 287         public  PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
 288                         @PathVariable String code) throws Exception {
 289                 try {
 290                         boolean deleteResponse = externalAccessRolesService.deleteRoleForApplication(code, request.getHeader(UEBKEY));
 291                         if(deleteResponse){
 292                                 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
 293                                 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 294                                 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRole: succeeded for app {}, role {}",
 295                                                 app.getId(), code);
 296                                 AuditLog auditLog = new AuditLog();
 297                                 auditLog.setUserId(user.getId());
 298                                 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE);
 299                                 auditLog.setComments(EcompPortalUtils.truncateString("Deleted role for app:"+app.getId()+" and role:'"+code+"'", PortalConstants.AUDIT_LOG_COMMENT_SIZE));
 300                                 auditLog.setAffectedRecordId(user.getOrgUserId());
 301                                 auditService.logActivity(auditLog, null);
 302                                 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP,
 303                                                 EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 304                                 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP,
 305                                                 EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 306                                 EcompPortalUtils.calculateDateTimeDifferenceForLog(
 307                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
 308                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
 309                                 logger.info(EELFLoggerDelegate.auditLogger,
 310                                                 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRole",
 311                                                                 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE, String.valueOf(user.getId()),
 312                                                                 user.getOrgUserId(), code));
 313                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
 314                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
 315                                 MDC.remove(SystemProperties.MDC_TIMER);
 316                         } else{
 317                                 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
 318                                 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to deleteRole for '"+code+"'", "Failed");
 319                         }
 320                 } catch (Exception e) {
 321                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 322                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
 323                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to deleteRole", "Failed");
 324                 }
 325                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Deleted", "Success");
 326
 327         }
 328
 329         @ApiOperation(value = "Gets active roles for an application.", response = CentralRole.class, responseContainer = "Json")
 330         @RequestMapping(value = { "/activeRoles" }, method = RequestMethod.GET, produces = "application/json")
 331         public  List<CentralRole> getActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
 332                 List<CentralRole> cenRole = null;
 333                 try {
 334                         cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
 335                 } catch (HttpClientErrorException e) {
 336                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 337                         logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
 338                 }
 339                 return cenRole;
 340
 341         }
 342
 343         @ApiOperation(value = "deletes user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 344         @RequestMapping(value = { "/deleteDependcyRoleRecord/{roleId}" }, method = RequestMethod.DELETE, produces = "application/json")
 345         public PortalRestResponse<String> deleteDependencyRoleRecord(HttpServletRequest request, HttpServletResponse response,
 346                         @PathVariable("roleId") Long roleId) throws Exception {
 347                 try {
 348                         boolean deleteResponse = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
 349                                         request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
 350                         if (!deleteResponse) {
 351                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 352                                 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteDependencyRoleRecord",
 353                                                 "Failed");
 354                         }
 355                 } catch (HttpClientErrorException e) {
 356                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 357                         logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord failed", e);
 358                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteDependencyRoleRecord",
 359                                         "Failed");
 360                 }
 361                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully Deleted", "Success");
 362         }
 363
 364         @ApiOperation(value = "Bulk upload functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 365         @RequestMapping(value = { "/upload/portal/functions" }, method = RequestMethod.POST, produces = "application/json")
 366         public  PortalRestResponse<String> bulkUploadFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
 367                 Integer result = 0;
 368                 try {
 369                         result = externalAccessRolesService.bulkUploadFunctions(request.getHeader(UEBKEY));
 370                 } catch (HttpClientErrorException e) {
 371                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 372                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
 373                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
 374                 }
 375                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
 376         }
 377
 378         @ApiOperation(value = "Bulk upload roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 379         @RequestMapping(value = { "/upload/portal/roles" }, method = RequestMethod.POST, produces = "application/json")
 380         public  PortalRestResponse<String> bulkUploadRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
 381                 Integer result = 0;
 382                 try {
 383                         result = externalAccessRolesService.bulkUploadRoles(request.getHeader(UEBKEY));
 384                 } catch (HttpClientErrorException e) {
 385                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 386                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
 387                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
 388                 }
 389                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
 390         }
 391
 392         @ApiOperation(value = "Bulk upload role functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 393         @RequestMapping(value = { "/upload/portal/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
 394         public  PortalRestResponse<String> bulkUploadRoleFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
 395                 Integer result = 0;
 396                 try {
 397                         result = externalAccessRolesService.bulkUploadRolesFunctions(request.getHeader(UEBKEY));
 398                 } catch (HttpClientErrorException e) {
 399                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 400                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoleFunctions failed", e);
 401                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoleFunctions", "Failed");
 402                 }
 403                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
 404         }
 405
 406         @ApiOperation(value = "Bulk upload user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 407         @RequestMapping(value = { "/upload/portal/userRoles" }, method = RequestMethod.POST, produces = "application/json")
 408         public  PortalRestResponse<String> bulkUploadUserRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
 409                 Integer result = 0;
 410                 try {
 411                         result = externalAccessRolesService.bulkUploadUserRoles(request.getHeader(UEBKEY));
 412                 } catch (HttpClientErrorException e) {
 413                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 414                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUserRoles failed", e);
 415                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUserRoles", "Failed");
 416                 }
 417                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
 418         }
 419
 420         @ApiOperation(value = "Bulk upload functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
 421         @RequestMapping(value = { "/upload/partner/functions" }, method = RequestMethod.POST, produces = "application/json")
 422         public  PortalRestResponse<String> bulkUploadPartnerFunctions(HttpServletRequest request, HttpServletResponse response, @RequestBody List<RoleFunction> upload) throws Exception {
 423                 try {
 424                         externalAccessRolesService.bulkUploadPartnerFunctions(request.getHeader(UEBKEY), upload);
 425                 } catch (HttpClientErrorException e) {
 426                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 427                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
 428                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
 429                 }
 430                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
 431         }
 432
 433         @ApiOperation(value = "Bulk upload roles for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
 434         @RequestMapping(value = { "/upload/partner/roles" }, method = RequestMethod.POST, produces = "application/json")
 435         public  PortalRestResponse<String> bulkUploadPartnerRoles(HttpServletRequest request, HttpServletResponse response, @RequestBody List<Role> upload) throws Exception {
 436                 try {
 437                         externalAccessRolesService.bulkUploadPartnerRoles(request.getHeader(UEBKEY), upload);
 438                 } catch (HttpClientErrorException e) {
 439                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 440                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
 441                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
 442                 }
 443                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
 444         }
 445
 446         @ApiOperation(value = "Bulk upload role functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
 447         @RequestMapping(value = { "/upload/partner/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
 448         public  PortalRestResponse<String> bulkUploadPartnerRoleFunctions(HttpServletRequest request, HttpServletResponse response, @RequestBody List<Role> upload) throws Exception {
 449                 try {
 450                         externalAccessRolesService.bulkUploadPartnerRoleFunctions(request.getHeader(UEBKEY), upload);
 451                 } catch (HttpClientErrorException e) {
 452                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 453                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
 454                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadPartnerRoleFunctions", "Failed");
 455                 }
 456                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
 457         }
 458
 459         @ApiOperation(value = "Gets all functions along with global functions", response = List.class, responseContainer = "Json")
 460         @RequestMapping(value = { "/menuFunctions" }, method = RequestMethod.GET, produces = "application/json")
 461         public  List<String> getMenuFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
 462                 List<String> functionsList = null;
 463                 try {
 464                         functionsList = externalAccessRolesService.getMenuFunctionsList(request.getHeader(UEBKEY));
 465                 } catch (HttpClientErrorException e) {
 466                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 467                         logger.error(EELFLoggerDelegate.errorLogger, "getMenuFunctions failed", e);
 468                 }
 469                 return functionsList;
 470         }
 471
 472 }