2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
6 * ===================================================================
7 * Modification Copyright © 2020 IBM.
8 * ===================================================================
10 * Unless otherwise specified, all software contained herein is licensed
11 * under the Apache License, Version 2.0 (the "License");
12 * you may not use this software except in compliance with the License.
13 * You may obtain a copy of the License at
15 * http://www.apache.org/licenses/LICENSE-2.0
17 * Unless required by applicable law or agreed to in writing, software
18 * distributed under the License is distributed on an "AS IS" BASIS,
19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20 * See the License for the specific language governing permissions and
21 * limitations under the License.
23 * Unless otherwise specified, all documentation contained herein is licensed
24 * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
25 * you may not use this documentation except in compliance with the License.
26 * You may obtain a copy of the License at
28 * https://creativecommons.org/licenses/by/4.0/
30 * Unless required by applicable law or agreed to in writing, documentation
31 * distributed under the License is distributed on an "AS IS" BASIS,
32 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
33 * See the License for the specific language governing permissions and
34 * limitations under the License.
36 * ============LICENSE_END============================================
40 package org.onap.portalapp.portal.controller;
43 import java.io.IOException;
44 import java.util.ArrayList;
45 import java.util.HashMap;
46 import java.util.List;
49 import java.util.TreeSet;
51 import javax.servlet.http.HttpServletRequest;
52 import javax.servlet.http.HttpServletResponse;
54 import org.apache.commons.lang.StringUtils;
55 import org.onap.portalapp.portal.domain.CentralV2RoleFunction;
56 import org.onap.portalapp.portal.domain.EPApp;
57 import org.onap.portalapp.portal.domain.EPUser;
58 import org.onap.portalapp.portal.domain.EcompAuditLog;
59 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
60 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
61 import org.onap.portalapp.portal.exceptions.InvalidRoleException;
62 import org.onap.portalapp.portal.logging.aop.EPAuditLog;
63 import org.onap.portalapp.portal.logging.aop.EPEELFLoggerAdvice;
64 import org.onap.portalapp.portal.logging.logic.EPLogUtil;
65 import org.onap.portalapp.portal.service.ExternalAccessRolesService;
66 import org.onap.portalsdk.core.service.UserService;
67 import org.onap.portalapp.portal.transport.CentralRole;
68 import org.onap.portalapp.portal.transport.CentralRoleFunction;
69 import org.onap.portalapp.portal.transport.CentralUser;
70 import org.onap.portalapp.portal.transport.CentralV2Role;
71 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
72 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
73 import org.onap.portalapp.portal.utils.EcompPortalUtils;
74 import org.onap.portalapp.portal.utils.PortalConstants;
75 import org.onap.portalapp.validation.DataValidator;
76 import org.onap.portalapp.validation.SecureString;
77 import org.onap.portalsdk.core.domain.AuditLog;
78 import org.onap.portalsdk.core.domain.Role;
79 import org.onap.portalsdk.core.domain.User;
80 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
81 import org.onap.portalsdk.core.restful.domain.EcompRole;
82 import org.onap.portalsdk.core.restful.domain.EcompUser;
83 import org.onap.portalsdk.core.service.AuditService;
84 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
85 import org.onap.portalsdk.core.util.SystemProperties;
86 import org.onap.portalsdk.core.web.support.UserUtils;
88 import org.springframework.beans.BeanUtils;
89 import org.springframework.beans.factory.annotation.Autowired;
90 import org.springframework.context.annotation.EnableAspectJAutoProxy;
91 import org.springframework.http.ResponseEntity;
92 import org.springframework.web.bind.annotation.PathVariable;
93 import org.springframework.web.bind.annotation.RequestBody;
94 import org.springframework.web.bind.annotation.RequestMapping;
95 import org.springframework.web.bind.annotation.GetMapping;
96 import org.springframework.web.bind.annotation.PostMapping;
97 import org.springframework.web.bind.annotation.DeleteMapping;
98 import org.springframework.web.bind.annotation.RestController;
100 import com.fasterxml.jackson.databind.DeserializationFeature;
101 import com.fasterxml.jackson.databind.ObjectMapper;
102 import com.fasterxml.jackson.databind.type.TypeFactory;
104 import io.swagger.annotations.ApiOperation;
107 @RequestMapping("/auxapi")
108 @org.springframework.context.annotation.Configuration
109 @EnableAspectJAutoProxy
111 public class ExternalAccessRolesController implements BasicAuthenticationController {
112 private static final String ROLE_INVALID_CHARS = "%=():,\"\"";
113 private static final String SUCCESSFULLY_DELETED = "Successfully Deleted";
114 private static final String INVALID_UEB_KEY = "Invalid credentials!";
115 private static final String LOGIN_ID = "LoginId";
116 private static final String UEBKEY = "uebkey";
118 private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ExternalAccessRolesController.class);
119 private static final DataValidator DATA_VALIDATOR = new DataValidator();
122 private AuditService auditService;
125 private ExternalAccessRolesService externalAccessRolesService;
128 private UserService userservice = new UserServiceCentalizedImpl();
130 @ApiOperation(value = "Gets user role for an application.", response = CentralUser.class, responseContainer="List")
131 @GetMapping(value = {
132 "/user/{loginId}" }, produces = "application/json")
133 public CentralUser getUser(HttpServletRequest request, HttpServletResponse response,
134 @PathVariable("loginId") String loginId) throws Exception {
135 if (!DATA_VALIDATOR.isValid(new SecureString(loginId))){
136 sendErrorResponse(response, new Exception("Data is not valid"));
137 logger.error(EELFLoggerDelegate.errorLogger, "getUser not valid data");
140 CentralUser answer = null;
142 fieldsValidation(request);
143 answer = externalAccessRolesService.getUserRoles(loginId, request.getHeader(UEBKEY));
144 } catch (Exception e) {
145 sendErrorResponse(response, e);
146 logger.error(EELFLoggerDelegate.errorLogger, "getUser failed", e);
151 @ApiOperation(value = "Gets user roles for an application which is upgraded to newer version.", response = String.class, responseContainer="List")
152 @GetMapping(value = {
153 "/v1/user/{loginId}" }, produces = "application/json")
154 public String getV2UserList(HttpServletRequest request, HttpServletResponse response,
155 @PathVariable("loginId") String loginId) throws Exception {
156 if (!DATA_VALIDATOR.isValid(new SecureString(loginId))){
157 sendErrorResponse(response, new Exception("Data is not valid"));
158 logger.error(EELFLoggerDelegate.errorLogger, "getV2UserList not valid data");
159 return "Data is not valid";
161 String answer = null;
163 fieldsValidation(request);
164 answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
165 } catch (Exception e) {
166 sendErrorResponse(response, e);
167 logger.error(EELFLoggerDelegate.errorLogger, "getV2UserList failed", e);
172 @ApiOperation(value = "Gets roles for an application.", response = CentralRole.class, responseContainer="Json")
173 @GetMapping(value = {
174 "/roles" }, produces = "application/json")
175 public List<CentralRole> getRolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
176 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRolesForApp");
177 List<CentralV2Role> v2CenRole = null;
178 List<CentralRole> cenRole = null;
180 fieldsValidation(request);
181 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
182 // Sync all roles from external system into ONAP portal DB
183 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
184 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
185 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
186 v2CenRole = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
187 cenRole = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(v2CenRole);
188 } catch (Exception e) {
189 sendErrorResponse(response, e);
190 logger.error(EELFLoggerDelegate.errorLogger, "getRolesForApp failed", e);
192 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRolesForApp");
196 @ApiOperation(value = "Gets roles for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
197 @GetMapping(value = {
198 "/v1/roles" }, produces = "application/json")
199 public List<CentralV2Role> getV2RolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
200 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RolesForApp");
201 List<CentralV2Role> answer = null;
203 fieldsValidation(request);
204 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
205 // Sync all roles from external system into ONAP portal DB
206 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Entering into syncApplicationRolesWithEcompDB");
207 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
208 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Finished syncApplicationRolesWithEcompDB");
209 answer = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
210 } catch (Exception e) {
211 sendErrorResponse(response, e);
212 logger.error(EELFLoggerDelegate.errorLogger, "getV2RolesForApp failed", e);
214 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RolesForApp");
218 @ApiOperation(value = "Gets all role functions for an application for older version.", response = CentralRoleFunction.class, responseContainer="Json")
219 @GetMapping(value = {
220 "/functions" }, produces = "application/json")
221 public List<CentralRoleFunction> getRoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
223 List<CentralV2RoleFunction> answer = null;
224 List<CentralRoleFunction> roleFuncList = null;
225 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleFunctionsList");
227 fieldsValidation(request);
228 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
229 // Sync all functions from external system into ONAP portal DB
230 logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
231 externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
232 logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
233 answer = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
234 roleFuncList = externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(answer);
235 } catch (Exception e) {
236 sendErrorResponse(response, e);
237 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunctionsList failed", e);
239 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleFunctionsList");
243 @ApiOperation(value = "Gets all role functions for an application which is upgraded to newer version.", response = CentralV2RoleFunction.class, responseContainer="Json")
244 @GetMapping(value = {
245 "/v1/functions" }, produces = "application/json")
246 public List<CentralV2RoleFunction> getV2RoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
248 List<CentralV2RoleFunction> cenRoleFuncList = null;
249 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleFunctionsList");
251 fieldsValidation(request);
252 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
253 // Sync all functions from external system into ONAP portal DB
254 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
255 externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
256 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
257 cenRoleFuncList = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
258 } catch (Exception e) {
259 sendErrorResponse(response, e);
260 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunctionsList failed", e);
262 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleFunctionsList");
263 return cenRoleFuncList;
267 @ApiOperation(value = "Gets role information for an application.", response = CentralRole.class, responseContainer="Json")
268 @GetMapping(value = {
269 "/role/{role_id}" }, produces = "application/json")
270 public CentralRole getRoleInfo(HttpServletRequest request, HttpServletResponse response,
271 @PathVariable("role_id") Long roleId) throws Exception {
272 CentralV2Role answer = null;
273 CentralRole cenRole = null;
274 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleInfo");
276 fieldsValidation(request);
277 answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
278 cenRole = externalAccessRolesService.convertV2CentralRoleToOldVerisonCentralRole(answer);
279 } catch (Exception e) {
280 sendErrorResponse(response, e);
281 logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo failed", e);
283 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleInfo");
287 @ApiOperation(value = "Gets v2 role information for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
288 @GetMapping(value = {
289 "/v1/role/{role_id}" }, produces = "application/json")
290 public CentralV2Role getV2RoleInfo(HttpServletRequest request, HttpServletResponse response,
291 @PathVariable("role_id") Long roleId) throws Exception {
292 CentralV2Role answer = null;
293 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleInfo");
295 fieldsValidation(request);
296 answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
297 } catch (Exception e) {
298 sendErrorResponse(response, e);
299 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleInfo failed", e);
301 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleInfo");
305 @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralRoleFunction.class, responseContainer = "Json")
306 @GetMapping(value = { "/function/{code}" }, produces = "application/json")
307 public CentralRoleFunction getRoleFunction(HttpServletRequest request, HttpServletResponse response,
308 @PathVariable("code") String code) throws Exception {
309 CentralV2RoleFunction centralV2RoleFunction = null;
310 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
311 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
312 sendErrorResponse(response, new Exception("Data is not valid"));
313 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunction failed", new Exception("Data is not valid"));
316 fieldsValidation(request);
317 centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
318 if(centralV2RoleFunction != null && EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
319 BeanUtils.copyProperties(centralV2RoleFunction, centralRoleFunction, "type","action");
321 } catch (Exception e) {
322 sendErrorResponse(response, e);
323 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunction failed", e);
325 return centralRoleFunction;
328 @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralV2RoleFunction.class, responseContainer = "Json")
329 @GetMapping(value = { "/v1/function/{code}" }, produces = "application/json")
330 public CentralV2RoleFunction getV2RoleFunction(HttpServletRequest request, HttpServletResponse response,
331 @PathVariable("code") String code) throws Exception {
332 CentralV2RoleFunction centralV2RoleFunction = null;
333 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
334 sendErrorResponse(response, new Exception("Data is not valid"));
335 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunction failed", new Exception("Data is not valid"));
338 fieldsValidation(request);
339 centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
340 if(centralV2RoleFunction == null || !EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
341 centralV2RoleFunction = new CentralV2RoleFunction();
343 } catch (Exception e) {
344 sendErrorResponse(response, e);
345 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunction failed", e);
347 return centralV2RoleFunction;
350 @ApiOperation(value = "Saves role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
351 @PostMapping(value = { "/roleFunction" }, produces = "application/json")
352 public PortalRestResponse<String> saveRoleFunction(HttpServletRequest request, HttpServletResponse response,
353 @RequestBody String roleFunc) {
354 String status = "Successfully saved!";
355 if(!DATA_VALIDATOR.isValid(new SecureString(roleFunc))){
356 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed");
357 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
358 "Failed to roleFunc, not valid data.", "Failed");
361 fieldsValidation(request);
362 ObjectMapper mapper = new ObjectMapper();
363 List<EPApp> applicationList = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
364 EPApp requestedApp = applicationList.get(0);
365 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
366 CentralV2RoleFunction availableRoleFunction = mapper.readValue(roleFunc, CentralV2RoleFunction.class);
367 CentralV2RoleFunction domainRoleFunction = null;
368 boolean isCentralV2Version = false;
369 if(availableRoleFunction.getType()!=null && availableRoleFunction.getAction()!= null) {
370 isCentralV2Version = true;
372 if(isCentralV2Version) {
373 String code = availableRoleFunction.getType()+"|"+availableRoleFunction.getCode()+"|"+availableRoleFunction.getAction();
374 domainRoleFunction = externalAccessRolesService.getRoleFunction(code,
375 requestedApp.getUebKey());
377 domainRoleFunction = externalAccessRolesService.getRoleFunction(availableRoleFunction.getCode(),
378 requestedApp.getUebKey());
381 boolean saveOrUpdateResponse = false;
382 if (domainRoleFunction != null && isCentralV2Version && domainRoleFunction.getCode().equals(availableRoleFunction.getCode())
383 && domainRoleFunction.getType().equals(availableRoleFunction.getType())
384 && domainRoleFunction.getAction().equals(availableRoleFunction.getAction())) {
385 domainRoleFunction.setName(availableRoleFunction.getName());
386 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(domainRoleFunction,
389 availableRoleFunction.setAppId(requestedApp.getId());
390 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(availableRoleFunction,
394 if(domainRoleFunction != null) {
395 status = "Successfully updated!";
397 if (saveOrUpdateResponse) {
398 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
399 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
400 String activityCode = (!status.equals("Successfully updated!"))
401 ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_FUNCTION
402 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_FUNCTION;
403 logger.info(EELFLoggerDelegate.applicationLogger, "saveRoleFunction: succeeded for app {}, function {}",
404 app.getId(), availableRoleFunction.getCode());
405 AuditLog auditLog = new AuditLog();
406 auditLog.setUserId(user.getId());
407 auditLog.setActivityCode(activityCode);
408 auditLog.setComments(
409 EcompPortalUtils.truncateString(
410 "saveRoleFunction role for app:" + app.getId() + " and function:'"
411 + availableRoleFunction.getCode() + "'",
412 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
413 auditLog.setAffectedRecordId(user.getOrgUserId());
414 auditService.logActivity(auditLog, null);
415 String auditMessageInfo = EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRoleFunction", activityCode,
416 String.valueOf(user.getId()), user.getOrgUserId(), availableRoleFunction.getCode());
417 EPLogUtil.logAuditMessage(logger, auditMessageInfo);
420 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed");
421 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
422 "Failed to saveRoleFunction for '" + availableRoleFunction.getCode() + "'", "Failed");
424 } catch (Exception e) {
425 if (e.getMessage() == null ||e.getMessage().contains(INVALID_UEB_KEY)) {
426 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
428 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
430 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed", e);
431 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
433 return new PortalRestResponse<>(PortalRestStatusEnum.OK, status, "Success");
436 @ApiOperation(value = "Deletes role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
437 @DeleteMapping(value = { "/roleFunction/{code}" }, produces = "application/json")
438 public PortalRestResponse<String> deleteRoleFunction(HttpServletRequest request, HttpServletResponse response,
439 @PathVariable("code") String code) {
440 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
441 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
442 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
443 "Failed to deleteRoleFunction, not valid data.", "Failed");
446 fieldsValidation(request);
447 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
448 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
449 boolean getDelFuncResponse = externalAccessRolesService.deleteCentralRoleFunction(code, app);
450 if (getDelFuncResponse) {
451 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRoleFunction: succeeded for app {}, role {}",
453 AuditLog auditLog = new AuditLog();
454 auditLog.setUserId(user.getId());
455 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION);
456 auditLog.setComments(EcompPortalUtils.truncateString(
457 "Deleted function for app:" + app.getId() + " and function code:'" + code + "'",
458 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
459 auditLog.setAffectedRecordId(user.getOrgUserId());
460 auditService.logActivity(auditLog, null);
461 String auditMessageInfo = EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRoleFunction",
462 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION, String.valueOf(user.getId()),
463 user.getOrgUserId(), code);
464 EPLogUtil.logAuditMessage(logger, auditMessageInfo);
467 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
468 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
469 "Failed to deleteRoleFunction for '" + code + "'", "Failed");
471 } catch (Exception e) {
472 if (e.getMessage().contains(INVALID_UEB_KEY)) {
473 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
475 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
477 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed", e);
478 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
480 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
484 @ApiOperation(value = "Saves role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
485 @PostMapping(value = { "/role" }, produces = "application/json")
486 public PortalRestResponse<String> saveRole(HttpServletRequest request, HttpServletResponse response,
487 @RequestBody Role role) {
489 fieldsValidation(request);
490 ExternalRequestFieldsValidator saveRoleResult = null;
491 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
492 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
493 if(role.getId()!=null && StringUtils.containsAny(role.getName(), ROLE_INVALID_CHARS)) {
494 throw new InvalidRoleException("Invalid role name found for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed");
496 saveRoleResult = externalAccessRolesService.saveRoleForApplication(role, request.getHeader(UEBKEY));
497 if (saveRoleResult.isResult()) {
498 String activityCode = (role.getId() == null) ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_ROLE
499 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_ROLE_AND_FUNCTION;
500 logger.info(EELFLoggerDelegate.applicationLogger, "saveRole: succeeded for app {}, role {}",
501 app.getId(), role.getName());
502 AuditLog auditLog = new AuditLog();
503 auditLog.setUserId(user.getId());
504 auditLog.setActivityCode(activityCode);
505 auditLog.setComments(EcompPortalUtils.truncateString(
506 "saveRole role for app:" + app.getId() + " and role:'" + role.getName() + "'",
507 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
508 auditLog.setAffectedRecordId(user.getOrgUserId());
509 auditService.logActivity(auditLog, null);
510 String auditMessageInfo = EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRole", activityCode,
511 String.valueOf(user.getId()), user.getOrgUserId(), role.getName());
512 EPLogUtil.logAuditMessage(logger, auditMessageInfo);
515 if(saveRoleResult.getDetailMessage().contains("406")){
516 response.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
517 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
518 "Failed to create a role for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed"
521 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
522 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
523 "Failed to saveRole for '" + role.getName() + "'", "Failed");
526 } catch (Exception e) {
527 if (e.getMessage().contains(INVALID_UEB_KEY)) {
528 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
530 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
532 logger.error(EELFLoggerDelegate.errorLogger, "saveRole failed", e);
533 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
535 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
538 @ApiOperation(value = "Deletes role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
539 @DeleteMapping(value = { "/deleteRole/{code}" }, produces = "application/json")
540 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
541 @PathVariable String code) {
542 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
543 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
544 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
545 "Failed to deleteRole, not valid data.", "Failed");
548 fieldsValidation(request);
549 boolean deleteResponse = externalAccessRolesService.deleteRoleForApplication(code,
550 request.getHeader(UEBKEY));
551 if (deleteResponse) {
552 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
553 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
554 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRole: succeeded for app {}, role {}",
556 AuditLog auditLog = new AuditLog();
557 auditLog.setUserId(user.getId());
558 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE);
559 auditLog.setComments(EcompPortalUtils.truncateString(
560 "Deleted role for app:" + app.getId() + " and role:'" + code + "'",
561 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
562 auditLog.setAffectedRecordId(user.getOrgUserId());
563 auditService.logActivity(auditLog, null);
564 String auditMessageInfo = EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRole",
565 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE, String.valueOf(user.getId()),
566 user.getOrgUserId(), code);
567 EPLogUtil.logAuditMessage(logger, auditMessageInfo);
570 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
571 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
572 "Failed to deleteRole for '" + code + "'", "Failed");
574 } catch (Exception e) {
575 if (e.getMessage().contains(INVALID_UEB_KEY)) {
576 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
578 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
580 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
581 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
583 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
586 @ApiOperation(value = "Gets active roles for an application.", response = CentralRole.class, responseContainer = "Json")
587 @GetMapping(value = { "/activeRoles" }, produces = "application/json")
588 public List<CentralRole> getActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
589 List<CentralRole> roles = null;
591 fieldsValidation(request);
592 List<CentralV2Role> cenRoles= externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
593 roles = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles);
594 } catch (Exception e) {
595 sendErrorResponse(response, e);
596 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
602 @ApiOperation(value = "Gets active roles for an application.", response = CentralV2Role.class, responseContainer = "Json")
603 @GetMapping(value = { "/v1/activeRoles" }, produces = "application/json")
604 public List<CentralV2Role> getV2ActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
605 List<CentralV2Role> cenRole = null;
607 fieldsValidation(request);
608 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
609 } catch (Exception e) {
610 sendErrorResponse(response, e);
611 logger.error(EELFLoggerDelegate.errorLogger, "getV2ActiveRoles failed", e);
617 @ApiOperation(value = "deletes user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
618 @DeleteMapping(value = { "/deleteDependcyRoleRecord/{roleId}" }, produces = "application/json")
619 public PortalRestResponse<String> deleteDependencyRoleRecord(HttpServletRequest request, HttpServletResponse response,
620 @PathVariable("roleId") Long roleId) {
621 ExternalRequestFieldsValidator removeResult = null;
623 fieldsValidation(request);
624 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
625 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
626 if (!removeResult.isResult()) {
627 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
628 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteDependencyRoleRecord",
631 } catch (Exception e) {
632 if (e.getMessage().contains(INVALID_UEB_KEY)) {
633 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
635 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
637 logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord failed", e);
638 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
640 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
644 @ApiOperation(value = "deletes roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
645 @DeleteMapping(value = { "/v2/deleteRole/{roleId}" }, produces = "application/json")
646 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
647 @PathVariable("roleId") Long roleId) {
648 ExternalRequestFieldsValidator removeResult = null;
650 fieldsValidation(request);
651 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
652 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
653 if (!removeResult.isResult()) {
654 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
655 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteRole",
658 } catch (Exception e) {
659 if (e.getMessage().contains(INVALID_UEB_KEY)) {
660 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
662 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
664 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
665 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
667 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
671 @ApiOperation(value = "Bulk upload functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
672 @PostMapping(value = { "/upload/portal/functions" }, produces = "application/json")
673 public PortalRestResponse<String> bulkUploadFunctions(HttpServletRequest request, HttpServletResponse response) {
676 result = externalAccessRolesService.bulkUploadFunctions(request.getHeader(UEBKEY));
677 } catch (Exception e) {
678 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
679 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
680 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
682 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
685 @ApiOperation(value = "Bulk upload roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
686 @PostMapping(value = { "/upload/portal/roles" }, produces = "application/json")
687 public PortalRestResponse<String> bulkUploadRoles(HttpServletRequest request, HttpServletResponse response) {
690 result = externalAccessRolesService.bulkUploadRoles(request.getHeader(UEBKEY));
691 } catch (Exception e) {
692 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
693 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
694 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
696 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
699 @ApiOperation(value = "Bulk upload role functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
700 @PostMapping(value = { "/upload/portal/roleFunctions" }, produces = "application/json")
701 public PortalRestResponse<String> bulkUploadRoleFunctions(HttpServletRequest request, HttpServletResponse response) {
704 result = externalAccessRolesService.bulkUploadRolesFunctions(request.getHeader(UEBKEY));
705 } catch (Exception e) {
706 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
707 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoleFunctions failed", e);
708 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoleFunctions", "Failed");
710 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
713 @ApiOperation(value = "Bulk upload user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
714 @PostMapping(value = { "/upload/portal/userRoles" }, produces = "application/json")
715 public PortalRestResponse<String> bulkUploadUserRoles(HttpServletRequest request, HttpServletResponse response) {
718 result = externalAccessRolesService.bulkUploadUserRoles(request.getHeader(UEBKEY));
719 } catch (Exception e) {
720 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
721 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUserRoles failed", e);
722 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUserRoles", "Failed");
724 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
727 @ApiOperation(value = "Bulk upload users for renamed role of an application.", response = PortalRestResponse.class, responseContainer = "Json")
728 @PostMapping(value = { "/upload/portal/userRole/{roleId}" }, produces = "application/json")
729 public PortalRestResponse<String> bulkUploadUsersSingleRole(HttpServletRequest request, HttpServletResponse response, @PathVariable Long roleId) {
732 String roleName = request.getHeader("RoleName");
733 result = externalAccessRolesService.bulkUploadUsersSingleRole(request.getHeader(UEBKEY), roleId, roleName);
734 } catch (Exception e) {
735 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
736 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUsersSingleRole failed", e);
737 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUsersSingleRole", "Failed");
739 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
742 @ApiOperation(value = "Bulk upload functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
743 @PostMapping(value = { "/upload/partner/functions" }, produces = "application/json")
744 public PortalRestResponse<String> bulkUploadPartnerFunctions(HttpServletRequest request, HttpServletResponse response) {
745 Integer addedFunctions = 0;
747 addedFunctions = externalAccessRolesService.bulkUploadPartnerFunctions(request.getHeader(UEBKEY));
748 } catch (Exception e) {
749 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
750 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
751 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
753 return new PortalRestResponse<>(PortalRestStatusEnum.OK,
754 "Successfully added: '" + addedFunctions + "' functions", "Success");
757 @ApiOperation(value = "Bulk upload roles for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
758 @PostMapping(value = { "/upload/partner/roles" }, produces = "application/json")
759 public PortalRestResponse<String> bulkUploadPartnerRoles(HttpServletRequest request, HttpServletResponse response, @RequestBody List<Role> upload) {
761 externalAccessRolesService.bulkUploadPartnerRoles(request.getHeader(UEBKEY), upload);
762 } catch (Exception e) {
763 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
764 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
765 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
767 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added", "Success");
770 @ApiOperation(value = "Bulk upload role functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
771 @PostMapping(value = { "/upload/partner/roleFunctions" }, produces = "application/json")
772 public PortalRestResponse<String> bulkUploadPartnerRoleFunctions(HttpServletRequest request, HttpServletResponse response) {
773 Integer addedRoleFunctions = 0;
775 addedRoleFunctions = externalAccessRolesService.bulkUploadPartnerRoleFunctions(request.getHeader(UEBKEY));
776 } catch (Exception e) {
777 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
778 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadPartnerRoleFunctions failed", e);
779 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadPartnerRoleFunctions",
782 return new PortalRestResponse<>(PortalRestStatusEnum.OK,
783 "Successfully added: '" + addedRoleFunctions + "' role functions", "Success");
786 @ApiOperation(value = "Gets all functions along with global functions", response = List.class, responseContainer = "Json")
787 @GetMapping(value = { "/menuFunctions" }, produces = "application/json")
788 public List<String> getMenuFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
789 List<String> functionsList = null;
791 fieldsValidation(request);
792 functionsList = externalAccessRolesService.getMenuFunctionsList(request.getHeader(UEBKEY));
793 } catch (Exception e) {
794 sendErrorResponse(response, e);
795 logger.error(EELFLoggerDelegate.errorLogger, "getMenuFunctions failed", e);
797 return functionsList;
800 @ApiOperation(value = "Gets all active Users of application", response = String.class, responseContainer = "Json")
801 @GetMapping(value = { "/users" }, produces = "application/json")
802 public List<EcompUser> getUsersOfApplication(HttpServletRequest request, HttpServletResponse response) throws Exception {
803 List<EcompUser> users = null;
805 fieldsValidation(request);
806 users = externalAccessRolesService.getAllAppUsers(request.getHeader(UEBKEY));
807 } catch (Exception e) {
808 sendErrorResponse(response, e);
809 logger.error(EELFLoggerDelegate.errorLogger, "getUsersOfApplication failed", e);
816 * It checks the input uebkey of the application and throws exception if it is invalid key
821 private void fieldsValidation(HttpServletRequest request) throws Exception{
822 List<EPApp> app = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
824 throw new Exception(INVALID_UEB_KEY);
826 if(!app.isEmpty() && app.get(0).getRolesInAAF()){
827 ResponseEntity<String> response = externalAccessRolesService.getNameSpaceIfExists(app.get(0));
828 if (response.getStatusCode().value() == HttpServletResponse.SC_NOT_FOUND)
829 throw new Exception("Invalid NameSpace");
835 * It returns http response with appropriate message
839 * @throws IOException
841 private void sendErrorResponse(HttpServletResponse response, Exception e) throws IOException {
842 response.setContentType("application/json");
843 response.setCharacterEncoding("UTF-8");
844 final Map<String,String> uebkeyResponse = new HashMap<>();
845 ObjectMapper mapper = new ObjectMapper();
847 if (e.getMessage().contains(INVALID_UEB_KEY)) {
848 uebkeyResponse.put("error",INVALID_UEB_KEY);
849 reason = mapper.writeValueAsString(uebkeyResponse);
850 response.getWriter().write(reason);
851 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
853 uebkeyResponse.put("error",e.getMessage());
854 reason = mapper.writeValueAsString(uebkeyResponse);
855 response.getWriter().write(reason);
856 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
860 @ApiOperation(value = "Gets ecompUser of an application.", response = CentralUser.class, responseContainer = "List")
861 @GetMapping(value = { "/v2/user/{loginId}" }, produces = "application/json")
862 public String getEcompUser(HttpServletRequest request, HttpServletResponse response,
863 @PathVariable("loginId") String loginId) throws Exception {
864 if(!DATA_VALIDATOR.isValid(new SecureString(loginId))){
865 sendErrorResponse(response, new Exception("getEcompUser failed"));
866 logger.error(EELFLoggerDelegate.errorLogger, "getEcompUser failed", new Exception("getEcompUser failed"));
868 EcompUser user = new EcompUser();
869 ObjectMapper mapper = new ObjectMapper();
870 String answer = null;
872 fieldsValidation(request);
874 answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
875 if (answer != null) {
876 User ecompUser = userservice.userMapper(answer);
877 user = UserUtils.convertToEcompUser(ecompUser);
878 List<EcompRole> missingRolesOfUser = externalAccessRolesService.missingUserApplicationRoles(request.getHeader(UEBKEY), loginId, user.getRoles());
879 if (missingRolesOfUser.size() > 0) {
880 Set<EcompRole> roles = new TreeSet<>(missingRolesOfUser);
881 user.getRoles().addAll(roles);
884 } catch (Exception e) {
885 sendErrorResponse(response, e);
886 logger.error(EELFLoggerDelegate.errorLogger, "getEcompUser failed", e);
888 return mapper.writeValueAsString(user);
891 @ApiOperation(value = "Gets user ecomp role for an application.", response = CentralUser.class, responseContainer = "List")
892 @GetMapping(value = { "/v2/roles" }, produces = "application/json")
893 public List<EcompRole> getEcompRolesOfApplication(HttpServletRequest request, HttpServletResponse response)
895 List<EcompRole> ecompRoles = null;
896 ObjectMapper mapper = new ObjectMapper();
897 List<CentralV2Role> cenRole = null;
899 fieldsValidation(request);
900 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
901 // Sync all roles from external system into ONAP portal DB
902 logger.debug(EELFLoggerDelegate.debugLogger,
903 "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
904 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
905 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
906 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
907 } catch (Exception e) {
908 sendErrorResponse(response, e);
909 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
911 if (cenRole != null) {
912 String res = mapper.writeValueAsString(cenRole);
913 ecompRoles = new ArrayList<>();
914 List<Role> roles = mapper.readValue(res,
915 TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
916 for (Role role : roles)
917 ecompRoles.add(UserUtils.convertToEcompRole(role));
918 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getEcompRolesOfApplication");