gerrit.onap Code Review - portal.git/blob

   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.ecomp.model.PortalRestResponse;
  13 import org.openecomp.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  14 import org.openecomp.portalapp.portal.logging.aop.EPAuditLog;
  15 import org.openecomp.portalapp.portal.service.ExternalAccessRolesService;
  16 import org.openecomp.portalapp.portal.transport.CentralRole;
  17 import org.openecomp.portalsdk.core.domain.Role;
  18 import org.openecomp.portalsdk.core.domain.RoleFunction;
  19 import org.openecomp.portalsdk.core.logging.logic.EELFLoggerDelegate;
  20 import org.springframework.beans.factory.annotation.Autowired;
  21 import org.springframework.context.annotation.EnableAspectJAutoProxy;
  22 import org.springframework.web.bind.annotation.PathVariable;
  23 import org.springframework.web.bind.annotation.RequestBody;
  24 import org.springframework.web.bind.annotation.RequestMapping;
  25 import org.springframework.web.bind.annotation.RequestMethod;
  26 import org.springframework.web.bind.annotation.RestController;
  27 import org.springframework.web.client.HttpClientErrorException;
  28
  29 import com.fasterxml.jackson.databind.ObjectMapper;
  30
  31 import io.swagger.annotations.ApiOperation;
  32
  33 @RestController
  34 @RequestMapping("/auxapi")
  35 @org.springframework.context.annotation.Configuration
  36 @EnableAspectJAutoProxy
  37 @EPAuditLog
  38 public class ExternalAccessRolesController implements BasicAuthenticationController {
  39
  40         private static final String UEBKEY = "uebkey";
  41
  42         private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ExternalAccessRolesController.class);
  43
  44         @Autowired
  45         private ExternalAccessRolesService externalAccessRolesService;
  46
  47         @ApiOperation(value = "Gets user role for an application.", response = String.class, responseContainer="List")
  48         @RequestMapping(value = {
  49                         "/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
  50         public String getUser(HttpServletRequest request, HttpServletResponse response, @PathVariable("loginId") String loginId) throws Exception {
  51
  52                 String answer = null;
  53                 try {
  54                         answer = externalAccessRolesService.getUser(loginId, request.getHeader(UEBKEY));
  55                 } catch (Exception e) {
  56                         logger.error(EELFLoggerDelegate.errorLogger, "getUser failed", e);
  57                 }
  58         return answer;
  59         }
  60
  61         @ApiOperation(value = "Gets roles for an application.", response = CentralRole.class, responseContainer="Json")
  62         @RequestMapping(value = {
  63                         "/roles" }, method = RequestMethod.GET, produces = "application/json")
  64         public List<CentralRole> getRolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
  65                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRolesForApp");
  66                 List<EPApp> applicationList=new ArrayList<>();
  67                 applicationList = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
  68                 EPApp app = applicationList.get(0);
  69         externalAccessRolesService.SyncApplicationRolesWithEcompDB(app);
  70                 List<CentralRole> answer = null;
  71                 try {
  72                         answer = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
  73                 } catch (HttpClientErrorException e) {
  74                         if("Application not found".equalsIgnoreCase(e.getMessage())){
  75                                 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
  76                         }
  77                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
  78                         logger.error(EELFLoggerDelegate.errorLogger, "getRolesForApp failed", e);
  79                 }
  80                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRolesForApp");
  81                 return answer;
  82         }
  83
  84         @ApiOperation(value = "Gets all role functions for an application.", response = CentralRoleFunction.class, responseContainer="Json")
  85         @RequestMapping(value = {
  86                         "/functions" }, method = RequestMethod.GET, produces = "application/json")
  87         public List<CentralRoleFunction> getRoleFunctionsList(HttpServletRequest request, HttpServletResponse response) throws Exception {
  88                 List<CentralRoleFunction> answer = null;
  89                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleFunctionsList");
  90                 try {
  91                         answer = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
  92                 } catch (HttpClientErrorException e) {
  93                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
  94                         logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunctionsList failed", e);
  95                 }
  96                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleFunctionsList");
  97                 return answer;
  98         }
  99
 100         @ApiOperation(value = "Gets role information for an application.", response = CentralRole.class, responseContainer="Json")
 101         @RequestMapping(value = {
 102                         "/role/{role_id}" }, method = RequestMethod.GET, produces = "application/json")
 103         public CentralRole getRoleInfo(HttpServletRequest request, HttpServletResponse response, @PathVariable("role_id") Long roleId) throws Exception {
 104                 CentralRole answer = null;
 105                 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleInfo");
 106
 107                 try {
 108                         answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
 109                 } catch (HttpClientErrorException e) {
 110                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 111                         logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo failed", e);
 112                 }
 113                 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleInfo");
 114                 return answer;
 115         }
 116
 117         @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralRoleFunction.class, responseContainer = "Json")
 118         @RequestMapping(value = { "/function/{code}" }, method = RequestMethod.GET, produces = "application/json")
 119         public CentralRoleFunction getRoleFunction(HttpServletRequest request, HttpServletResponse response,
 120                         @PathVariable("code") String code) throws Exception {
 121                 CentralRoleFunction centralRoleFunction = null;
 122                 try {
 123                         centralRoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
 124                 } catch (HttpClientErrorException e) {
 125                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 126                         logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo failed", e);
 127                 }
 128                 return centralRoleFunction;
 129         }
 130
 131         @ApiOperation(value = "Saves role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 132         @RequestMapping(value = { "/roleFunction" }, method = RequestMethod.POST, produces = "application/json")
 133         public PortalRestResponse<String> saveRoleFunction(HttpServletRequest request, HttpServletResponse response,
 134                         @RequestBody String roleFunc) throws Exception {
 135
 136                 ObjectMapper mapper = new ObjectMapper();
 137                 List<EPApp> applicationList = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
 138                 EPApp requestedApp = applicationList.get(0);
 139                 Long appId = requestedApp.getId();
 140                 try {
 141                          String data = roleFunc;
 142                         CentralRoleFunction availableRoleFunction = mapper.readValue(data, CentralRoleFunction.class);
 143                         availableRoleFunction.setAppId(appId);
 144                         externalAccessRolesService.saveCentralRoleFunction(availableRoleFunction, requestedApp);
 145                 } catch (Exception e) {
 146                         logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed", e);
 147                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
 148                 }
 149                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
 150         }
 151
 152         @ApiOperation(value = "Deletes role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 153         @RequestMapping(value = { "/roleFunction/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
 154         public  PortalRestResponse<String> deleteRoleFunction(HttpServletRequest request, HttpServletResponse response, @PathVariable("code") String code) throws Exception {
 155                 try {
 156                         externalAccessRolesService.deleteCentralRoleFunction(code, request.getHeader(UEBKEY));
 157                 } catch (HttpClientErrorException e) {
 158                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 159                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed", e);
 160                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to deleteRoleFunction", "Failed");
 161                 }
 162                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Deleted", "Success");
 163
 164         }
 165
 166         @ApiOperation(value = "Saves role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 167         @RequestMapping(value = { "/role" }, method = RequestMethod.POST, produces = "application/json")
 168         public PortalRestResponse<String> saveRole(HttpServletRequest request, HttpServletResponse response,
 169                         @RequestBody Role role) throws Exception {
 170                 try {
 171                         externalAccessRolesService.saveRoleForApplication(role,request.getHeader(UEBKEY));
 172                 } catch (Exception e) {
 173                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 174                         logger.error(EELFLoggerDelegate.errorLogger, "saveRole failed", e);
 175                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to saveRole", "Failed");
 176                 }
 177                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
 178         }
 179
 180         @ApiOperation(value = "Deletes role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 181         @RequestMapping(value = { "/deleteRole/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
 182         public  PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
 183                         @PathVariable String code) throws Exception {
 184                 try {
 185                         externalAccessRolesService.deleteRoleForApplication(code, request.getHeader(UEBKEY));
 186                 } catch (Exception e) {
 187                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 188                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
 189                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to deleteRole", "Failed");
 190                 }
 191                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Deleted", "Success");
 192
 193         }
 194
 195         @ApiOperation(value = "Gets active roles for an application.", response = CentralRole.class, responseContainer = "Json")
 196         @RequestMapping(value = { "/activeRoles" }, method = RequestMethod.GET, produces = "application/json")
 197         public  List<CentralRole> getActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
 198                 List<CentralRole> cenRole = null;
 199                 try {
 200                         cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
 201                 } catch (HttpClientErrorException e) {
 202                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 203                         logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
 204                 }
 205                 return cenRole;
 206
 207         }
 208
 209         @ApiOperation(value = "deletes user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 210         @RequestMapping(value = { "/deleteDependcyRoleRecord/{roleId}" }, method = RequestMethod.DELETE, produces = "application/json")
 211         public  PortalRestResponse<String> deleteDependcyRoleRecord(HttpServletRequest request, HttpServletResponse response, @PathVariable("roleId") Long roleId) throws Exception {
 212                 try {
 213                         externalAccessRolesService.deleteDependcyRoleRecord(roleId,request.getHeader(UEBKEY), request.getHeader("LoginId"));
 214                 } catch (HttpClientErrorException e) {
 215                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 216                         logger.error(EELFLoggerDelegate.errorLogger, "deleteDependcyRoleRecord failed", e);
 217                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to deleteDependcyRoleRecord", "Failed");
 218                 }
 219                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Deleted", "Success");
 220         }
 221
 222         @ApiOperation(value = "Bulk upload functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 223         @RequestMapping(value = { "/upload/portal/functions" }, method = RequestMethod.POST, produces = "application/json")
 224         public  PortalRestResponse<String> bulkUploadFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
 225                 Integer result = 0;
 226                 try {
 227                         result = externalAccessRolesService.bulkUploadFunctions(request.getHeader(UEBKEY));
 228                 } catch (HttpClientErrorException e) {
 229                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 230                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
 231                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
 232                 }
 233                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
 234         }
 235
 236         @ApiOperation(value = "Bulk upload roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 237         @RequestMapping(value = { "/upload/portal/roles" }, method = RequestMethod.POST, produces = "application/json")
 238         public  PortalRestResponse<String> bulkUploadRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
 239                 Integer result = 0;
 240                 try {
 241                         result = externalAccessRolesService.bulkUploadRoles(request.getHeader(UEBKEY));
 242                 } catch (HttpClientErrorException e) {
 243                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 244                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
 245                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
 246                 }
 247                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
 248         }
 249
 250         @ApiOperation(value = "Bulk upload role functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 251         @RequestMapping(value = { "/upload/portal/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
 252         public  PortalRestResponse<String> bulkUploadRoleFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
 253                 Integer result = 0;
 254                 try {
 255                         result = externalAccessRolesService.bulkUploadRolesFunctions(request.getHeader(UEBKEY));
 256                 } catch (HttpClientErrorException e) {
 257                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 258                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoleFunctions failed", e);
 259                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoleFunctions", "Failed");
 260                 }
 261                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
 262         }
 263
 264         @ApiOperation(value = "Bulk upload user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
 265         @RequestMapping(value = { "/upload/portal/userRoles" }, method = RequestMethod.POST, produces = "application/json")
 266         public  PortalRestResponse<String> bulkUploadUserRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
 267                 Integer result = 0;
 268                 try {
 269                         result = externalAccessRolesService.bulkUploadUserRoles(request.getHeader(UEBKEY));
 270                 } catch (HttpClientErrorException e) {
 271                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 272                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUserRoles failed", e);
 273                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUserRoles", "Failed");
 274                 }
 275                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
 276         }
 277
 278         @ApiOperation(value = "Bulk upload functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
 279         @RequestMapping(value = { "/upload/partner/functions" }, method = RequestMethod.POST, produces = "application/json")
 280         public  PortalRestResponse<String> bulkUploadPartnerFunctions(HttpServletRequest request, HttpServletResponse response, @RequestBody List<RoleFunction> upload) throws Exception {
 281                 try {
 282                         externalAccessRolesService.bulkUploadPartnerFunctions(request.getHeader(UEBKEY), upload);
 283                 } catch (HttpClientErrorException e) {
 284                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 285                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
 286                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
 287                 }
 288                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
 289         }
 290
 291         @ApiOperation(value = "Bulk upload roles for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
 292         @RequestMapping(value = { "/upload/partner/roles" }, method = RequestMethod.POST, produces = "application/json")
 293         public  PortalRestResponse<String> bulkUploadPartnerRoles(HttpServletRequest request, HttpServletResponse response, @RequestBody List<Role> upload) throws Exception {
 294                 try {
 295                         externalAccessRolesService.bulkUploadPartnerRoles(request.getHeader(UEBKEY), upload);
 296                 } catch (HttpClientErrorException e) {
 297                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 298                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
 299                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
 300                 }
 301                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
 302         }
 303
 304         @ApiOperation(value = "Bulk upload role functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
 305         @RequestMapping(value = { "/upload/partner/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
 306         public  PortalRestResponse<String> bulkUploadPartnerRoleFunctions(HttpServletRequest request, HttpServletResponse response, @RequestBody List<Role> upload) throws Exception {
 307                 try {
 308                         externalAccessRolesService.bulkUploadPartnerRoleFunctions(request.getHeader(UEBKEY), upload);
 309                 } catch (HttpClientErrorException e) {
 310                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 311                         logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
 312                         return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadPartnerRoleFunctions", "Failed");
 313                 }
 314                 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
 315         }
 316
 317         @ApiOperation(value = "Gets all functions along with global functions", response = List.class, responseContainer = "Json")
 318         @RequestMapping(value = { "/menuFunctions" }, method = RequestMethod.GET, produces = "application/json")
 319         public  List<String> getMenuFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
 320                 List<String> functionsList = null;
 321                 try {
 322                         functionsList = externalAccessRolesService.getMenuFunctionsList(request.getHeader(UEBKEY));
 323                 } catch (HttpClientErrorException e) {
 324                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 325                         logger.error(EELFLoggerDelegate.errorLogger, "getMenuFunctions failed", e);
 326                 }
 327                 return functionsList;
 328         }
 329
 330 }