2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ===================================================================
8 * Unless otherwise specified, all software contained herein is licensed
9 * under the Apache License, Version 2.0 (the "License");
10 * you may not use this software except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
21 * Unless otherwise specified, all documentation contained herein is licensed
22 * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
23 * you may not use this documentation except in compliance with the License.
24 * You may obtain a copy of the License at
26 * https://creativecommons.org/licenses/by/4.0/
28 * Unless required by applicable law or agreed to in writing, documentation
29 * distributed under the License is distributed on an "AS IS" BASIS,
30 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
31 * See the License for the specific language governing permissions and
32 * limitations under the License.
34 * ============LICENSE_END============================================
38 package org.onap.portalapp.portal.controller;
41 import java.io.IOException;
42 import java.util.ArrayList;
43 import java.util.HashMap;
44 import java.util.List;
47 import javax.servlet.http.HttpServletRequest;
48 import javax.servlet.http.HttpServletResponse;
50 import org.apache.commons.lang.StringUtils;
51 import org.onap.portalapp.portal.domain.CentralV2RoleFunction;
52 import org.onap.portalapp.portal.domain.EPApp;
53 import org.onap.portalapp.portal.domain.EPUser;
54 import org.onap.portalapp.portal.domain.EcompAuditLog;
55 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
56 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
57 import org.onap.portalapp.portal.exceptions.InvalidRoleException;
58 import org.onap.portalapp.portal.logging.aop.EPAuditLog;
59 import org.onap.portalapp.portal.logging.aop.EPEELFLoggerAdvice;
60 import org.onap.portalapp.portal.logging.logic.EPLogUtil;
61 import org.onap.portalapp.portal.service.ExternalAccessRolesService;
62 import org.onap.portalapp.portal.transport.CentralRole;
63 import org.onap.portalapp.portal.transport.CentralRoleFunction;
64 import org.onap.portalapp.portal.transport.CentralUser;
65 import org.onap.portalapp.portal.transport.CentralV2Role;
66 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
67 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
68 import org.onap.portalapp.portal.utils.EcompPortalUtils;
69 import org.onap.portalapp.portal.utils.PortalConstants;
70 import org.onap.portalsdk.core.domain.AuditLog;
71 import org.onap.portalsdk.core.domain.Role;
72 import org.onap.portalsdk.core.domain.RoleFunction;
73 import org.onap.portalsdk.core.domain.User;
74 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
75 import org.onap.portalsdk.core.restful.domain.EcompRole;
76 import org.onap.portalsdk.core.restful.domain.EcompUser;
77 import org.onap.portalsdk.core.service.AuditService;
78 import org.onap.portalsdk.core.service.UserService;
79 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
80 import org.onap.portalsdk.core.util.SystemProperties;
81 import org.onap.portalsdk.core.web.support.UserUtils;
83 import org.springframework.beans.BeanUtils;
84 import org.springframework.beans.factory.annotation.Autowired;
85 import org.springframework.context.annotation.EnableAspectJAutoProxy;
86 import org.springframework.http.ResponseEntity;
87 import org.springframework.web.bind.annotation.PathVariable;
88 import org.springframework.web.bind.annotation.RequestBody;
89 import org.springframework.web.bind.annotation.RequestMapping;
90 import org.springframework.web.bind.annotation.RequestMethod;
91 import org.springframework.web.bind.annotation.RestController;
92 import org.springframework.web.client.RestTemplate;
94 import com.fasterxml.jackson.databind.DeserializationFeature;
95 import com.fasterxml.jackson.databind.ObjectMapper;
96 import com.fasterxml.jackson.databind.type.TypeFactory;
98 import io.swagger.annotations.ApiOperation;
101 @RequestMapping("/auxapi")
102 @org.springframework.context.annotation.Configuration
103 @EnableAspectJAutoProxy
105 public class ExternalAccessRolesController implements BasicAuthenticationController {
107 private static final String ROLE_INVALID_CHARS = "%=():,\"\"";
109 private static final String SUCCESSFULLY_DELETED = "Successfully Deleted";
111 private static final String INVALID_UEB_KEY = "Invalid uebkey!";
113 private static final String LOGIN_ID = "LoginId";
115 RestTemplate template = new RestTemplate();
118 private AuditService auditService;
120 private static final String UEBKEY = "uebkey";
122 private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ExternalAccessRolesController.class);
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 @RequestMapping(value = {
132 "/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
133 public CentralUser getUser(HttpServletRequest request, HttpServletResponse response,
134 @PathVariable("loginId") String loginId) throws Exception {
136 CentralUser answer = null;
138 fieldsValidation(request);
139 answer = externalAccessRolesService.getUserRoles(loginId, request.getHeader(UEBKEY));
140 } catch (Exception e) {
141 sendErrorResponse(response, e);
142 logger.error(EELFLoggerDelegate.errorLogger, "getUser failed", e);
147 @ApiOperation(value = "Gets user roles for an application which is upgraded to newer version.", response = String.class, responseContainer="List")
148 @RequestMapping(value = {
149 "/v1/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
150 public String getV2UserList(HttpServletRequest request, HttpServletResponse response,
151 @PathVariable("loginId") String loginId) throws Exception {
152 String answer = null;
154 fieldsValidation(request);
155 answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
156 } catch (Exception e) {
157 sendErrorResponse(response, e);
158 logger.error(EELFLoggerDelegate.errorLogger, "getV2UserList failed", e);
163 @ApiOperation(value = "Gets roles for an application.", response = CentralRole.class, responseContainer="Json")
164 @RequestMapping(value = {
165 "/roles" }, method = RequestMethod.GET, produces = "application/json")
166 public List<CentralRole> getRolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
167 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRolesForApp");
168 List<CentralV2Role> v2CenRole = null;
169 List<CentralRole> cenRole = null;
171 fieldsValidation(request);
172 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
173 // Sync all roles from external system into ONAP portal DB
174 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
175 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
176 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
177 v2CenRole = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
178 cenRole = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(v2CenRole);
179 } catch (Exception e) {
180 sendErrorResponse(response, e);
181 logger.error(EELFLoggerDelegate.errorLogger, "getRolesForApp failed", e);
183 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRolesForApp");
187 @ApiOperation(value = "Gets roles for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
188 @RequestMapping(value = {
189 "/v1/roles" }, method = RequestMethod.GET, produces = "application/json")
190 public List<CentralV2Role> getV2RolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
191 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RolesForApp");
192 List<CentralV2Role> answer = null;
194 fieldsValidation(request);
195 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
196 // Sync all roles from external system into ONAP portal DB
197 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Entering into syncApplicationRolesWithEcompDB");
198 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
199 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Finished syncApplicationRolesWithEcompDB");
200 answer = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
201 } catch (Exception e) {
202 sendErrorResponse(response, e);
203 logger.error(EELFLoggerDelegate.errorLogger, "getV2RolesForApp failed", e);
205 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RolesForApp");
209 @ApiOperation(value = "Gets all role functions for an application for older version.", response = CentralRoleFunction.class, responseContainer="Json")
210 @RequestMapping(value = {
211 "/functions" }, method = RequestMethod.GET, produces = "application/json")
212 public List<CentralRoleFunction> getRoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
214 List<CentralV2RoleFunction> answer = null;
215 List<CentralRoleFunction> roleFuncList = null;
216 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleFunctionsList");
218 fieldsValidation(request);
219 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
220 // Sync all functions from external system into ONAP portal DB
221 logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
222 externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
223 logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
224 answer = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
225 roleFuncList = externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(answer);
226 } catch (Exception e) {
227 sendErrorResponse(response, e);
228 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunctionsList failed", e);
230 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleFunctionsList");
234 @ApiOperation(value = "Gets all role functions for an application which is upgraded to newer version.", response = CentralV2RoleFunction.class, responseContainer="Json")
235 @RequestMapping(value = {
236 "/v1/functions" }, method = RequestMethod.GET, produces = "application/json")
237 public List<CentralV2RoleFunction> getV2RoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
239 List<CentralV2RoleFunction> cenRoleFuncList = null;
240 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleFunctionsList");
242 fieldsValidation(request);
243 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
244 // Sync all functions from external system into ONAP portal DB
245 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
246 externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
247 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
248 cenRoleFuncList = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
249 } catch (Exception e) {
250 sendErrorResponse(response, e);
251 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunctionsList failed", e);
253 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleFunctionsList");
254 return cenRoleFuncList;
258 @ApiOperation(value = "Gets role information for an application.", response = CentralRole.class, responseContainer="Json")
259 @RequestMapping(value = {
260 "/role/{role_id}" }, method = RequestMethod.GET, produces = "application/json")
261 public CentralRole getRoleInfo(HttpServletRequest request, HttpServletResponse response,
262 @PathVariable("role_id") Long roleId) throws Exception {
263 CentralV2Role answer = null;
264 CentralRole cenRole = null;
265 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleInfo");
267 fieldsValidation(request);
268 answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
269 cenRole = externalAccessRolesService.convertV2CentralRoleToOldVerisonCentralRole(answer);
270 } catch (Exception e) {
271 sendErrorResponse(response, e);
272 logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo failed", e);
274 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleInfo");
278 @ApiOperation(value = "Gets v2 role information for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
279 @RequestMapping(value = {
280 "/v1/role/{role_id}" }, method = RequestMethod.GET, produces = "application/json")
281 public CentralV2Role getV2RoleInfo(HttpServletRequest request, HttpServletResponse response,
282 @PathVariable("role_id") Long roleId) throws Exception {
283 CentralV2Role answer = null;
284 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleInfo");
286 fieldsValidation(request);
287 answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
288 } catch (Exception e) {
289 sendErrorResponse(response, e);
290 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleInfo failed", e);
292 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleInfo");
296 @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralRoleFunction.class, responseContainer = "Json")
297 @RequestMapping(value = { "/function/{code}" }, method = RequestMethod.GET, produces = "application/json")
298 public CentralRoleFunction getRoleFunction(HttpServletRequest request, HttpServletResponse response,
299 @PathVariable("code") String code) throws Exception {
300 CentralV2RoleFunction centralV2RoleFunction = null;
301 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
303 fieldsValidation(request);
304 centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
305 if(centralV2RoleFunction != null && EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
306 BeanUtils.copyProperties(centralV2RoleFunction, centralRoleFunction, "type","action");
308 } catch (Exception e) {
309 sendErrorResponse(response, e);
310 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunction failed", e);
312 return centralRoleFunction;
315 @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralV2RoleFunction.class, responseContainer = "Json")
316 @RequestMapping(value = { "/v1/function/{code}" }, method = RequestMethod.GET, produces = "application/json")
317 public CentralV2RoleFunction getV2RoleFunction(HttpServletRequest request, HttpServletResponse response,
318 @PathVariable("code") String code) throws Exception {
319 CentralV2RoleFunction centralV2RoleFunction = null;
321 fieldsValidation(request);
322 centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
323 if(centralV2RoleFunction == null || !EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
324 centralV2RoleFunction = new CentralV2RoleFunction();
326 } catch (Exception e) {
327 sendErrorResponse(response, e);
328 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunction failed", e);
330 return centralV2RoleFunction;
333 @ApiOperation(value = "Saves role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
334 @RequestMapping(value = { "/roleFunction" }, method = RequestMethod.POST, produces = "application/json")
335 public PortalRestResponse<String> saveRoleFunction(HttpServletRequest request, HttpServletResponse response,
336 @RequestBody String roleFunc) throws Exception {
338 fieldsValidation(request);
339 String data = roleFunc;
340 ObjectMapper mapper = new ObjectMapper();
341 List<EPApp> applicationList = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
342 EPApp requestedApp = applicationList.get(0);
343 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
344 CentralV2RoleFunction availableRoleFunction = mapper.readValue(data, CentralV2RoleFunction.class);
345 CentralV2RoleFunction domainRoleFunction = null;
346 if(availableRoleFunction.getType()!=null && availableRoleFunction.getAction()!= null) {
347 String code = availableRoleFunction.getType()+"|"+availableRoleFunction.getCode()+"|"+availableRoleFunction.getAction();
348 domainRoleFunction = externalAccessRolesService.getRoleFunction(code,
349 requestedApp.getUebKey());
351 domainRoleFunction = externalAccessRolesService.getRoleFunction(availableRoleFunction.getCode(),
352 requestedApp.getUebKey());
355 boolean saveOrUpdateResponse = false;
356 if (domainRoleFunction != null && domainRoleFunction.getCode().equals(availableRoleFunction.getCode())
357 && domainRoleFunction.getType().equals(availableRoleFunction.getType())
358 && domainRoleFunction.getAction().equals(availableRoleFunction.getAction())) {
359 domainRoleFunction.setName(availableRoleFunction.getName());
360 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(domainRoleFunction,
363 availableRoleFunction.setAppId(requestedApp.getId());
364 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(availableRoleFunction,
367 if (saveOrUpdateResponse) {
368 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
369 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
370 CentralV2RoleFunction function = externalAccessRolesService
371 .getRoleFunction(availableRoleFunction.getCode(), request.getHeader(UEBKEY));
372 String activityCode = (function.getCode() == null)
373 ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_FUNCTION
374 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_FUNCTION;
375 logger.info(EELFLoggerDelegate.applicationLogger, "saveRoleFunction: succeeded for app {}, function {}",
376 app.getId(), availableRoleFunction.getCode());
377 AuditLog auditLog = new AuditLog();
378 auditLog.setUserId(user.getId());
379 auditLog.setActivityCode(activityCode);
380 auditLog.setComments(
381 EcompPortalUtils.truncateString(
382 "saveRoleFunction role for app:" + app.getId() + " and function:'"
383 + availableRoleFunction.getCode() + "'",
384 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
385 auditLog.setAffectedRecordId(user.getOrgUserId());
386 auditService.logActivity(auditLog, null);
387 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
388 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
389 EcompPortalUtils.calculateDateTimeDifferenceForLog(
390 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
391 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
392 logger.info(EELFLoggerDelegate.auditLogger,
393 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRoleFunction", activityCode,
394 String.valueOf(user.getId()), user.getOrgUserId(), availableRoleFunction.getCode()));
395 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
396 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
397 MDC.remove(SystemProperties.MDC_TIMER);
399 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed");
400 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
401 "Failed to saveRoleFunction for '" + availableRoleFunction.getCode() + "'", "Failed");
403 } catch (Exception e) {
404 if (e.getMessage().contains(INVALID_UEB_KEY)) {
405 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
407 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
409 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed", e);
410 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
412 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
415 @ApiOperation(value = "Deletes role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
416 @RequestMapping(value = { "/roleFunction/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
417 public PortalRestResponse<String> deleteRoleFunction(HttpServletRequest request, HttpServletResponse response,
418 @PathVariable("code") String code) throws Exception {
420 fieldsValidation(request);
421 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
422 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
423 boolean getDelFuncResponse = externalAccessRolesService.deleteCentralRoleFunction(code, app);
424 if (getDelFuncResponse) {
425 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRoleFunction: succeeded for app {}, role {}",
427 AuditLog auditLog = new AuditLog();
428 auditLog.setUserId(user.getId());
429 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION);
430 auditLog.setComments(EcompPortalUtils.truncateString(
431 "Deleted function for app:" + app.getId() + " and function code:'" + code + "'",
432 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
433 auditLog.setAffectedRecordId(user.getOrgUserId());
434 auditService.logActivity(auditLog, null);
435 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
436 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
437 EcompPortalUtils.calculateDateTimeDifferenceForLog(
438 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
439 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
440 logger.info(EELFLoggerDelegate.auditLogger,
441 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRoleFunction",
442 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION, String.valueOf(user.getId()),
443 user.getOrgUserId(), code));
444 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
445 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
446 MDC.remove(SystemProperties.MDC_TIMER);
448 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
449 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
450 "Failed to deleteRoleFunction for '" + code + "'", "Failed");
452 } catch (Exception e) {
453 if (e.getMessage().contains(INVALID_UEB_KEY)) {
454 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
456 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
458 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed", e);
459 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
461 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
465 @ApiOperation(value = "Saves role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
466 @RequestMapping(value = { "/role" }, method = RequestMethod.POST, produces = "application/json")
467 public PortalRestResponse<String> saveRole(HttpServletRequest request, HttpServletResponse response,
468 @RequestBody Role role) throws Exception {
470 fieldsValidation(request);
471 ExternalRequestFieldsValidator saveRoleResult = null;
472 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
473 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
474 if(role.getId()!=null && StringUtils.containsAny(role.getName(), ROLE_INVALID_CHARS)) {
475 throw new InvalidRoleException("Invalid role name found for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed");
477 saveRoleResult = externalAccessRolesService.saveRoleForApplication(role, request.getHeader(UEBKEY));
478 if (saveRoleResult.isResult()) {
479 String activityCode = (role.getId() == null) ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_ROLE
480 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_ROLE_AND_FUNCTION;
481 logger.info(EELFLoggerDelegate.applicationLogger, "saveRole: succeeded for app {}, role {}",
482 app.getId(), role.getName());
483 AuditLog auditLog = new AuditLog();
484 auditLog.setUserId(user.getId());
485 auditLog.setActivityCode(activityCode);
486 auditLog.setComments(EcompPortalUtils.truncateString(
487 "saveRole role for app:" + app.getId() + " and role:'" + role.getName() + "'",
488 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
489 auditLog.setAffectedRecordId(user.getOrgUserId());
490 auditService.logActivity(auditLog, null);
491 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
492 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
493 EcompPortalUtils.calculateDateTimeDifferenceForLog(
494 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
495 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
496 logger.info(EELFLoggerDelegate.auditLogger,
497 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRole", activityCode,
498 String.valueOf(user.getId()), user.getOrgUserId(), role.getName()));
499 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
500 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
501 MDC.remove(SystemProperties.MDC_TIMER);
503 if(saveRoleResult.getDetailMessage().contains("406")){
504 response.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
505 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
506 "Failed to create a role for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed"
509 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
510 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
511 "Failed to saveRole for '" + role.getName() + "'", "Failed");
514 } catch (Exception e) {
515 if (e.getMessage().contains(INVALID_UEB_KEY)) {
516 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
518 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
520 logger.error(EELFLoggerDelegate.errorLogger, "saveRole failed", e);
521 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
523 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
526 @ApiOperation(value = "Deletes role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
527 @RequestMapping(value = { "/deleteRole/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
528 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
529 @PathVariable String code) throws Exception {
531 fieldsValidation(request);
532 boolean deleteResponse = externalAccessRolesService.deleteRoleForApplication(code,
533 request.getHeader(UEBKEY));
534 if (deleteResponse) {
535 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
536 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
537 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRole: succeeded for app {}, role {}",
539 AuditLog auditLog = new AuditLog();
540 auditLog.setUserId(user.getId());
541 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE);
542 auditLog.setComments(EcompPortalUtils.truncateString(
543 "Deleted role for app:" + app.getId() + " and role:'" + code + "'",
544 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
545 auditLog.setAffectedRecordId(user.getOrgUserId());
546 auditService.logActivity(auditLog, null);
547 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
548 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
549 EcompPortalUtils.calculateDateTimeDifferenceForLog(
550 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
551 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
552 logger.info(EELFLoggerDelegate.auditLogger,
553 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRole",
554 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE, String.valueOf(user.getId()),
555 user.getOrgUserId(), code));
556 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
557 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
558 MDC.remove(SystemProperties.MDC_TIMER);
560 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
561 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
562 "Failed to deleteRole for '" + code + "'", "Failed");
564 } catch (Exception e) {
565 if (e.getMessage().contains(INVALID_UEB_KEY)) {
566 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
568 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
570 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
571 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
573 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
576 @ApiOperation(value = "Gets active roles for an application.", response = CentralRole.class, responseContainer = "Json")
577 @RequestMapping(value = { "/activeRoles" }, method = RequestMethod.GET, produces = "application/json")
578 public List<CentralRole> getActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
579 List<CentralRole> roles = null;
581 fieldsValidation(request);
582 List<CentralV2Role> cenRoles= externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
583 roles = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles);
584 } catch (Exception e) {
585 sendErrorResponse(response, e);
586 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
592 @ApiOperation(value = "Gets active roles for an application.", response = CentralV2Role.class, responseContainer = "Json")
593 @RequestMapping(value = { "/v1/activeRoles" }, method = RequestMethod.GET, produces = "application/json")
594 public List<CentralV2Role> getV2ActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
595 List<CentralV2Role> cenRole = null;
597 fieldsValidation(request);
598 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
599 } catch (Exception e) {
600 sendErrorResponse(response, e);
601 logger.error(EELFLoggerDelegate.errorLogger, "getV2ActiveRoles failed", e);
607 @ApiOperation(value = "deletes user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
608 @RequestMapping(value = { "/deleteDependcyRoleRecord/{roleId}" }, method = RequestMethod.DELETE, produces = "application/json")
609 public PortalRestResponse<String> deleteDependencyRoleRecord(HttpServletRequest request, HttpServletResponse response,
610 @PathVariable("roleId") Long roleId) throws Exception {
611 ExternalRequestFieldsValidator removeResult = null;
613 fieldsValidation(request);
614 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
615 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
616 if (!removeResult.isResult()) {
617 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
618 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteDependencyRoleRecord",
621 } catch (Exception e) {
622 if (e.getMessage().contains(INVALID_UEB_KEY)) {
623 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
625 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
627 logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord failed", e);
628 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
630 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
634 @ApiOperation(value = "deletes roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
635 @RequestMapping(value = { "/v2/deleteRole/{roleId}" }, method = RequestMethod.DELETE, produces = "application/json")
636 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
637 @PathVariable("roleId") Long roleId) throws Exception {
638 ExternalRequestFieldsValidator removeResult = null;
640 fieldsValidation(request);
641 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
642 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
643 if (!removeResult.isResult()) {
644 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
645 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteRole",
648 } catch (Exception e) {
649 if (e.getMessage().contains(INVALID_UEB_KEY)) {
650 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
652 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
654 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
655 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
657 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
661 @ApiOperation(value = "Bulk upload functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
662 @RequestMapping(value = { "/upload/portal/functions" }, method = RequestMethod.POST, produces = "application/json")
663 public PortalRestResponse<String> bulkUploadFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
666 result = externalAccessRolesService.bulkUploadFunctions(request.getHeader(UEBKEY));
667 } catch (Exception e) {
668 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
669 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
670 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
672 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
675 @ApiOperation(value = "Bulk upload roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
676 @RequestMapping(value = { "/upload/portal/roles" }, method = RequestMethod.POST, produces = "application/json")
677 public PortalRestResponse<String> bulkUploadRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
680 result = externalAccessRolesService.bulkUploadRoles(request.getHeader(UEBKEY));
681 } catch (Exception e) {
682 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
683 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
684 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
686 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
689 @ApiOperation(value = "Bulk upload role functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
690 @RequestMapping(value = { "/upload/portal/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
691 public PortalRestResponse<String> bulkUploadRoleFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
694 result = externalAccessRolesService.bulkUploadRolesFunctions(request.getHeader(UEBKEY));
695 } catch (Exception e) {
696 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
697 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoleFunctions failed", e);
698 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoleFunctions", "Failed");
700 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
703 @ApiOperation(value = "Bulk upload user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
704 @RequestMapping(value = { "/upload/portal/userRoles" }, method = RequestMethod.POST, produces = "application/json")
705 public PortalRestResponse<String> bulkUploadUserRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
708 result = externalAccessRolesService.bulkUploadUserRoles(request.getHeader(UEBKEY));
709 } catch (Exception e) {
710 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
711 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUserRoles failed", e);
712 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUserRoles", "Failed");
714 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
717 @ApiOperation(value = "Bulk upload users for renamed role of an application.", response = PortalRestResponse.class, responseContainer = "Json")
718 @RequestMapping(value = { "/upload/portal/userRole/{roleId}" }, method = RequestMethod.POST, produces = "application/json")
719 public PortalRestResponse<String> bulkUploadUsersSingleRole(HttpServletRequest request, HttpServletResponse response, @PathVariable Long roleId) throws Exception {
722 String roleName = request.getHeader("RoleName");
723 result = externalAccessRolesService.bulkUploadUsersSingleRole(request.getHeader(UEBKEY), roleId, roleName);
724 } catch (Exception e) {
725 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
726 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUsersSingleRole failed", e);
727 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUsersSingleRole", "Failed");
729 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
732 @ApiOperation(value = "Bulk upload functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
733 @RequestMapping(value = { "/upload/partner/functions" }, method = RequestMethod.POST, produces = "application/json")
734 public PortalRestResponse<String> bulkUploadPartnerFunctions(HttpServletRequest request, HttpServletResponse response, @RequestBody List<RoleFunction> upload) throws Exception {
736 externalAccessRolesService.bulkUploadPartnerFunctions(request.getHeader(UEBKEY), upload);
737 } catch (Exception e) {
738 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
739 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
740 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
742 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
745 @ApiOperation(value = "Bulk upload roles for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
746 @RequestMapping(value = { "/upload/partner/roles" }, method = RequestMethod.POST, produces = "application/json")
747 public PortalRestResponse<String> bulkUploadPartnerRoles(HttpServletRequest request, HttpServletResponse response, @RequestBody List<Role> upload) throws Exception {
749 externalAccessRolesService.bulkUploadPartnerRoles(request.getHeader(UEBKEY), upload);
750 } catch (Exception e) {
751 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
752 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
753 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
755 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
758 @ApiOperation(value = "Bulk upload role functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
759 @RequestMapping(value = { "/upload/partner/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
760 public PortalRestResponse<String> bulkUploadPartnerRoleFunctions(HttpServletRequest request, HttpServletResponse response, @RequestBody List<Role> upload) throws Exception {
762 externalAccessRolesService.bulkUploadPartnerRoleFunctions(request.getHeader(UEBKEY), upload);
763 } catch (Exception e) {
764 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
765 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
766 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadPartnerRoleFunctions", "Failed");
768 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
771 @ApiOperation(value = "Gets all functions along with global functions", response = List.class, responseContainer = "Json")
772 @RequestMapping(value = { "/menuFunctions" }, method = RequestMethod.GET, produces = "application/json")
773 public List<String> getMenuFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
774 List<String> functionsList = null;
776 fieldsValidation(request);
777 functionsList = externalAccessRolesService.getMenuFunctionsList(request.getHeader(UEBKEY));
778 } catch (Exception e) {
779 sendErrorResponse(response, e);
780 logger.error(EELFLoggerDelegate.errorLogger, "getMenuFunctions failed", e);
782 return functionsList;
785 @ApiOperation(value = "Gets all active Users of application", response = String.class, responseContainer = "Json")
786 @RequestMapping(value = { "/users" }, method = RequestMethod.GET, produces = "application/json")
787 public List<EcompUser> getUsersOfApplication(HttpServletRequest request, HttpServletResponse response) throws Exception {
788 List<EcompUser> users = null;
790 fieldsValidation(request);
791 users = externalAccessRolesService.getAllAppUsers(request.getHeader(UEBKEY));
792 } catch (Exception e) {
793 sendErrorResponse(response, e);
794 logger.error(EELFLoggerDelegate.errorLogger, "getUsersOfApplication failed", e);
801 * It checks the input uebkey of the application and throws exception if it is invalid key
806 private void fieldsValidation(HttpServletRequest request) throws Exception{
807 List<EPApp> app = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
809 throw new Exception(INVALID_UEB_KEY);
811 if(!app.isEmpty() && app.get(0).getCentralAuth()){
812 ResponseEntity<String> response = externalAccessRolesService.getNameSpaceIfExists(app.get(0));
813 if (response.getStatusCode().value() == HttpServletResponse.SC_NOT_FOUND)
814 throw new Exception("Invalid NameSpace");
820 * It returns http response with appropriate message
824 * @throws IOException
826 private void sendErrorResponse(HttpServletResponse response, Exception e) throws IOException {
827 response.setContentType("application/json");
828 response.setCharacterEncoding("UTF-8");
829 final Map<String,String> uebkeyResponse = new HashMap<>();
830 ObjectMapper mapper = new ObjectMapper();
832 if (e.getMessage().contains(INVALID_UEB_KEY)) {
833 uebkeyResponse.put("error",INVALID_UEB_KEY);
834 reason = mapper.writeValueAsString(uebkeyResponse);
835 response.getWriter().write(reason);
836 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
838 uebkeyResponse.put("error",e.getMessage());
839 reason = mapper.writeValueAsString(uebkeyResponse);
840 response.getWriter().write(reason);
841 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
845 @ApiOperation(value = "Gets ecompUser of an application.", response = CentralUser.class, responseContainer = "List")
846 @RequestMapping(value = { "/v2/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
847 public String getEcompUser(HttpServletRequest request, HttpServletResponse response,
848 @PathVariable("loginId") String loginId) throws Exception {
849 EcompUser user = null;
850 ObjectMapper mapper = new ObjectMapper();
851 String answer = null;
853 fieldsValidation(request);
854 answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
855 if (answer != null) {
856 User ecompUser = userservice.userMapper(answer);
857 user = UserUtils.convertToEcompUser(ecompUser);
859 } catch (Exception e) {
860 sendErrorResponse(response, e);
861 logger.error(EELFLoggerDelegate.errorLogger, "getEcompUser failed", e);
864 return mapper.writeValueAsString(user);
869 @ApiOperation(value = "Gets user ecomp role for an application.", response = CentralUser.class, responseContainer = "List")
870 @RequestMapping(value = { "/v2/roles" }, method = RequestMethod.GET, produces = "application/json")
871 public List<EcompRole> getEcompRolesOfApplication(HttpServletRequest request, HttpServletResponse response)
873 List<EcompRole> ecompRoles = null;
874 ObjectMapper mapper = new ObjectMapper();
875 List<CentralV2Role> cenRole = null;
877 fieldsValidation(request);
878 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
879 // Sync all roles from external system into ONAP portal DB
880 logger.debug(EELFLoggerDelegate.debugLogger,
881 "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
882 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
883 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
884 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
885 } catch (Exception e) {
886 sendErrorResponse(response, e);
887 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
889 if (cenRole != null) {
890 String res = mapper.writeValueAsString(cenRole);
891 ecompRoles = new ArrayList<>();
892 List<Role> roles = mapper.readValue(res,
893 TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
894 for (Role role : roles)
895 ecompRoles.add(UserUtils.convertToEcompRole(role));
896 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getEcompRolesOfApplication");