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