2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2017-2018 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.User;
73 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
74 import org.onap.portalsdk.core.restful.domain.EcompRole;
75 import org.onap.portalsdk.core.restful.domain.EcompUser;
76 import org.onap.portalsdk.core.service.AuditService;
77 import org.onap.portalsdk.core.service.UserService;
78 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
79 import org.onap.portalsdk.core.util.SystemProperties;
80 import org.onap.portalsdk.core.web.support.UserUtils;
82 import org.springframework.beans.BeanUtils;
83 import org.springframework.beans.factory.annotation.Autowired;
84 import org.springframework.context.annotation.EnableAspectJAutoProxy;
85 import org.springframework.http.ResponseEntity;
86 import org.springframework.web.bind.annotation.PathVariable;
87 import org.springframework.web.bind.annotation.RequestBody;
88 import org.springframework.web.bind.annotation.RequestMapping;
89 import org.springframework.web.bind.annotation.RequestMethod;
90 import org.springframework.web.bind.annotation.RestController;
91 import org.springframework.web.client.RestTemplate;
93 import com.fasterxml.jackson.databind.DeserializationFeature;
94 import com.fasterxml.jackson.databind.ObjectMapper;
95 import com.fasterxml.jackson.databind.type.TypeFactory;
97 import io.swagger.annotations.ApiOperation;
100 @RequestMapping("/auxapi")
101 @org.springframework.context.annotation.Configuration
102 @EnableAspectJAutoProxy
104 public class ExternalAccessRolesController implements BasicAuthenticationController {
106 private static final String ROLE_INVALID_CHARS = "%=():,\"\"";
108 private static final String SUCCESSFULLY_DELETED = "Successfully Deleted";
110 private static final String INVALID_UEB_KEY = "Invalid uebkey!";
112 private static final String LOGIN_ID = "LoginId";
114 RestTemplate template = new RestTemplate();
117 private AuditService auditService;
119 private static final String UEBKEY = "uebkey";
121 private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ExternalAccessRolesController.class);
124 private ExternalAccessRolesService externalAccessRolesService;
127 private UserService userservice = new UserServiceCentalizedImpl();
129 @ApiOperation(value = "Gets user role for an application.", response = CentralUser.class, responseContainer="List")
130 @RequestMapping(value = {
131 "/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
132 public CentralUser getUser(HttpServletRequest request, HttpServletResponse response,
133 @PathVariable("loginId") String loginId) throws Exception {
135 CentralUser answer = null;
137 fieldsValidation(request);
138 answer = externalAccessRolesService.getUserRoles(loginId, request.getHeader(UEBKEY));
139 } catch (Exception e) {
140 sendErrorResponse(response, e);
141 logger.error(EELFLoggerDelegate.errorLogger, "getUser failed", e);
146 @ApiOperation(value = "Gets user roles for an application which is upgraded to newer version.", response = String.class, responseContainer="List")
147 @RequestMapping(value = {
148 "/v1/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
149 public String getV2UserList(HttpServletRequest request, HttpServletResponse response,
150 @PathVariable("loginId") String loginId) throws Exception {
151 String answer = null;
153 fieldsValidation(request);
154 answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
155 } catch (Exception e) {
156 sendErrorResponse(response, e);
157 logger.error(EELFLoggerDelegate.errorLogger, "getV2UserList failed", e);
162 @ApiOperation(value = "Gets roles for an application.", response = CentralRole.class, responseContainer="Json")
163 @RequestMapping(value = {
164 "/roles" }, method = RequestMethod.GET, produces = "application/json")
165 public List<CentralRole> getRolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
166 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRolesForApp");
167 List<CentralV2Role> v2CenRole = null;
168 List<CentralRole> cenRole = null;
170 fieldsValidation(request);
171 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
172 // Sync all roles from external system into ONAP portal DB
173 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
174 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
175 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
176 v2CenRole = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
177 cenRole = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(v2CenRole);
178 } catch (Exception e) {
179 sendErrorResponse(response, e);
180 logger.error(EELFLoggerDelegate.errorLogger, "getRolesForApp failed", e);
182 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRolesForApp");
186 @ApiOperation(value = "Gets roles for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
187 @RequestMapping(value = {
188 "/v1/roles" }, method = RequestMethod.GET, produces = "application/json")
189 public List<CentralV2Role> getV2RolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
190 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RolesForApp");
191 List<CentralV2Role> answer = null;
193 fieldsValidation(request);
194 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
195 // Sync all roles from external system into ONAP portal DB
196 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Entering into syncApplicationRolesWithEcompDB");
197 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
198 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Finished syncApplicationRolesWithEcompDB");
199 answer = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
200 } catch (Exception e) {
201 sendErrorResponse(response, e);
202 logger.error(EELFLoggerDelegate.errorLogger, "getV2RolesForApp failed", e);
204 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RolesForApp");
208 @ApiOperation(value = "Gets all role functions for an application for older version.", response = CentralRoleFunction.class, responseContainer="Json")
209 @RequestMapping(value = {
210 "/functions" }, method = RequestMethod.GET, produces = "application/json")
211 public List<CentralRoleFunction> getRoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
213 List<CentralV2RoleFunction> answer = null;
214 List<CentralRoleFunction> roleFuncList = null;
215 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleFunctionsList");
217 fieldsValidation(request);
218 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
219 // Sync all functions from external system into ONAP portal DB
220 logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
221 externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
222 logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
223 answer = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
224 roleFuncList = externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(answer);
225 } catch (Exception e) {
226 sendErrorResponse(response, e);
227 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunctionsList failed", e);
229 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleFunctionsList");
233 @ApiOperation(value = "Gets all role functions for an application which is upgraded to newer version.", response = CentralV2RoleFunction.class, responseContainer="Json")
234 @RequestMapping(value = {
235 "/v1/functions" }, method = RequestMethod.GET, produces = "application/json")
236 public List<CentralV2RoleFunction> getV2RoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
238 List<CentralV2RoleFunction> cenRoleFuncList = null;
239 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleFunctionsList");
241 fieldsValidation(request);
242 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
243 // Sync all functions from external system into ONAP portal DB
244 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
245 externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
246 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
247 cenRoleFuncList = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
248 } catch (Exception e) {
249 sendErrorResponse(response, e);
250 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunctionsList failed", e);
252 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleFunctionsList");
253 return cenRoleFuncList;
257 @ApiOperation(value = "Gets role information for an application.", response = CentralRole.class, responseContainer="Json")
258 @RequestMapping(value = {
259 "/role/{role_id}" }, method = RequestMethod.GET, produces = "application/json")
260 public CentralRole getRoleInfo(HttpServletRequest request, HttpServletResponse response,
261 @PathVariable("role_id") Long roleId) throws Exception {
262 CentralV2Role answer = null;
263 CentralRole cenRole = null;
264 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleInfo");
266 fieldsValidation(request);
267 answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
268 cenRole = externalAccessRolesService.convertV2CentralRoleToOldVerisonCentralRole(answer);
269 } catch (Exception e) {
270 sendErrorResponse(response, e);
271 logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo failed", e);
273 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleInfo");
277 @ApiOperation(value = "Gets v2 role information for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
278 @RequestMapping(value = {
279 "/v1/role/{role_id}" }, method = RequestMethod.GET, produces = "application/json")
280 public CentralV2Role getV2RoleInfo(HttpServletRequest request, HttpServletResponse response,
281 @PathVariable("role_id") Long roleId) throws Exception {
282 CentralV2Role answer = null;
283 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleInfo");
285 fieldsValidation(request);
286 answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
287 } catch (Exception e) {
288 sendErrorResponse(response, e);
289 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleInfo failed", e);
291 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleInfo");
295 @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralRoleFunction.class, responseContainer = "Json")
296 @RequestMapping(value = { "/function/{code}" }, method = RequestMethod.GET, produces = "application/json")
297 public CentralRoleFunction getRoleFunction(HttpServletRequest request, HttpServletResponse response,
298 @PathVariable("code") String code) throws Exception {
299 CentralV2RoleFunction centralV2RoleFunction = null;
300 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
302 fieldsValidation(request);
303 centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
304 if(centralV2RoleFunction != null && EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
305 BeanUtils.copyProperties(centralV2RoleFunction, centralRoleFunction, "type","action");
307 } catch (Exception e) {
308 sendErrorResponse(response, e);
309 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunction failed", e);
311 return centralRoleFunction;
314 @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralV2RoleFunction.class, responseContainer = "Json")
315 @RequestMapping(value = { "/v1/function/{code}" }, method = RequestMethod.GET, produces = "application/json")
316 public CentralV2RoleFunction getV2RoleFunction(HttpServletRequest request, HttpServletResponse response,
317 @PathVariable("code") String code) throws Exception {
318 CentralV2RoleFunction centralV2RoleFunction = null;
320 fieldsValidation(request);
321 centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
322 if(centralV2RoleFunction == null || !EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
323 centralV2RoleFunction = new CentralV2RoleFunction();
325 } catch (Exception e) {
326 sendErrorResponse(response, e);
327 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunction failed", e);
329 return centralV2RoleFunction;
332 @ApiOperation(value = "Saves role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
333 @RequestMapping(value = { "/roleFunction" }, method = RequestMethod.POST, produces = "application/json")
334 public PortalRestResponse<String> saveRoleFunction(HttpServletRequest request, HttpServletResponse response,
335 @RequestBody String roleFunc) throws Exception {
336 String status = "Successfully saved!";
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 boolean isCentralV2Version = false;
347 if(availableRoleFunction.getType()!=null && availableRoleFunction.getAction()!= null) {
348 isCentralV2Version = true;
350 if(isCentralV2Version) {
351 String code = availableRoleFunction.getType()+"|"+availableRoleFunction.getCode()+"|"+availableRoleFunction.getAction();
352 domainRoleFunction = externalAccessRolesService.getRoleFunction(code,
353 requestedApp.getUebKey());
355 domainRoleFunction = externalAccessRolesService.getRoleFunction(availableRoleFunction.getCode(),
356 requestedApp.getUebKey());
359 boolean saveOrUpdateResponse = false;
360 if (domainRoleFunction != null && isCentralV2Version && domainRoleFunction.getCode().equals(availableRoleFunction.getCode())
361 && domainRoleFunction.getType().equals(availableRoleFunction.getType())
362 && domainRoleFunction.getAction().equals(availableRoleFunction.getAction())) {
363 domainRoleFunction.setName(availableRoleFunction.getName());
364 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(domainRoleFunction,
367 availableRoleFunction.setAppId(requestedApp.getId());
368 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(availableRoleFunction,
372 if(domainRoleFunction != null) {
373 status = "Successfully updated!";
375 if (saveOrUpdateResponse) {
376 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
377 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
378 String activityCode = (!status.equals("Successfully updated!"))
379 ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_FUNCTION
380 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_FUNCTION;
381 logger.info(EELFLoggerDelegate.applicationLogger, "saveRoleFunction: succeeded for app {}, function {}",
382 app.getId(), availableRoleFunction.getCode());
383 AuditLog auditLog = new AuditLog();
384 auditLog.setUserId(user.getId());
385 auditLog.setActivityCode(activityCode);
386 auditLog.setComments(
387 EcompPortalUtils.truncateString(
388 "saveRoleFunction role for app:" + app.getId() + " and function:'"
389 + availableRoleFunction.getCode() + "'",
390 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
391 auditLog.setAffectedRecordId(user.getOrgUserId());
392 auditService.logActivity(auditLog, null);
393 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
394 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
395 EcompPortalUtils.calculateDateTimeDifferenceForLog(
396 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
397 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
398 logger.info(EELFLoggerDelegate.auditLogger,
399 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRoleFunction", activityCode,
400 String.valueOf(user.getId()), user.getOrgUserId(), availableRoleFunction.getCode()));
401 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
402 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
403 MDC.remove(SystemProperties.MDC_TIMER);
405 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed");
406 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
407 "Failed to saveRoleFunction for '" + availableRoleFunction.getCode() + "'", "Failed");
409 } catch (Exception e) {
410 if (e.getMessage() == null ||e.getMessage().contains(INVALID_UEB_KEY)) {
411 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
413 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
415 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed", e);
416 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
418 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, status, "Success");
421 @ApiOperation(value = "Deletes role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
422 @RequestMapping(value = { "/roleFunction/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
423 public PortalRestResponse<String> deleteRoleFunction(HttpServletRequest request, HttpServletResponse response,
424 @PathVariable("code") String code) throws Exception {
426 fieldsValidation(request);
427 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
428 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
429 boolean getDelFuncResponse = externalAccessRolesService.deleteCentralRoleFunction(code, app);
430 if (getDelFuncResponse) {
431 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRoleFunction: succeeded for app {}, role {}",
433 AuditLog auditLog = new AuditLog();
434 auditLog.setUserId(user.getId());
435 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION);
436 auditLog.setComments(EcompPortalUtils.truncateString(
437 "Deleted function for app:" + app.getId() + " and function code:'" + code + "'",
438 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
439 auditLog.setAffectedRecordId(user.getOrgUserId());
440 auditService.logActivity(auditLog, null);
441 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
442 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
443 EcompPortalUtils.calculateDateTimeDifferenceForLog(
444 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
445 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
446 logger.info(EELFLoggerDelegate.auditLogger,
447 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRoleFunction",
448 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION, String.valueOf(user.getId()),
449 user.getOrgUserId(), code));
450 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
451 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
452 MDC.remove(SystemProperties.MDC_TIMER);
454 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
455 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
456 "Failed to deleteRoleFunction for '" + code + "'", "Failed");
458 } catch (Exception e) {
459 if (e.getMessage().contains(INVALID_UEB_KEY)) {
460 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
462 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
464 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed", e);
465 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
467 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
471 @ApiOperation(value = "Saves role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
472 @RequestMapping(value = { "/role" }, method = RequestMethod.POST, produces = "application/json")
473 public PortalRestResponse<String> saveRole(HttpServletRequest request, HttpServletResponse response,
474 @RequestBody Role role) throws Exception {
476 fieldsValidation(request);
477 ExternalRequestFieldsValidator saveRoleResult = null;
478 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
479 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
480 if(role.getId()!=null && StringUtils.containsAny(role.getName(), ROLE_INVALID_CHARS)) {
481 throw new InvalidRoleException("Invalid role name found for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed");
483 saveRoleResult = externalAccessRolesService.saveRoleForApplication(role, request.getHeader(UEBKEY));
484 if (saveRoleResult.isResult()) {
485 String activityCode = (role.getId() == null) ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_ROLE
486 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_ROLE_AND_FUNCTION;
487 logger.info(EELFLoggerDelegate.applicationLogger, "saveRole: succeeded for app {}, role {}",
488 app.getId(), role.getName());
489 AuditLog auditLog = new AuditLog();
490 auditLog.setUserId(user.getId());
491 auditLog.setActivityCode(activityCode);
492 auditLog.setComments(EcompPortalUtils.truncateString(
493 "saveRole role for app:" + app.getId() + " and role:'" + role.getName() + "'",
494 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
495 auditLog.setAffectedRecordId(user.getOrgUserId());
496 auditService.logActivity(auditLog, null);
497 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
498 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
499 EcompPortalUtils.calculateDateTimeDifferenceForLog(
500 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
501 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
502 logger.info(EELFLoggerDelegate.auditLogger,
503 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRole", activityCode,
504 String.valueOf(user.getId()), user.getOrgUserId(), role.getName()));
505 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
506 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
507 MDC.remove(SystemProperties.MDC_TIMER);
509 if(saveRoleResult.getDetailMessage().contains("406")){
510 response.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
511 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
512 "Failed to create a role for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed"
515 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
516 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
517 "Failed to saveRole for '" + role.getName() + "'", "Failed");
520 } catch (Exception e) {
521 if (e.getMessage().contains(INVALID_UEB_KEY)) {
522 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
524 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
526 logger.error(EELFLoggerDelegate.errorLogger, "saveRole failed", e);
527 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
529 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
532 @ApiOperation(value = "Deletes role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
533 @RequestMapping(value = { "/deleteRole/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
534 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
535 @PathVariable String code) throws Exception {
537 fieldsValidation(request);
538 boolean deleteResponse = externalAccessRolesService.deleteRoleForApplication(code,
539 request.getHeader(UEBKEY));
540 if (deleteResponse) {
541 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
542 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
543 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRole: succeeded for app {}, role {}",
545 AuditLog auditLog = new AuditLog();
546 auditLog.setUserId(user.getId());
547 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE);
548 auditLog.setComments(EcompPortalUtils.truncateString(
549 "Deleted role for app:" + app.getId() + " and role:'" + code + "'",
550 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
551 auditLog.setAffectedRecordId(user.getOrgUserId());
552 auditService.logActivity(auditLog, null);
553 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
554 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
555 EcompPortalUtils.calculateDateTimeDifferenceForLog(
556 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
557 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
558 logger.info(EELFLoggerDelegate.auditLogger,
559 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRole",
560 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE, String.valueOf(user.getId()),
561 user.getOrgUserId(), code));
562 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
563 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
564 MDC.remove(SystemProperties.MDC_TIMER);
566 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
567 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
568 "Failed to deleteRole for '" + code + "'", "Failed");
570 } catch (Exception e) {
571 if (e.getMessage().contains(INVALID_UEB_KEY)) {
572 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
574 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
576 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
577 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
579 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
582 @ApiOperation(value = "Gets active roles for an application.", response = CentralRole.class, responseContainer = "Json")
583 @RequestMapping(value = { "/activeRoles" }, method = RequestMethod.GET, produces = "application/json")
584 public List<CentralRole> getActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
585 List<CentralRole> roles = null;
587 fieldsValidation(request);
588 List<CentralV2Role> cenRoles= externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
589 roles = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles);
590 } catch (Exception e) {
591 sendErrorResponse(response, e);
592 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
598 @ApiOperation(value = "Gets active roles for an application.", response = CentralV2Role.class, responseContainer = "Json")
599 @RequestMapping(value = { "/v1/activeRoles" }, method = RequestMethod.GET, produces = "application/json")
600 public List<CentralV2Role> getV2ActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
601 List<CentralV2Role> cenRole = null;
603 fieldsValidation(request);
604 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
605 } catch (Exception e) {
606 sendErrorResponse(response, e);
607 logger.error(EELFLoggerDelegate.errorLogger, "getV2ActiveRoles failed", e);
613 @ApiOperation(value = "deletes user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
614 @RequestMapping(value = { "/deleteDependcyRoleRecord/{roleId}" }, method = RequestMethod.DELETE, produces = "application/json")
615 public PortalRestResponse<String> deleteDependencyRoleRecord(HttpServletRequest request, HttpServletResponse response,
616 @PathVariable("roleId") Long roleId) throws Exception {
617 ExternalRequestFieldsValidator removeResult = null;
619 fieldsValidation(request);
620 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
621 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
622 if (!removeResult.isResult()) {
623 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
624 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteDependencyRoleRecord",
627 } catch (Exception e) {
628 if (e.getMessage().contains(INVALID_UEB_KEY)) {
629 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
631 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
633 logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord failed", e);
634 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
636 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
640 @ApiOperation(value = "deletes roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
641 @RequestMapping(value = { "/v2/deleteRole/{roleId}" }, method = RequestMethod.DELETE, produces = "application/json")
642 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
643 @PathVariable("roleId") Long roleId) throws Exception {
644 ExternalRequestFieldsValidator removeResult = null;
646 fieldsValidation(request);
647 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
648 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
649 if (!removeResult.isResult()) {
650 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
651 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteRole",
654 } catch (Exception e) {
655 if (e.getMessage().contains(INVALID_UEB_KEY)) {
656 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
658 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
660 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
661 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
663 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
667 @ApiOperation(value = "Bulk upload functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
668 @RequestMapping(value = { "/upload/portal/functions" }, method = RequestMethod.POST, produces = "application/json")
669 public PortalRestResponse<String> bulkUploadFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
672 result = externalAccessRolesService.bulkUploadFunctions(request.getHeader(UEBKEY));
673 } catch (Exception e) {
674 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
675 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
676 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
678 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
681 @ApiOperation(value = "Bulk upload roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
682 @RequestMapping(value = { "/upload/portal/roles" }, method = RequestMethod.POST, produces = "application/json")
683 public PortalRestResponse<String> bulkUploadRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
686 result = externalAccessRolesService.bulkUploadRoles(request.getHeader(UEBKEY));
687 } catch (Exception e) {
688 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
689 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
690 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
692 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
695 @ApiOperation(value = "Bulk upload role functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
696 @RequestMapping(value = { "/upload/portal/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
697 public PortalRestResponse<String> bulkUploadRoleFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
700 result = externalAccessRolesService.bulkUploadRolesFunctions(request.getHeader(UEBKEY));
701 } catch (Exception e) {
702 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
703 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoleFunctions failed", e);
704 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoleFunctions", "Failed");
706 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
709 @ApiOperation(value = "Bulk upload user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
710 @RequestMapping(value = { "/upload/portal/userRoles" }, method = RequestMethod.POST, produces = "application/json")
711 public PortalRestResponse<String> bulkUploadUserRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
714 result = externalAccessRolesService.bulkUploadUserRoles(request.getHeader(UEBKEY));
715 } catch (Exception e) {
716 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
717 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUserRoles failed", e);
718 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUserRoles", "Failed");
720 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
723 @ApiOperation(value = "Bulk upload users for renamed role of an application.", response = PortalRestResponse.class, responseContainer = "Json")
724 @RequestMapping(value = { "/upload/portal/userRole/{roleId}" }, method = RequestMethod.POST, produces = "application/json")
725 public PortalRestResponse<String> bulkUploadUsersSingleRole(HttpServletRequest request, HttpServletResponse response, @PathVariable Long roleId) throws Exception {
728 String roleName = request.getHeader("RoleName");
729 result = externalAccessRolesService.bulkUploadUsersSingleRole(request.getHeader(UEBKEY), roleId, roleName);
730 } catch (Exception e) {
731 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
732 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUsersSingleRole failed", e);
733 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUsersSingleRole", "Failed");
735 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
738 @ApiOperation(value = "Bulk upload functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
739 @RequestMapping(value = { "/upload/partner/functions" }, method = RequestMethod.POST, produces = "application/json")
740 public PortalRestResponse<String> bulkUploadPartnerFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
741 Integer addedFunctions = 0;
743 addedFunctions = externalAccessRolesService.bulkUploadPartnerFunctions(request.getHeader(UEBKEY));
744 } catch (Exception e) {
745 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
746 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
747 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
749 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: '"+addedFunctions+"' functions", "Success");
752 @ApiOperation(value = "Bulk upload roles for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
753 @RequestMapping(value = { "/upload/partner/roles" }, method = RequestMethod.POST, produces = "application/json")
754 public PortalRestResponse<String> bulkUploadPartnerRoles(HttpServletRequest request, HttpServletResponse response, @RequestBody List<Role> upload) throws Exception {
756 externalAccessRolesService.bulkUploadPartnerRoles(request.getHeader(UEBKEY), upload);
757 } catch (Exception e) {
758 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
759 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
760 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
762 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
765 @ApiOperation(value = "Bulk upload role functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
766 @RequestMapping(value = { "/upload/partner/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
767 public PortalRestResponse<String> bulkUploadPartnerRoleFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
768 Integer addedRoleFunctions = 0;
770 addedRoleFunctions = externalAccessRolesService.bulkUploadPartnerRoleFunctions(request.getHeader(UEBKEY));
771 } catch (Exception e) {
772 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
773 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
774 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadPartnerRoleFunctions", "Failed");
776 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: '"+addedRoleFunctions + "' role functions", "Success");
779 @ApiOperation(value = "Gets all functions along with global functions", response = List.class, responseContainer = "Json")
780 @RequestMapping(value = { "/menuFunctions" }, method = RequestMethod.GET, produces = "application/json")
781 public List<String> getMenuFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
782 List<String> functionsList = null;
784 fieldsValidation(request);
785 functionsList = externalAccessRolesService.getMenuFunctionsList(request.getHeader(UEBKEY));
786 } catch (Exception e) {
787 sendErrorResponse(response, e);
788 logger.error(EELFLoggerDelegate.errorLogger, "getMenuFunctions failed", e);
790 return functionsList;
793 @ApiOperation(value = "Gets all active Users of application", response = String.class, responseContainer = "Json")
794 @RequestMapping(value = { "/users" }, method = RequestMethod.GET, produces = "application/json")
795 public List<EcompUser> getUsersOfApplication(HttpServletRequest request, HttpServletResponse response) throws Exception {
796 List<EcompUser> users = null;
798 fieldsValidation(request);
799 users = externalAccessRolesService.getAllAppUsers(request.getHeader(UEBKEY));
800 } catch (Exception e) {
801 sendErrorResponse(response, e);
802 logger.error(EELFLoggerDelegate.errorLogger, "getUsersOfApplication failed", e);
809 * It checks the input uebkey of the application and throws exception if it is invalid key
814 private void fieldsValidation(HttpServletRequest request) throws Exception{
815 List<EPApp> app = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
817 throw new Exception(INVALID_UEB_KEY);
819 if(!app.isEmpty() && app.get(0).getCentralAuth()){
820 ResponseEntity<String> response = externalAccessRolesService.getNameSpaceIfExists(app.get(0));
821 if (response.getStatusCode().value() == HttpServletResponse.SC_NOT_FOUND)
822 throw new Exception("Invalid NameSpace");
828 * It returns http response with appropriate message
832 * @throws IOException
834 private void sendErrorResponse(HttpServletResponse response, Exception e) throws IOException {
835 response.setContentType("application/json");
836 response.setCharacterEncoding("UTF-8");
837 final Map<String,String> uebkeyResponse = new HashMap<>();
838 ObjectMapper mapper = new ObjectMapper();
840 if (e.getMessage().contains(INVALID_UEB_KEY)) {
841 uebkeyResponse.put("error",INVALID_UEB_KEY);
842 reason = mapper.writeValueAsString(uebkeyResponse);
843 response.getWriter().write(reason);
844 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
846 uebkeyResponse.put("error",e.getMessage());
847 reason = mapper.writeValueAsString(uebkeyResponse);
848 response.getWriter().write(reason);
849 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
853 @ApiOperation(value = "Gets ecompUser of an application.", response = CentralUser.class, responseContainer = "List")
854 @RequestMapping(value = { "/v2/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
855 public String getEcompUser(HttpServletRequest request, HttpServletResponse response,
856 @PathVariable("loginId") String loginId) throws Exception {
857 EcompUser user = new EcompUser();
858 ObjectMapper mapper = new ObjectMapper();
859 String answer = null;
861 fieldsValidation(request);
862 answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
863 if (answer != null) {
864 User ecompUser = userservice.userMapper(answer);
865 user = UserUtils.convertToEcompUser(ecompUser);
867 } catch (Exception e) {
868 sendErrorResponse(response, e);
869 logger.error(EELFLoggerDelegate.errorLogger, "getEcompUser failed", e);
871 return mapper.writeValueAsString(user);
874 @ApiOperation(value = "Gets user ecomp role for an application.", response = CentralUser.class, responseContainer = "List")
875 @RequestMapping(value = { "/v2/roles" }, method = RequestMethod.GET, produces = "application/json")
876 public List<EcompRole> getEcompRolesOfApplication(HttpServletRequest request, HttpServletResponse response)
878 List<EcompRole> ecompRoles = null;
879 ObjectMapper mapper = new ObjectMapper();
880 List<CentralV2Role> cenRole = null;
882 fieldsValidation(request);
883 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
884 // Sync all roles from external system into ONAP portal DB
885 logger.debug(EELFLoggerDelegate.debugLogger,
886 "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
887 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
888 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
889 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
890 } catch (Exception e) {
891 sendErrorResponse(response, e);
892 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
894 if (cenRole != null) {
895 String res = mapper.writeValueAsString(cenRole);
896 ecompRoles = new ArrayList<>();
897 List<Role> roles = mapper.readValue(res,
898 TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
899 for (Role role : roles)
900 ecompRoles.add(UserUtils.convertToEcompRole(role));
901 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getEcompRolesOfApplication");