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 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
416 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
417 EcompPortalUtils.calculateDateTimeDifferenceForLog(
418 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
419 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
420 logger.info(EELFLoggerDelegate.auditLogger,
421 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRoleFunction", activityCode,
422 String.valueOf(user.getId()), user.getOrgUserId(), availableRoleFunction.getCode()));
423 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
424 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
425 MDC.remove(SystemProperties.MDC_TIMER);
427 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed");
428 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
429 "Failed to saveRoleFunction for '" + availableRoleFunction.getCode() + "'", "Failed");
431 } catch (Exception e) {
432 if (e.getMessage() == null ||e.getMessage().contains(INVALID_UEB_KEY)) {
433 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
435 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
437 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed", e);
438 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
440 return new PortalRestResponse<>(PortalRestStatusEnum.OK, status, "Success");
443 @ApiOperation(value = "Deletes role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
444 @DeleteMapping(value = { "/roleFunction/{code}" }, produces = "application/json")
445 public PortalRestResponse<String> deleteRoleFunction(HttpServletRequest request, HttpServletResponse response,
446 @PathVariable("code") String code) {
447 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
448 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
449 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
450 "Failed to deleteRoleFunction, not valid data.", "Failed");
453 fieldsValidation(request);
454 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
455 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
456 boolean getDelFuncResponse = externalAccessRolesService.deleteCentralRoleFunction(code, app);
457 if (getDelFuncResponse) {
458 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRoleFunction: succeeded for app {}, role {}",
460 AuditLog auditLog = new AuditLog();
461 auditLog.setUserId(user.getId());
462 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION);
463 auditLog.setComments(EcompPortalUtils.truncateString(
464 "Deleted function for app:" + app.getId() + " and function code:'" + code + "'",
465 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
466 auditLog.setAffectedRecordId(user.getOrgUserId());
467 auditService.logActivity(auditLog, null);
468 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
469 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
470 EcompPortalUtils.calculateDateTimeDifferenceForLog(
471 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
472 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
473 logger.info(EELFLoggerDelegate.auditLogger,
474 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRoleFunction",
475 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION, String.valueOf(user.getId()),
476 user.getOrgUserId(), code));
477 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
478 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
479 MDC.remove(SystemProperties.MDC_TIMER);
481 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
482 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
483 "Failed to deleteRoleFunction for '" + code + "'", "Failed");
485 } catch (Exception e) {
486 if (e.getMessage().contains(INVALID_UEB_KEY)) {
487 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
489 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
491 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed", e);
492 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
494 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
498 @ApiOperation(value = "Saves role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
499 @PostMapping(value = { "/role" }, produces = "application/json")
500 public PortalRestResponse<String> saveRole(HttpServletRequest request, HttpServletResponse response,
501 @RequestBody Role role) {
503 fieldsValidation(request);
504 ExternalRequestFieldsValidator saveRoleResult = null;
505 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
506 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
507 if(role.getId()!=null && StringUtils.containsAny(role.getName(), ROLE_INVALID_CHARS)) {
508 throw new InvalidRoleException("Invalid role name found for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed");
510 saveRoleResult = externalAccessRolesService.saveRoleForApplication(role, request.getHeader(UEBKEY));
511 if (saveRoleResult.isResult()) {
512 String activityCode = (role.getId() == null) ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_ROLE
513 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_ROLE_AND_FUNCTION;
514 logger.info(EELFLoggerDelegate.applicationLogger, "saveRole: succeeded for app {}, role {}",
515 app.getId(), role.getName());
516 AuditLog auditLog = new AuditLog();
517 auditLog.setUserId(user.getId());
518 auditLog.setActivityCode(activityCode);
519 auditLog.setComments(EcompPortalUtils.truncateString(
520 "saveRole role for app:" + app.getId() + " and role:'" + role.getName() + "'",
521 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
522 auditLog.setAffectedRecordId(user.getOrgUserId());
523 auditService.logActivity(auditLog, null);
524 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
525 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
526 EcompPortalUtils.calculateDateTimeDifferenceForLog(
527 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
528 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
529 logger.info(EELFLoggerDelegate.auditLogger,
530 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRole", activityCode,
531 String.valueOf(user.getId()), user.getOrgUserId(), role.getName()));
532 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
533 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
534 MDC.remove(SystemProperties.MDC_TIMER);
536 if(saveRoleResult.getDetailMessage().contains("406")){
537 response.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
538 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
539 "Failed to create a role for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed"
542 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
543 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
544 "Failed to saveRole for '" + role.getName() + "'", "Failed");
547 } catch (Exception e) {
548 if (e.getMessage().contains(INVALID_UEB_KEY)) {
549 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
551 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
553 logger.error(EELFLoggerDelegate.errorLogger, "saveRole failed", e);
554 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
556 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
559 @ApiOperation(value = "Deletes role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
560 @DeleteMapping(value = { "/deleteRole/{code}" }, produces = "application/json")
561 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
562 @PathVariable String code) {
563 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
564 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
565 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
566 "Failed to deleteRole, not valid data.", "Failed");
569 fieldsValidation(request);
570 boolean deleteResponse = externalAccessRolesService.deleteRoleForApplication(code,
571 request.getHeader(UEBKEY));
572 if (deleteResponse) {
573 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
574 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
575 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRole: succeeded for app {}, role {}",
577 AuditLog auditLog = new AuditLog();
578 auditLog.setUserId(user.getId());
579 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE);
580 auditLog.setComments(EcompPortalUtils.truncateString(
581 "Deleted role for app:" + app.getId() + " and role:'" + code + "'",
582 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
583 auditLog.setAffectedRecordId(user.getOrgUserId());
584 auditService.logActivity(auditLog, null);
585 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
586 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
587 EcompPortalUtils.calculateDateTimeDifferenceForLog(
588 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
589 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
590 logger.info(EELFLoggerDelegate.auditLogger,
591 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRole",
592 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE, String.valueOf(user.getId()),
593 user.getOrgUserId(), code));
594 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
595 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
596 MDC.remove(SystemProperties.MDC_TIMER);
598 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
599 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
600 "Failed to deleteRole for '" + code + "'", "Failed");
602 } catch (Exception e) {
603 if (e.getMessage().contains(INVALID_UEB_KEY)) {
604 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
606 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
608 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
609 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
611 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
614 @ApiOperation(value = "Gets active roles for an application.", response = CentralRole.class, responseContainer = "Json")
615 @GetMapping(value = { "/activeRoles" }, produces = "application/json")
616 public List<CentralRole> getActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
617 List<CentralRole> roles = null;
619 fieldsValidation(request);
620 List<CentralV2Role> cenRoles= externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
621 roles = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles);
622 } catch (Exception e) {
623 sendErrorResponse(response, e);
624 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
630 @ApiOperation(value = "Gets active roles for an application.", response = CentralV2Role.class, responseContainer = "Json")
631 @GetMapping(value = { "/v1/activeRoles" }, produces = "application/json")
632 public List<CentralV2Role> getV2ActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
633 List<CentralV2Role> cenRole = null;
635 fieldsValidation(request);
636 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
637 } catch (Exception e) {
638 sendErrorResponse(response, e);
639 logger.error(EELFLoggerDelegate.errorLogger, "getV2ActiveRoles failed", e);
645 @ApiOperation(value = "deletes user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
646 @DeleteMapping(value = { "/deleteDependcyRoleRecord/{roleId}" }, produces = "application/json")
647 public PortalRestResponse<String> deleteDependencyRoleRecord(HttpServletRequest request, HttpServletResponse response,
648 @PathVariable("roleId") Long roleId) {
649 ExternalRequestFieldsValidator removeResult = null;
651 fieldsValidation(request);
652 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
653 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
654 if (!removeResult.isResult()) {
655 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
656 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteDependencyRoleRecord",
659 } catch (Exception e) {
660 if (e.getMessage().contains(INVALID_UEB_KEY)) {
661 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
663 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
665 logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord failed", e);
666 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
668 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
672 @ApiOperation(value = "deletes roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
673 @DeleteMapping(value = { "/v2/deleteRole/{roleId}" }, produces = "application/json")
674 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
675 @PathVariable("roleId") Long roleId) {
676 ExternalRequestFieldsValidator removeResult = null;
678 fieldsValidation(request);
679 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
680 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
681 if (!removeResult.isResult()) {
682 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
683 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteRole",
686 } catch (Exception e) {
687 if (e.getMessage().contains(INVALID_UEB_KEY)) {
688 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
690 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
692 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
693 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
695 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
699 @ApiOperation(value = "Bulk upload functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
700 @PostMapping(value = { "/upload/portal/functions" }, produces = "application/json")
701 public PortalRestResponse<String> bulkUploadFunctions(HttpServletRequest request, HttpServletResponse response) {
704 result = externalAccessRolesService.bulkUploadFunctions(request.getHeader(UEBKEY));
705 } catch (Exception e) {
706 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
707 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
708 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
710 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
713 @ApiOperation(value = "Bulk upload roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
714 @PostMapping(value = { "/upload/portal/roles" }, produces = "application/json")
715 public PortalRestResponse<String> bulkUploadRoles(HttpServletRequest request, HttpServletResponse response) {
718 result = externalAccessRolesService.bulkUploadRoles(request.getHeader(UEBKEY));
719 } catch (Exception e) {
720 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
721 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
722 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
724 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
727 @ApiOperation(value = "Bulk upload role functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
728 @PostMapping(value = { "/upload/portal/roleFunctions" }, produces = "application/json")
729 public PortalRestResponse<String> bulkUploadRoleFunctions(HttpServletRequest request, HttpServletResponse response) {
732 result = externalAccessRolesService.bulkUploadRolesFunctions(request.getHeader(UEBKEY));
733 } catch (Exception e) {
734 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
735 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoleFunctions failed", e);
736 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoleFunctions", "Failed");
738 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
741 @ApiOperation(value = "Bulk upload user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
742 @PostMapping(value = { "/upload/portal/userRoles" }, produces = "application/json")
743 public PortalRestResponse<String> bulkUploadUserRoles(HttpServletRequest request, HttpServletResponse response) {
746 result = externalAccessRolesService.bulkUploadUserRoles(request.getHeader(UEBKEY));
747 } catch (Exception e) {
748 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
749 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUserRoles failed", e);
750 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUserRoles", "Failed");
752 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
755 @ApiOperation(value = "Bulk upload users for renamed role of an application.", response = PortalRestResponse.class, responseContainer = "Json")
756 @PostMapping(value = { "/upload/portal/userRole/{roleId}" }, produces = "application/json")
757 public PortalRestResponse<String> bulkUploadUsersSingleRole(HttpServletRequest request, HttpServletResponse response, @PathVariable Long roleId) {
760 String roleName = request.getHeader("RoleName");
761 result = externalAccessRolesService.bulkUploadUsersSingleRole(request.getHeader(UEBKEY), roleId, roleName);
762 } catch (Exception e) {
763 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
764 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUsersSingleRole failed", e);
765 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUsersSingleRole", "Failed");
767 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
770 @ApiOperation(value = "Bulk upload functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
771 @PostMapping(value = { "/upload/partner/functions" }, produces = "application/json")
772 public PortalRestResponse<String> bulkUploadPartnerFunctions(HttpServletRequest request, HttpServletResponse response) {
773 Integer addedFunctions = 0;
775 addedFunctions = externalAccessRolesService.bulkUploadPartnerFunctions(request.getHeader(UEBKEY));
776 } catch (Exception e) {
777 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
778 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
779 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
781 return new PortalRestResponse<>(PortalRestStatusEnum.OK,
782 "Successfully added: '" + addedFunctions + "' functions", "Success");
785 @ApiOperation(value = "Bulk upload roles for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
786 @PostMapping(value = { "/upload/partner/roles" }, produces = "application/json")
787 public PortalRestResponse<String> bulkUploadPartnerRoles(HttpServletRequest request, HttpServletResponse response, @RequestBody List<Role> upload) {
789 externalAccessRolesService.bulkUploadPartnerRoles(request.getHeader(UEBKEY), upload);
790 } catch (Exception e) {
791 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
792 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
793 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
795 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added", "Success");
798 @ApiOperation(value = "Bulk upload role functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
799 @PostMapping(value = { "/upload/partner/roleFunctions" }, produces = "application/json")
800 public PortalRestResponse<String> bulkUploadPartnerRoleFunctions(HttpServletRequest request, HttpServletResponse response) {
801 Integer addedRoleFunctions = 0;
803 addedRoleFunctions = externalAccessRolesService.bulkUploadPartnerRoleFunctions(request.getHeader(UEBKEY));
804 } catch (Exception e) {
805 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
806 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadPartnerRoleFunctions failed", e);
807 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadPartnerRoleFunctions",
810 return new PortalRestResponse<>(PortalRestStatusEnum.OK,
811 "Successfully added: '" + addedRoleFunctions + "' role functions", "Success");
814 @ApiOperation(value = "Gets all functions along with global functions", response = List.class, responseContainer = "Json")
815 @GetMapping(value = { "/menuFunctions" }, produces = "application/json")
816 public List<String> getMenuFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
817 List<String> functionsList = null;
819 fieldsValidation(request);
820 functionsList = externalAccessRolesService.getMenuFunctionsList(request.getHeader(UEBKEY));
821 } catch (Exception e) {
822 sendErrorResponse(response, e);
823 logger.error(EELFLoggerDelegate.errorLogger, "getMenuFunctions failed", e);
825 return functionsList;
828 @ApiOperation(value = "Gets all active Users of application", response = String.class, responseContainer = "Json")
829 @GetMapping(value = { "/users" }, produces = "application/json")
830 public List<EcompUser> getUsersOfApplication(HttpServletRequest request, HttpServletResponse response) throws Exception {
831 List<EcompUser> users = null;
833 fieldsValidation(request);
834 users = externalAccessRolesService.getAllAppUsers(request.getHeader(UEBKEY));
835 } catch (Exception e) {
836 sendErrorResponse(response, e);
837 logger.error(EELFLoggerDelegate.errorLogger, "getUsersOfApplication failed", e);
844 * It checks the input uebkey of the application and throws exception if it is invalid key
849 private void fieldsValidation(HttpServletRequest request) throws Exception{
850 List<EPApp> app = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
852 throw new Exception(INVALID_UEB_KEY);
854 if(!app.isEmpty() && app.get(0).getCentralAuth()){
855 ResponseEntity<String> response = externalAccessRolesService.getNameSpaceIfExists(app.get(0));
856 if (response.getStatusCode().value() == HttpServletResponse.SC_NOT_FOUND)
857 throw new Exception("Invalid NameSpace");
863 * It returns http response with appropriate message
867 * @throws IOException
869 private void sendErrorResponse(HttpServletResponse response, Exception e) throws IOException {
870 response.setContentType("application/json");
871 response.setCharacterEncoding("UTF-8");
872 final Map<String,String> uebkeyResponse = new HashMap<>();
873 ObjectMapper mapper = new ObjectMapper();
875 if (e.getMessage().contains(INVALID_UEB_KEY)) {
876 uebkeyResponse.put("error",INVALID_UEB_KEY);
877 reason = mapper.writeValueAsString(uebkeyResponse);
878 response.getWriter().write(reason);
879 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
881 uebkeyResponse.put("error",e.getMessage());
882 reason = mapper.writeValueAsString(uebkeyResponse);
883 response.getWriter().write(reason);
884 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
888 @ApiOperation(value = "Gets ecompUser of an application.", response = CentralUser.class, responseContainer = "List")
889 @GetMapping(value = { "/v2/user/{loginId}" }, produces = "application/json")
890 public String getEcompUser(HttpServletRequest request, HttpServletResponse response,
891 @PathVariable("loginId") String loginId) throws Exception {
892 if(!DATA_VALIDATOR.isValid(new SecureString(loginId))){
893 sendErrorResponse(response, new Exception("getEcompUser failed"));
894 logger.error(EELFLoggerDelegate.errorLogger, "getEcompUser failed", new Exception("getEcompUser failed"));
896 EcompUser user = new EcompUser();
897 ObjectMapper mapper = new ObjectMapper();
898 String answer = null;
900 fieldsValidation(request);
902 answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
903 if (answer != null) {
904 User ecompUser = userservice.userMapper(answer);
905 user = UserUtils.convertToEcompUser(ecompUser);
906 List<EcompRole> missingRolesOfUser = externalAccessRolesService.missingUserApplicationRoles(request.getHeader(UEBKEY), loginId, user.getRoles());
907 if (missingRolesOfUser.size() > 0) {
908 Set<EcompRole> roles = new TreeSet<>(missingRolesOfUser);
909 user.getRoles().addAll(roles);
912 } catch (Exception e) {
913 sendErrorResponse(response, e);
914 logger.error(EELFLoggerDelegate.errorLogger, "getEcompUser failed", e);
916 return mapper.writeValueAsString(user);
919 @ApiOperation(value = "Gets user ecomp role for an application.", response = CentralUser.class, responseContainer = "List")
920 @GetMapping(value = { "/v2/roles" }, produces = "application/json")
921 public List<EcompRole> getEcompRolesOfApplication(HttpServletRequest request, HttpServletResponse response)
923 List<EcompRole> ecompRoles = null;
924 ObjectMapper mapper = new ObjectMapper();
925 List<CentralV2Role> cenRole = null;
927 fieldsValidation(request);
928 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
929 // Sync all roles from external system into ONAP portal DB
930 logger.debug(EELFLoggerDelegate.debugLogger,
931 "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
932 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
933 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
934 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
935 } catch (Exception e) {
936 sendErrorResponse(response, e);
937 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
939 if (cenRole != null) {
940 String res = mapper.writeValueAsString(cenRole);
941 ecompRoles = new ArrayList<>();
942 List<Role> roles = mapper.readValue(res,
943 TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
944 for (Role role : roles)
945 ecompRoles.add(UserUtils.convertToEcompRole(role));
946 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getEcompRolesOfApplication");