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

   1 /*-
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal
   4  * ===================================================================
   5  * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
   6  * ===================================================================
   7  *
   8  * Unless otherwise specified, all software contained herein is licensed
   9  * under the Apache License, Version 2.0 (the “License”);
  10  * you may not use this software except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *             http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * Unless otherwise specified, all documentation contained herein is licensed
  22  * under the Creative Commons License, Attribution 4.0 Intl. (the “License”);
  23  * you may not use this documentation except in compliance with the License.
  24  * You may obtain a copy of the License at
  25  *
  26  *             https://creativecommons.org/licenses/by/4.0/
  27  *
  28  * Unless required by applicable law or agreed to in writing, documentation
  29  * distributed under the License is distributed on an "AS IS" BASIS,
  30  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  31  * See the License for the specific language governing permissions and
  32  * limitations under the License.
  33  *
  34  * ============LICENSE_END============================================
  35  *
  36  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  37  */
  38 package org.openecomp.portalapp.portal.controller;
  39
  40 import java.util.ArrayList;
  41 import java.util.List;
  42
  43 import javax.servlet.http.HttpServletRequest;
  44 import javax.servlet.http.HttpServletResponse;
  45
  46 import org.openecomp.portalapp.portal.domain.CentralRoleFunction;
  47 import org.openecomp.portalapp.portal.domain.EPApp;
  48 import org.openecomp.portalapp.portal.domain.EPUser;
  49 import org.openecomp.portalapp.portal.domain.EcompAuditLog;
  50 import org.openecomp.portalapp.portal.ecomp.model.PortalRestResponse;
  51 import org.openecomp.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  52 import org.openecomp.portalapp.portal.logging.aop.EPAuditLog;
  53 import org.openecomp.portalapp.portal.logging.aop.EPEELFLoggerAdvice;
  54 import org.openecomp.portalapp.portal.logging.logic.EPLogUtil;
  55 import org.openecomp.portalapp.portal.service.ExternalAccessRolesService;
  56 import org.openecomp.portalapp.portal.transport.CentralRole;
  57 import org.openecomp.portalapp.portal.utils.EPCommonSystemProperties;
  58 import org.openecomp.portalapp.portal.utils.EcompPortalUtils;
  59 import org.openecomp.portalapp.portal.utils.PortalConstants;
  60 import org.openecomp.portalsdk.core.domain.AuditLog;
  61 import org.openecomp.portalsdk.core.domain.Role;
  62 import org.openecomp.portalsdk.core.domain.RoleFunction;
  63 import org.openecomp.portalsdk.core.logging.logic.EELFLoggerDelegate;
  64 import org.openecomp.portalsdk.core.restful.domain.EcompUser;
  65 import org.openecomp.portalsdk.core.service.AuditService;
  66 import org.openecomp.portalsdk.core.util.SystemProperties;
  67 import org.slf4j.MDC;
  68 import org.springframework.beans.factory.annotation.Autowired;
  69 import org.springframework.context.annotation.EnableAspectJAutoProxy;
  70 import org.springframework.web.bind.annotation.PathVariable;
  71 import org.springframework.web.bind.annotation.RequestBody;
  72 import org.springframework.web.bind.annotation.RequestMapping;
  73 import org.springframework.web.bind.annotation.RequestMethod;
  74 import org.springframework.web.bind.annotation.RestController;
  75 import org.springframework.web.client.HttpClientErrorException;
  76
  77 import com.fasterxml.jackson.databind.ObjectMapper;
  78
  79 import io.swagger.annotations.ApiOperation;
  80
  81 @RestController
  82 @RequestMapping("/auxapi")
  83 @org.springframework.context.annotation.Configuration
  84 @EnableAspectJAutoProxy
  85 @EPAuditLog
  86 public class ExternalAccessRolesController implements BasicAuthenticationController {
  87
  88         private static final String LOGIN_ID = "LoginId";
  89
  90         @Autowired
  91         private AuditService auditService;
  92
  93         private static final String UEBKEY = "uebkey";
  94
  95         private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ExternalAccessRolesController.class);
  96
  97         @Autowired
  98         private ExternalAccessRolesService externalAccessRolesService;
  99
 100         @ApiOperation(value = "Gets user role for an application.", response = String.class, responseContainer = "List")
 101         @RequestMapping(value = { "/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
 102         public String getUser(HttpServletRequest request, HttpServletResponse response,
 103                         @PathVariable("loginId") String loginId) throws Exception {
 104
 105                 String answer = null;
 106                 try {
 107                         answer = externalAccessRolesService.getUserWithRoles(loginId, request.getHeader(UEBKEY));
 108                 } catch (Exception e) {
 109                         logger.error(EELFLoggerDelegate.errorLogger, "getUser failed", e);
 110                 }
 111                 return answer;
 112         }
 113
 114         @ApiOperation(value = "Gets roles for an application.", response = CentralRole.class, responseContainer = "Json")
 115         @RequestMapping(value = { "/roles" }, method = RequestMethod.GET, produces = "application/json")
 116         public List<CentralRole> getRolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
 117                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRolesForApp");
 118                 List<EPApp> applicationList = new ArrayList<>();
 119                 applicationList = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
 120                 EPApp app = applicationList.get(0);
 121                 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
 122                 List<CentralRole> answer = null;
 123                 try {
 124                         answer = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
 125                 } catch (HttpClientErrorException e) {
 126                         if ("Application not found".equalsIgnoreCase(e.getMessage())) {
 127                                 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
 128                         }
 129                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 130                         logger.error(EELFLoggerDelegate.errorLogger, "getRolesForApp failed", e);
 131                 }
 132                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRolesForApp");
 133                 return answer;
 134         }
 135
 136         @ApiOperation(value = "Gets all role functions for an application.", response = CentralRoleFunction.class, responseContainer = "Json")
 137         @RequestMapping(value = { "/functions" }, method = RequestMethod.GET, produces = "application/json")
 138         public List<CentralRoleFunction> getRoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
 139                         throws Exception {
 140                 List<CentralRoleFunction> answer = null;
 141                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleFunctionsList");
 142                 try {
 143                         answer = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
 144                 } catch (HttpClientErrorException e) {
 145                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 146                         logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunctionsList failed", e);
 147                 }
 148                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleFunctionsList");
 149                 return answer;
 150         }
 151
 152         @ApiOperation(value = "Gets role information for an application.", response = CentralRole.class, responseContainer = "Json")
 153         @RequestMapping(value = { "/role/{role_id}" }, method = RequestMethod.GET, produces = "application/json")
 154         public CentralRole getRoleInfo(HttpServletRequest request, HttpServletResponse response,
 155                         @PathVariable("role_id") Long roleId) throws Exception {
 156                 CentralRole answer = null;
 157                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleInfo");
 158
 159                 try {
 160                         answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
 161                 } catch (HttpClientErrorException e) {
 162                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 163                         logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo failed", e);
 164                 }
 165                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleInfo");
 166                 return answer;
 167         }
 168
 169         @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralRoleFunction.class, responseContainer = "Json")
 170         @RequestMapping(value = { "/function/{code}" }, method = RequestMethod.GET, produces = "application/json")
 171         public CentralRoleFunction getRoleFunction(HttpServletRequest request, HttpServletResponse response,
 172                         @PathVariable("code") String code) throws Exception {
 173                 CentralRoleFunction centralRoleFunction = null;
 174                 try {
 175                         centralRoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
 176                 } catch (HttpClientErrorException e) {
 177                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 178                         logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo failed", e);
 179                 }
 180                 return centralRoleFunction;
 181         }
 182
 183         @ApiOperation(value = "Saves role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 184         @RequestMapping(value = { "/roleFunction" }, method = RequestMethod.POST, produces = "application/json")
 185         public PortalRestResponse<String> saveRoleFunction(HttpServletRequest request, HttpServletResponse response,
 186                         @RequestBody String roleFunc) throws Exception {
 187
 188                 ObjectMapper mapper = new ObjectMapper();
 189                 List<EPApp> applicationList = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
 190                 EPApp requestedApp = applicationList.get(0);
 191                 Long appId = requestedApp.getId();
 192                 try {
 193                         String data = roleFunc;
 194                         CentralRoleFunction availableRoleFunction = mapper.readValue(data, CentralRoleFunction.class);
 195                         availableRoleFunction.setAppId(appId);
 196                         boolean saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(availableRoleFunction,
 197                                         requestedApp);
 198                         if (saveOrUpdateResponse) {
 199                                 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
 200                                 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 201                                 CentralRoleFunction function = externalAccessRolesService
 202                                                 .getRoleFunction(availableRoleFunction.getCode(), request.getHeader(UEBKEY));
 203                                 String activityCode = (function.getCode() == null)
 204                                                 ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_FUNCTION
 205                                                 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_FUNCTION;
 206                                 logger.info(EELFLoggerDelegate.applicationLogger, "saveRoleFunction: succeeded for app {}, function {}",
 207                                                 app.getId(), availableRoleFunction.getCode());
 208                                 AuditLog auditLog = new AuditLog();
 209                                 auditLog.setUserId(user.getId());
 210                                 auditLog.setActivityCode(activityCode);
 211                                 auditLog.setComments(
 212                                                 EcompPortalUtils.truncateString(
 213                                                                 "saveRoleFunction role for app:" + app.getId() + " and function:'"
 214                                                                                 + availableRoleFunction.getCode() + "'",
 215                                                                 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
 216                                 auditLog.setAffectedRecordId(user.getOrgUserId());
 217                                 auditService.logActivity(auditLog, null);
 218                                 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 219                                 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, 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.saveRoleFunction", activityCode,
 225                                                                 String.valueOf(user.getId()), user.getOrgUserId(), availableRoleFunction.getCode()));
 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, "saveRoleFunction failed");
 231                                 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
 232                                                 "Failed to saveRoleFunction for '" + availableRoleFunction.getCode() + "'", "Failed");
 233                         }
 234                 } catch (Exception e) {
 235                         logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed", e);
 236                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
 237                 }
 238                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
 239         }
 240
 241         @ApiOperation(value = "Deletes role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 242         @RequestMapping(value = { "/roleFunction/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
 243         public PortalRestResponse<String> deleteRoleFunction(HttpServletRequest request, HttpServletResponse response,
 244                         @PathVariable("code") String code) throws Exception {
 245                 try {
 246                         EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
 247                         EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 248                         boolean getDelFuncResponse = externalAccessRolesService.deleteCentralRoleFunction(code, app);
 249                         if (getDelFuncResponse) {
 250                                 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRoleFunction: succeeded for app {}, role {}",
 251                                                 app.getId(), code);
 252                                 AuditLog auditLog = new AuditLog();
 253                                 auditLog.setUserId(user.getId());
 254                                 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION);
 255                                 auditLog.setComments(EcompPortalUtils.truncateString(
 256                                                 "Deleted function for app:" + app.getId() + " and function code:'" + code + "'",
 257                                                 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
 258                                 auditLog.setAffectedRecordId(user.getOrgUserId());
 259                                 auditService.logActivity(auditLog, null);
 260                                 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 261                                 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 262                                 EcompPortalUtils.calculateDateTimeDifferenceForLog(
 263                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
 264                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
 265                                 logger.info(EELFLoggerDelegate.auditLogger,
 266                                                 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRoleFunction",
 267                                                                 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION, String.valueOf(user.getId()),
 268                                                                 user.getOrgUserId(), code));
 269                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
 270                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
 271                                 MDC.remove(SystemProperties.MDC_TIMER);
 272                         } else {
 273                                 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
 274                                 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
 275                                                 "Failed to deleteRoleFunction for '" + code + "'", "Failed");
 276                         }
 277                 } catch (HttpClientErrorException e) {
 278                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 279                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed", e);
 280                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
 281                                         "Failed to deleteRoleFunction for '" + code + "'", "Failed");
 282                 }
 283                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully Deleted", "Success");
 284
 285         }
 286
 287         @ApiOperation(value = "Saves role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 288         @RequestMapping(value = { "/role" }, method = RequestMethod.POST, produces = "application/json")
 289         public PortalRestResponse<String> saveRole(HttpServletRequest request, HttpServletResponse response,
 290                         @RequestBody Role role) throws Exception {
 291                 try {
 292                         EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
 293                         EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 294                         boolean getAddResponse = externalAccessRolesService.saveRoleForApplication(role, request.getHeader(UEBKEY));
 295                         if (getAddResponse) {
 296                                 String activityCode = (role.getId() == null) ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_ROLE
 297                                                 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_ROLE_AND_FUNCTION;
 298                                 logger.info(EELFLoggerDelegate.applicationLogger, "saveRole: succeeded for app {}, role {}",
 299                                                 app.getId(), role.getName());
 300                                 AuditLog auditLog = new AuditLog();
 301                                 auditLog.setUserId(user.getId());
 302                                 auditLog.setActivityCode(activityCode);
 303                                 auditLog.setComments(EcompPortalUtils.truncateString(
 304                                                 "saveRole role for app:" + app.getId() + " and role:'" + role.getName() + "'",
 305                                                 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
 306                                 auditLog.setAffectedRecordId(user.getOrgUserId());
 307                                 auditService.logActivity(auditLog, null);
 308                                 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 309                                 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 310                                 EcompPortalUtils.calculateDateTimeDifferenceForLog(
 311                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
 312                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
 313                                 logger.info(EELFLoggerDelegate.auditLogger,
 314                                                 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRole", activityCode,
 315                                                                 String.valueOf(user.getId()), user.getOrgUserId(), role.getName()));
 316                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
 317                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
 318                                 MDC.remove(SystemProperties.MDC_TIMER);
 319                         } else {
 320                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 321                                 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
 322                                                 "Failed to saveRole for '" + role.getName() + "'", "Failed");
 323
 324                         }
 325                 } catch (Exception e) {
 326                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 327                         logger.error(EELFLoggerDelegate.errorLogger, "saveRole failed", e);
 328                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to saveRole", "Failed");
 329                 }
 330                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
 331         }
 332
 333         @ApiOperation(value = "Deletes role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 334         @RequestMapping(value = { "/deleteRole/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
 335         public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
 336                         @PathVariable String code) throws Exception {
 337                 try {
 338                         boolean deleteResponse = externalAccessRolesService.deleteRoleForApplication(code,
 339                                         request.getHeader(UEBKEY));
 340                         if (deleteResponse) {
 341                                 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
 342                                 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
 343                                 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRole: succeeded for app {}, role {}",
 344                                                 app.getId(), code);
 345                                 AuditLog auditLog = new AuditLog();
 346                                 auditLog.setUserId(user.getId());
 347                                 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE);
 348                                 auditLog.setComments(EcompPortalUtils.truncateString(
 349                                                 "Deleted role for app:" + app.getId() + " and role:'" + code + "'",
 350                                                 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
 351                                 auditLog.setAffectedRecordId(user.getOrgUserId());
 352                                 auditService.logActivity(auditLog, null);
 353                                 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 354                                 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
 355                                 EcompPortalUtils.calculateDateTimeDifferenceForLog(
 356                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
 357                                                 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
 358                                 logger.info(EELFLoggerDelegate.auditLogger,
 359                                                 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRole",
 360                                                                 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE, String.valueOf(user.getId()),
 361                                                                 user.getOrgUserId(), code));
 362                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
 363                                 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
 364                                 MDC.remove(SystemProperties.MDC_TIMER);
 365                         } else {
 366                                 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
 367                                 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
 368                                                 "Failed to deleteRole for '" + code + "'", "Failed");
 369                         }
 370                 } catch (Exception e) {
 371                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 372                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
 373                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to deleteRole", "Failed");
 374                 }
 375                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Deleted", "Success");
 376
 377         }
 378
 379         @ApiOperation(value = "Gets active roles for an application.", response = CentralRole.class, responseContainer = "Json")
 380         @RequestMapping(value = { "/activeRoles" }, method = RequestMethod.GET, produces = "application/json")
 381         public List<CentralRole> getActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
 382                 List<CentralRole> cenRole = null;
 383                 try {
 384                         cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
 385                 } catch (HttpClientErrorException e) {
 386                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 387                         logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
 388                 }
 389                 return cenRole;
 390
 391         }
 392
 393         @ApiOperation(value = "deletes user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 394         @RequestMapping(value = {
 395                         "/deleteDependcyRoleRecord/{roleId}" }, method = RequestMethod.DELETE, produces = "application/json")
 396         public PortalRestResponse<String> deleteDependencyRoleRecord(HttpServletRequest request,
 397                         HttpServletResponse response, @PathVariable("roleId") Long roleId) throws Exception {
 398                 try {
 399                         boolean deleteResponse = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
 400                                         request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
 401                         if (!deleteResponse) {
 402                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 403                                 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteDependencyRoleRecord",
 404                                                 "Failed");
 405                         }
 406                 } catch (HttpClientErrorException e) {
 407                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 408                         logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord failed", e);
 409                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteDependencyRoleRecord",
 410                                         "Failed");
 411                 }
 412                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully Deleted", "Success");
 413         }
 414
 415         @ApiOperation(value = "Bulk upload functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 416         @RequestMapping(value = { "/upload/portal/functions" }, method = RequestMethod.POST, produces = "application/json")
 417         public PortalRestResponse<String> bulkUploadFunctions(HttpServletRequest request, HttpServletResponse response)
 418                         throws Exception {
 419                 Integer result = 0;
 420                 try {
 421                         result = externalAccessRolesService.bulkUploadFunctions(request.getHeader(UEBKEY));
 422                 } catch (HttpClientErrorException e) {
 423                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 424                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
 425                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions",
 426                                         "Failed");
 427                 }
 428                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
 429         }
 430
 431         @ApiOperation(value = "Bulk upload roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 432         @RequestMapping(value = { "/upload/portal/roles" }, method = RequestMethod.POST, produces = "application/json")
 433         public PortalRestResponse<String> bulkUploadRoles(HttpServletRequest request, HttpServletResponse response)
 434                         throws Exception {
 435                 Integer result = 0;
 436                 try {
 437                         result = externalAccessRolesService.bulkUploadRoles(request.getHeader(UEBKEY));
 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: " + result, "Success");
 444         }
 445
 446         @ApiOperation(value = "Bulk upload role functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 447         @RequestMapping(value = {
 448                         "/upload/portal/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
 449         public PortalRestResponse<String> bulkUploadRoleFunctions(HttpServletRequest request, HttpServletResponse response)
 450                         throws Exception {
 451                 Integer result = 0;
 452                 try {
 453                         result = externalAccessRolesService.bulkUploadRolesFunctions(request.getHeader(UEBKEY));
 454                 } catch (HttpClientErrorException e) {
 455                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 456                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoleFunctions failed", e);
 457                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoleFunctions",
 458                                         "Failed");
 459                 }
 460                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
 461         }
 462
 463         @ApiOperation(value = "Bulk upload user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 464         @RequestMapping(value = { "/upload/portal/userRoles" }, method = RequestMethod.POST, produces = "application/json")
 465         public PortalRestResponse<String> bulkUploadUserRoles(HttpServletRequest request, HttpServletResponse response)
 466                         throws Exception {
 467                 Integer result = 0;
 468                 try {
 469                         result = externalAccessRolesService.bulkUploadUserRoles(request.getHeader(UEBKEY));
 470                 } catch (HttpClientErrorException e) {
 471                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 472                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUserRoles failed", e);
 473                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUserRoles",
 474                                         "Failed");
 475                 }
 476                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
 477         }
 478
 479         @ApiOperation(value = "Bulk upload functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
 480         @RequestMapping(value = { "/upload/partner/functions" }, method = RequestMethod.POST, produces = "application/json")
 481         public PortalRestResponse<String> bulkUploadPartnerFunctions(HttpServletRequest request,
 482                         HttpServletResponse response, @RequestBody List<RoleFunction> upload) throws Exception {
 483                 try {
 484                         externalAccessRolesService.bulkUploadPartnerFunctions(request.getHeader(UEBKEY), upload);
 485                 } catch (HttpClientErrorException e) {
 486                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 487                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
 488                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions",
 489                                         "Failed");
 490                 }
 491                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
 492         }
 493
 494         @ApiOperation(value = "Bulk upload roles for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
 495         @RequestMapping(value = { "/upload/partner/roles" }, method = RequestMethod.POST, produces = "application/json")
 496         public PortalRestResponse<String> bulkUploadPartnerRoles(HttpServletRequest request, HttpServletResponse response,
 497                         @RequestBody List<Role> upload) throws Exception {
 498                 try {
 499                         externalAccessRolesService.bulkUploadPartnerRoles(request.getHeader(UEBKEY), upload);
 500                 } catch (HttpClientErrorException e) {
 501                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 502                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
 503                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
 504                 }
 505                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
 506         }
 507
 508         @ApiOperation(value = "Bulk upload role functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
 509         @RequestMapping(value = {
 510                         "/upload/partner/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
 511         public PortalRestResponse<String> bulkUploadPartnerRoleFunctions(HttpServletRequest request,
 512                         HttpServletResponse response, @RequestBody List<Role> upload) throws Exception {
 513                 try {
 514                         externalAccessRolesService.bulkUploadPartnerRoleFunctions(request.getHeader(UEBKEY), upload);
 515                 } catch (HttpClientErrorException e) {
 516                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 517                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
 518                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
 519                                         "Failed to bulkUploadPartnerRoleFunctions", "Failed");
 520                 }
 521                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
 522         }
 523
 524         @ApiOperation(value = "Gets all functions along with global functions", response = List.class, responseContainer = "Json")
 525         @RequestMapping(value = { "/menuFunctions" }, method = RequestMethod.GET, produces = "application/json")
 526         public List<String> getMenuFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
 527                 List<String> functionsList = null;
 528                 try {
 529                         functionsList = externalAccessRolesService.getMenuFunctionsList(request.getHeader(UEBKEY));
 530                 } catch (HttpClientErrorException e) {
 531                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 532                         logger.error(EELFLoggerDelegate.errorLogger, "getMenuFunctions failed", e);
 533                 }
 534                 return functionsList;
 535         }
 536
 537         @ApiOperation(value = "Gets all active Users of application", response = String.class, responseContainer = "Json")
 538         @RequestMapping(value = { "/users" }, method = RequestMethod.GET, produces = "application/json")
 539         public List<EcompUser> getUsersOfApplication(HttpServletRequest request, HttpServletResponse response)
 540                         throws Exception {
 541                 List<EcompUser> users = null;
 542                 try {
 543                         users = externalAccessRolesService.getAllAppUsers(request.getHeader(UEBKEY));
 544                 } catch (Exception e) {
 545                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 546                         logger.error(EELFLoggerDelegate.errorLogger, "getUsersOfApplication failed", e);
 547                         throw new Exception(e.getMessage());
 548                 }
 549                 return users;
 550         }
 551 }