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 java.util.TreeSet;
49 import javax.servlet.http.HttpServletRequest;
50 import javax.servlet.http.HttpServletResponse;
52 import org.apache.commons.lang.StringUtils;
53 import org.onap.portalapp.portal.domain.CentralV2RoleFunction;
54 import org.onap.portalapp.portal.domain.EPApp;
55 import org.onap.portalapp.portal.domain.EPUser;
56 import org.onap.portalapp.portal.domain.EcompAuditLog;
57 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
58 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
59 import org.onap.portalapp.portal.exceptions.InvalidRoleException;
60 import org.onap.portalapp.portal.logging.aop.EPAuditLog;
61 import org.onap.portalapp.portal.logging.aop.EPEELFLoggerAdvice;
62 import org.onap.portalapp.portal.logging.logic.EPLogUtil;
63 import org.onap.portalapp.portal.service.ExternalAccessRolesService;
64 import org.onap.portalapp.portal.transport.CentralRole;
65 import org.onap.portalapp.portal.transport.CentralRoleFunction;
66 import org.onap.portalapp.portal.transport.CentralUser;
67 import org.onap.portalapp.portal.transport.CentralV2Role;
68 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
69 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
70 import org.onap.portalapp.portal.utils.EcompPortalUtils;
71 import org.onap.portalapp.portal.utils.PortalConstants;
72 import org.onap.portalsdk.core.domain.AuditLog;
73 import org.onap.portalsdk.core.domain.Role;
74 import org.onap.portalsdk.core.domain.User;
75 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
76 import org.onap.portalsdk.core.restful.domain.EcompRole;
77 import org.onap.portalsdk.core.restful.domain.EcompUser;
78 import org.onap.portalsdk.core.service.AuditService;
79 import org.onap.portalsdk.core.service.UserService;
80 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
81 import org.onap.portalsdk.core.util.SystemProperties;
82 import org.onap.portalsdk.core.web.support.UserUtils;
84 import org.springframework.beans.BeanUtils;
85 import org.springframework.beans.factory.annotation.Autowired;
86 import org.springframework.context.annotation.EnableAspectJAutoProxy;
87 import org.springframework.http.ResponseEntity;
88 import org.springframework.web.bind.annotation.PathVariable;
89 import org.springframework.web.bind.annotation.RequestBody;
90 import org.springframework.web.bind.annotation.RequestMapping;
91 import org.springframework.web.bind.annotation.RequestMethod;
92 import org.springframework.web.bind.annotation.RestController;
93 import org.springframework.web.client.RestTemplate;
95 import com.fasterxml.jackson.databind.DeserializationFeature;
96 import com.fasterxml.jackson.databind.ObjectMapper;
97 import com.fasterxml.jackson.databind.type.TypeFactory;
99 import io.swagger.annotations.ApiOperation;
102 @RequestMapping("/auxapi")
103 @org.springframework.context.annotation.Configuration
104 @EnableAspectJAutoProxy
106 public class ExternalAccessRolesController implements BasicAuthenticationController {
108 private static final String ROLE_INVALID_CHARS = "%=():,\"\"";
110 private static final String SUCCESSFULLY_DELETED = "Successfully Deleted";
112 private static final String INVALID_UEB_KEY = "Invalid credentials!";
114 private static final String LOGIN_ID = "LoginId";
116 RestTemplate template = new RestTemplate();
119 private AuditService auditService;
121 private static final String UEBKEY = "uebkey";
123 private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ExternalAccessRolesController.class);
126 private ExternalAccessRolesService externalAccessRolesService;
129 private UserService userservice = new UserServiceCentalizedImpl();
131 @ApiOperation(value = "Gets user role for an application.", response = CentralUser.class, responseContainer="List")
132 @RequestMapping(value = {
133 "/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
134 public CentralUser getUser(HttpServletRequest request, HttpServletResponse response,
135 @PathVariable("loginId") String loginId) throws Exception {
137 CentralUser answer = null;
139 fieldsValidation(request);
140 answer = externalAccessRolesService.getUserRoles(loginId, request.getHeader(UEBKEY));
141 } catch (Exception e) {
142 sendErrorResponse(response, e);
143 logger.error(EELFLoggerDelegate.errorLogger, "getUser failed", e);
148 @ApiOperation(value = "Gets user roles for an application which is upgraded to newer version.", response = String.class, responseContainer="List")
149 @RequestMapping(value = {
150 "/v1/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
151 public String getV2UserList(HttpServletRequest request, HttpServletResponse response,
152 @PathVariable("loginId") String loginId) throws Exception {
153 String answer = null;
155 fieldsValidation(request);
156 answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
157 } catch (Exception e) {
158 sendErrorResponse(response, e);
159 logger.error(EELFLoggerDelegate.errorLogger, "getV2UserList failed", e);
164 @ApiOperation(value = "Gets roles for an application.", response = CentralRole.class, responseContainer="Json")
165 @RequestMapping(value = {
166 "/roles" }, method = RequestMethod.GET, produces = "application/json")
167 public List<CentralRole> getRolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
168 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRolesForApp");
169 List<CentralV2Role> v2CenRole = null;
170 List<CentralRole> cenRole = null;
172 fieldsValidation(request);
173 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
174 // Sync all roles from external system into ONAP portal DB
175 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
176 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
177 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
178 v2CenRole = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
179 cenRole = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(v2CenRole);
180 } catch (Exception e) {
181 sendErrorResponse(response, e);
182 logger.error(EELFLoggerDelegate.errorLogger, "getRolesForApp failed", e);
184 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRolesForApp");
188 @ApiOperation(value = "Gets roles for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
189 @RequestMapping(value = {
190 "/v1/roles" }, method = RequestMethod.GET, produces = "application/json")
191 public List<CentralV2Role> getV2RolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
192 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RolesForApp");
193 List<CentralV2Role> answer = null;
195 fieldsValidation(request);
196 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
197 // Sync all roles from external system into ONAP portal DB
198 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Entering into syncApplicationRolesWithEcompDB");
199 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
200 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Finished syncApplicationRolesWithEcompDB");
201 answer = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
202 } catch (Exception e) {
203 sendErrorResponse(response, e);
204 logger.error(EELFLoggerDelegate.errorLogger, "getV2RolesForApp failed", e);
206 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RolesForApp");
210 @ApiOperation(value = "Gets all role functions for an application for older version.", response = CentralRoleFunction.class, responseContainer="Json")
211 @RequestMapping(value = {
212 "/functions" }, method = RequestMethod.GET, produces = "application/json")
213 public List<CentralRoleFunction> getRoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
215 List<CentralV2RoleFunction> answer = null;
216 List<CentralRoleFunction> roleFuncList = null;
217 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleFunctionsList");
219 fieldsValidation(request);
220 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
221 // Sync all functions from external system into ONAP portal DB
222 logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
223 externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
224 logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
225 answer = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
226 roleFuncList = externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(answer);
227 } catch (Exception e) {
228 sendErrorResponse(response, e);
229 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunctionsList failed", e);
231 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleFunctionsList");
235 @ApiOperation(value = "Gets all role functions for an application which is upgraded to newer version.", response = CentralV2RoleFunction.class, responseContainer="Json")
236 @RequestMapping(value = {
237 "/v1/functions" }, method = RequestMethod.GET, produces = "application/json")
238 public List<CentralV2RoleFunction> getV2RoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
240 List<CentralV2RoleFunction> cenRoleFuncList = null;
241 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleFunctionsList");
243 fieldsValidation(request);
244 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
245 // Sync all functions from external system into ONAP portal DB
246 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
247 externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
248 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
249 cenRoleFuncList = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
250 } catch (Exception e) {
251 sendErrorResponse(response, e);
252 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunctionsList failed", e);
254 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleFunctionsList");
255 return cenRoleFuncList;
259 @ApiOperation(value = "Gets role information for an application.", response = CentralRole.class, responseContainer="Json")
260 @RequestMapping(value = {
261 "/role/{role_id}" }, method = RequestMethod.GET, produces = "application/json")
262 public CentralRole getRoleInfo(HttpServletRequest request, HttpServletResponse response,
263 @PathVariable("role_id") Long roleId) throws Exception {
264 CentralV2Role answer = null;
265 CentralRole cenRole = null;
266 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleInfo");
268 fieldsValidation(request);
269 answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
270 cenRole = externalAccessRolesService.convertV2CentralRoleToOldVerisonCentralRole(answer);
271 } catch (Exception e) {
272 sendErrorResponse(response, e);
273 logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo failed", e);
275 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleInfo");
279 @ApiOperation(value = "Gets v2 role information for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
280 @RequestMapping(value = {
281 "/v1/role/{role_id}" }, method = RequestMethod.GET, produces = "application/json")
282 public CentralV2Role getV2RoleInfo(HttpServletRequest request, HttpServletResponse response,
283 @PathVariable("role_id") Long roleId) throws Exception {
284 CentralV2Role answer = null;
285 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleInfo");
287 fieldsValidation(request);
288 answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
289 } catch (Exception e) {
290 sendErrorResponse(response, e);
291 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleInfo failed", e);
293 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleInfo");
297 @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralRoleFunction.class, responseContainer = "Json")
298 @RequestMapping(value = { "/function/{code}" }, method = RequestMethod.GET, produces = "application/json")
299 public CentralRoleFunction getRoleFunction(HttpServletRequest request, HttpServletResponse response,
300 @PathVariable("code") String code) throws Exception {
301 CentralV2RoleFunction centralV2RoleFunction = null;
302 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
304 fieldsValidation(request);
305 centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
306 if(centralV2RoleFunction != null && EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
307 BeanUtils.copyProperties(centralV2RoleFunction, centralRoleFunction, "type","action");
309 } catch (Exception e) {
310 sendErrorResponse(response, e);
311 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunction failed", e);
313 return centralRoleFunction;
316 @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralV2RoleFunction.class, responseContainer = "Json")
317 @RequestMapping(value = { "/v1/function/{code}" }, method = RequestMethod.GET, produces = "application/json")
318 public CentralV2RoleFunction getV2RoleFunction(HttpServletRequest request, HttpServletResponse response,
319 @PathVariable("code") String code) throws Exception {
320 CentralV2RoleFunction centralV2RoleFunction = null;
322 fieldsValidation(request);
323 centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
324 if(centralV2RoleFunction == null || !EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
325 centralV2RoleFunction = new CentralV2RoleFunction();
327 } catch (Exception e) {
328 sendErrorResponse(response, e);
329 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunction failed", e);
331 return centralV2RoleFunction;
334 @ApiOperation(value = "Saves role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
335 @RequestMapping(value = { "/roleFunction" }, method = RequestMethod.POST, produces = "application/json")
336 public PortalRestResponse<String> saveRoleFunction(HttpServletRequest request, HttpServletResponse response,
337 @RequestBody String roleFunc) throws Exception {
338 String status = "Successfully saved!";
340 fieldsValidation(request);
341 String data = roleFunc;
342 ObjectMapper mapper = new ObjectMapper();
343 List<EPApp> applicationList = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
344 EPApp requestedApp = applicationList.get(0);
345 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
346 CentralV2RoleFunction availableRoleFunction = mapper.readValue(data, CentralV2RoleFunction.class);
347 CentralV2RoleFunction domainRoleFunction = null;
348 boolean isCentralV2Version = false;
349 if(availableRoleFunction.getType()!=null && availableRoleFunction.getAction()!= null) {
350 isCentralV2Version = true;
352 if(isCentralV2Version) {
353 String code = availableRoleFunction.getType()+"|"+availableRoleFunction.getCode()+"|"+availableRoleFunction.getAction();
354 domainRoleFunction = externalAccessRolesService.getRoleFunction(code,
355 requestedApp.getUebKey());
357 domainRoleFunction = externalAccessRolesService.getRoleFunction(availableRoleFunction.getCode(),
358 requestedApp.getUebKey());
361 boolean saveOrUpdateResponse = false;
362 if (domainRoleFunction != null && isCentralV2Version && domainRoleFunction.getCode().equals(availableRoleFunction.getCode())
363 && domainRoleFunction.getType().equals(availableRoleFunction.getType())
364 && domainRoleFunction.getAction().equals(availableRoleFunction.getAction())) {
365 domainRoleFunction.setName(availableRoleFunction.getName());
366 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(domainRoleFunction,
369 availableRoleFunction.setAppId(requestedApp.getId());
370 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(availableRoleFunction,
374 if(domainRoleFunction != null) {
375 status = "Successfully updated!";
377 if (saveOrUpdateResponse) {
378 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
379 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
380 String activityCode = (!status.equals("Successfully updated!"))
381 ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_FUNCTION
382 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_FUNCTION;
383 logger.info(EELFLoggerDelegate.applicationLogger, "saveRoleFunction: succeeded for app {}, function {}",
384 app.getId(), availableRoleFunction.getCode());
385 AuditLog auditLog = new AuditLog();
386 auditLog.setUserId(user.getId());
387 auditLog.setActivityCode(activityCode);
388 auditLog.setComments(
389 EcompPortalUtils.truncateString(
390 "saveRoleFunction role for app:" + app.getId() + " and function:'"
391 + availableRoleFunction.getCode() + "'",
392 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
393 auditLog.setAffectedRecordId(user.getOrgUserId());
394 auditService.logActivity(auditLog, null);
395 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
396 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
397 EcompPortalUtils.calculateDateTimeDifferenceForLog(
398 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
399 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
400 logger.info(EELFLoggerDelegate.auditLogger,
401 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRoleFunction", activityCode,
402 String.valueOf(user.getId()), user.getOrgUserId(), availableRoleFunction.getCode()));
403 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
404 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
405 MDC.remove(SystemProperties.MDC_TIMER);
407 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed");
408 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
409 "Failed to saveRoleFunction for '" + availableRoleFunction.getCode() + "'", "Failed");
411 } catch (Exception e) {
412 if (e.getMessage() == null ||e.getMessage().contains(INVALID_UEB_KEY)) {
413 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
415 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
417 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed", e);
418 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
420 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, status, "Success");
423 @ApiOperation(value = "Deletes role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
424 @RequestMapping(value = { "/roleFunction/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
425 public PortalRestResponse<String> deleteRoleFunction(HttpServletRequest request, HttpServletResponse response,
426 @PathVariable("code") String code) throws Exception {
428 fieldsValidation(request);
429 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
430 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
431 boolean getDelFuncResponse = externalAccessRolesService.deleteCentralRoleFunction(code, app);
432 if (getDelFuncResponse) {
433 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRoleFunction: succeeded for app {}, role {}",
435 AuditLog auditLog = new AuditLog();
436 auditLog.setUserId(user.getId());
437 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION);
438 auditLog.setComments(EcompPortalUtils.truncateString(
439 "Deleted function for app:" + app.getId() + " and function code:'" + code + "'",
440 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
441 auditLog.setAffectedRecordId(user.getOrgUserId());
442 auditService.logActivity(auditLog, null);
443 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
444 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
445 EcompPortalUtils.calculateDateTimeDifferenceForLog(
446 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
447 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
448 logger.info(EELFLoggerDelegate.auditLogger,
449 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRoleFunction",
450 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION, String.valueOf(user.getId()),
451 user.getOrgUserId(), code));
452 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
453 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
454 MDC.remove(SystemProperties.MDC_TIMER);
456 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
457 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
458 "Failed to deleteRoleFunction for '" + code + "'", "Failed");
460 } catch (Exception e) {
461 if (e.getMessage().contains(INVALID_UEB_KEY)) {
462 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
464 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
466 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed", e);
467 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
469 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
473 @ApiOperation(value = "Saves role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
474 @RequestMapping(value = { "/role" }, method = RequestMethod.POST, produces = "application/json")
475 public PortalRestResponse<String> saveRole(HttpServletRequest request, HttpServletResponse response,
476 @RequestBody Role role) throws Exception {
478 fieldsValidation(request);
479 ExternalRequestFieldsValidator saveRoleResult = null;
480 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
481 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
482 if(role.getId()!=null && StringUtils.containsAny(role.getName(), ROLE_INVALID_CHARS)) {
483 throw new InvalidRoleException("Invalid role name found for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed");
485 saveRoleResult = externalAccessRolesService.saveRoleForApplication(role, request.getHeader(UEBKEY));
486 if (saveRoleResult.isResult()) {
487 String activityCode = (role.getId() == null) ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_ROLE
488 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_ROLE_AND_FUNCTION;
489 logger.info(EELFLoggerDelegate.applicationLogger, "saveRole: succeeded for app {}, role {}",
490 app.getId(), role.getName());
491 AuditLog auditLog = new AuditLog();
492 auditLog.setUserId(user.getId());
493 auditLog.setActivityCode(activityCode);
494 auditLog.setComments(EcompPortalUtils.truncateString(
495 "saveRole role for app:" + app.getId() + " and role:'" + role.getName() + "'",
496 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
497 auditLog.setAffectedRecordId(user.getOrgUserId());
498 auditService.logActivity(auditLog, null);
499 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
500 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
501 EcompPortalUtils.calculateDateTimeDifferenceForLog(
502 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
503 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
504 logger.info(EELFLoggerDelegate.auditLogger,
505 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRole", activityCode,
506 String.valueOf(user.getId()), user.getOrgUserId(), role.getName()));
507 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
508 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
509 MDC.remove(SystemProperties.MDC_TIMER);
511 if(saveRoleResult.getDetailMessage().contains("406")){
512 response.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
513 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
514 "Failed to create a role for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed"
517 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
518 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
519 "Failed to saveRole for '" + role.getName() + "'", "Failed");
522 } catch (Exception e) {
523 if (e.getMessage().contains(INVALID_UEB_KEY)) {
524 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
526 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
528 logger.error(EELFLoggerDelegate.errorLogger, "saveRole failed", e);
529 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
531 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
534 @ApiOperation(value = "Deletes role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
535 @RequestMapping(value = { "/deleteRole/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
536 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
537 @PathVariable String code) throws Exception {
539 fieldsValidation(request);
540 boolean deleteResponse = externalAccessRolesService.deleteRoleForApplication(code,
541 request.getHeader(UEBKEY));
542 if (deleteResponse) {
543 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
544 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
545 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRole: succeeded for app {}, role {}",
547 AuditLog auditLog = new AuditLog();
548 auditLog.setUserId(user.getId());
549 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE);
550 auditLog.setComments(EcompPortalUtils.truncateString(
551 "Deleted role for app:" + app.getId() + " and role:'" + code + "'",
552 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
553 auditLog.setAffectedRecordId(user.getOrgUserId());
554 auditService.logActivity(auditLog, null);
555 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
556 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
557 EcompPortalUtils.calculateDateTimeDifferenceForLog(
558 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
559 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
560 logger.info(EELFLoggerDelegate.auditLogger,
561 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRole",
562 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE, String.valueOf(user.getId()),
563 user.getOrgUserId(), code));
564 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
565 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
566 MDC.remove(SystemProperties.MDC_TIMER);
568 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
569 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
570 "Failed to deleteRole for '" + code + "'", "Failed");
572 } catch (Exception e) {
573 if (e.getMessage().contains(INVALID_UEB_KEY)) {
574 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
576 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
578 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
579 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
581 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
584 @ApiOperation(value = "Gets active roles for an application.", response = CentralRole.class, responseContainer = "Json")
585 @RequestMapping(value = { "/activeRoles" }, method = RequestMethod.GET, produces = "application/json")
586 public List<CentralRole> getActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
587 List<CentralRole> roles = null;
589 fieldsValidation(request);
590 List<CentralV2Role> cenRoles= externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
591 roles = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles);
592 } catch (Exception e) {
593 sendErrorResponse(response, e);
594 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
600 @ApiOperation(value = "Gets active roles for an application.", response = CentralV2Role.class, responseContainer = "Json")
601 @RequestMapping(value = { "/v1/activeRoles" }, method = RequestMethod.GET, produces = "application/json")
602 public List<CentralV2Role> getV2ActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
603 List<CentralV2Role> cenRole = null;
605 fieldsValidation(request);
606 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
607 } catch (Exception e) {
608 sendErrorResponse(response, e);
609 logger.error(EELFLoggerDelegate.errorLogger, "getV2ActiveRoles failed", e);
615 @ApiOperation(value = "deletes user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
616 @RequestMapping(value = { "/deleteDependcyRoleRecord/{roleId}" }, method = RequestMethod.DELETE, produces = "application/json")
617 public PortalRestResponse<String> deleteDependencyRoleRecord(HttpServletRequest request, HttpServletResponse response,
618 @PathVariable("roleId") Long roleId) throws Exception {
619 ExternalRequestFieldsValidator removeResult = null;
621 fieldsValidation(request);
622 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
623 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
624 if (!removeResult.isResult()) {
625 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
626 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteDependencyRoleRecord",
629 } catch (Exception e) {
630 if (e.getMessage().contains(INVALID_UEB_KEY)) {
631 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
633 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
635 logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord failed", e);
636 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
638 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
642 @ApiOperation(value = "deletes roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
643 @RequestMapping(value = { "/v2/deleteRole/{roleId}" }, method = RequestMethod.DELETE, produces = "application/json")
644 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
645 @PathVariable("roleId") Long roleId) throws Exception {
646 ExternalRequestFieldsValidator removeResult = null;
648 fieldsValidation(request);
649 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
650 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
651 if (!removeResult.isResult()) {
652 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
653 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteRole",
656 } catch (Exception e) {
657 if (e.getMessage().contains(INVALID_UEB_KEY)) {
658 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
660 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
662 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
663 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
665 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
669 @ApiOperation(value = "Bulk upload functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
670 @RequestMapping(value = { "/upload/portal/functions" }, method = RequestMethod.POST, produces = "application/json")
671 public PortalRestResponse<String> bulkUploadFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
674 result = externalAccessRolesService.bulkUploadFunctions(request.getHeader(UEBKEY));
675 } catch (Exception e) {
676 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
677 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
678 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
680 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
683 @ApiOperation(value = "Bulk upload roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
684 @RequestMapping(value = { "/upload/portal/roles" }, method = RequestMethod.POST, produces = "application/json")
685 public PortalRestResponse<String> bulkUploadRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
688 result = externalAccessRolesService.bulkUploadRoles(request.getHeader(UEBKEY));
689 } catch (Exception e) {
690 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
691 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
692 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
694 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
697 @ApiOperation(value = "Bulk upload role functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
698 @RequestMapping(value = { "/upload/portal/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
699 public PortalRestResponse<String> bulkUploadRoleFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
702 result = externalAccessRolesService.bulkUploadRolesFunctions(request.getHeader(UEBKEY));
703 } catch (Exception e) {
704 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
705 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoleFunctions failed", e);
706 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoleFunctions", "Failed");
708 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
711 @ApiOperation(value = "Bulk upload user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
712 @RequestMapping(value = { "/upload/portal/userRoles" }, method = RequestMethod.POST, produces = "application/json")
713 public PortalRestResponse<String> bulkUploadUserRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
716 result = externalAccessRolesService.bulkUploadUserRoles(request.getHeader(UEBKEY));
717 } catch (Exception e) {
718 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
719 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUserRoles failed", e);
720 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUserRoles", "Failed");
722 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
725 @ApiOperation(value = "Bulk upload users for renamed role of an application.", response = PortalRestResponse.class, responseContainer = "Json")
726 @RequestMapping(value = { "/upload/portal/userRole/{roleId}" }, method = RequestMethod.POST, produces = "application/json")
727 public PortalRestResponse<String> bulkUploadUsersSingleRole(HttpServletRequest request, HttpServletResponse response, @PathVariable Long roleId) throws Exception {
730 String roleName = request.getHeader("RoleName");
731 result = externalAccessRolesService.bulkUploadUsersSingleRole(request.getHeader(UEBKEY), roleId, roleName);
732 } catch (Exception e) {
733 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
734 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUsersSingleRole failed", e);
735 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUsersSingleRole", "Failed");
737 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: "+result, "Success");
740 @ApiOperation(value = "Bulk upload functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
741 @RequestMapping(value = { "/upload/partner/functions" }, method = RequestMethod.POST, produces = "application/json")
742 public PortalRestResponse<String> bulkUploadPartnerFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
743 Integer addedFunctions = 0;
745 addedFunctions = externalAccessRolesService.bulkUploadPartnerFunctions(request.getHeader(UEBKEY));
746 } catch (Exception e) {
747 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
748 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
749 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
751 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: '"+addedFunctions+"' functions", "Success");
754 @ApiOperation(value = "Bulk upload roles for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
755 @RequestMapping(value = { "/upload/partner/roles" }, method = RequestMethod.POST, produces = "application/json")
756 public PortalRestResponse<String> bulkUploadPartnerRoles(HttpServletRequest request, HttpServletResponse response, @RequestBody List<Role> upload) throws Exception {
758 externalAccessRolesService.bulkUploadPartnerRoles(request.getHeader(UEBKEY), upload);
759 } catch (Exception e) {
760 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
761 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
762 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
764 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added", "Success");
767 @ApiOperation(value = "Bulk upload role functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
768 @RequestMapping(value = { "/upload/partner/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
769 public PortalRestResponse<String> bulkUploadPartnerRoleFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
770 Integer addedRoleFunctions = 0;
772 addedRoleFunctions = externalAccessRolesService.bulkUploadPartnerRoleFunctions(request.getHeader(UEBKEY));
773 } catch (Exception e) {
774 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
775 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadPartnerRoleFunctions failed", e);
776 return new PortalRestResponse<String>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadPartnerRoleFunctions", "Failed");
778 return new PortalRestResponse<String>(PortalRestStatusEnum.OK, "Successfully added: '"+addedRoleFunctions + "' role functions", "Success");
781 @ApiOperation(value = "Gets all functions along with global functions", response = List.class, responseContainer = "Json")
782 @RequestMapping(value = { "/menuFunctions" }, method = RequestMethod.GET, produces = "application/json")
783 public List<String> getMenuFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
784 List<String> functionsList = null;
786 fieldsValidation(request);
787 functionsList = externalAccessRolesService.getMenuFunctionsList(request.getHeader(UEBKEY));
788 } catch (Exception e) {
789 sendErrorResponse(response, e);
790 logger.error(EELFLoggerDelegate.errorLogger, "getMenuFunctions failed", e);
792 return functionsList;
795 @ApiOperation(value = "Gets all active Users of application", response = String.class, responseContainer = "Json")
796 @RequestMapping(value = { "/users" }, method = RequestMethod.GET, produces = "application/json")
797 public List<EcompUser> getUsersOfApplication(HttpServletRequest request, HttpServletResponse response) throws Exception {
798 List<EcompUser> users = null;
800 fieldsValidation(request);
801 users = externalAccessRolesService.getAllAppUsers(request.getHeader(UEBKEY));
802 } catch (Exception e) {
803 sendErrorResponse(response, e);
804 logger.error(EELFLoggerDelegate.errorLogger, "getUsersOfApplication failed", e);
811 * It checks the input uebkey of the application and throws exception if it is invalid key
816 private void fieldsValidation(HttpServletRequest request) throws Exception{
817 List<EPApp> app = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
819 throw new Exception(INVALID_UEB_KEY);
821 if(!app.isEmpty() && app.get(0).getCentralAuth()){
822 ResponseEntity<String> response = externalAccessRolesService.getNameSpaceIfExists(app.get(0));
823 if (response.getStatusCode().value() == HttpServletResponse.SC_NOT_FOUND)
824 throw new Exception("Invalid NameSpace");
830 * It returns http response with appropriate message
834 * @throws IOException
836 private void sendErrorResponse(HttpServletResponse response, Exception e) throws IOException {
837 response.setContentType("application/json");
838 response.setCharacterEncoding("UTF-8");
839 final Map<String,String> uebkeyResponse = new HashMap<>();
840 ObjectMapper mapper = new ObjectMapper();
842 if (e.getMessage().contains(INVALID_UEB_KEY)) {
843 uebkeyResponse.put("error",INVALID_UEB_KEY);
844 reason = mapper.writeValueAsString(uebkeyResponse);
845 response.getWriter().write(reason);
846 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
848 uebkeyResponse.put("error",e.getMessage());
849 reason = mapper.writeValueAsString(uebkeyResponse);
850 response.getWriter().write(reason);
851 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
855 @ApiOperation(value = "Gets ecompUser of an application.", response = CentralUser.class, responseContainer = "List")
856 @RequestMapping(value = { "/v2/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
857 public String getEcompUser(HttpServletRequest request, HttpServletResponse response,
858 @PathVariable("loginId") String loginId) throws Exception {
859 EcompUser user = new EcompUser();
860 ObjectMapper mapper = new ObjectMapper();
861 String answer = null;
863 fieldsValidation(request);
865 answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
866 if (answer != null) {
867 User ecompUser = userservice.userMapper(answer);
868 user = UserUtils.convertToEcompUser(ecompUser);
869 List<EcompRole> missingRolesOfUser = externalAccessRolesService.missingUserApplicationRoles(request.getHeader(UEBKEY), loginId, user.getRoles());
870 if (missingRolesOfUser.size() > 0) {
871 Set<EcompRole> roles = new TreeSet<EcompRole>(missingRolesOfUser);
872 user.getRoles().addAll(roles);
875 } catch (Exception e) {
876 sendErrorResponse(response, e);
877 logger.error(EELFLoggerDelegate.errorLogger, "getEcompUser failed", e);
879 return mapper.writeValueAsString(user);
882 @ApiOperation(value = "Gets user ecomp role for an application.", response = CentralUser.class, responseContainer = "List")
883 @RequestMapping(value = { "/v2/roles" }, method = RequestMethod.GET, produces = "application/json")
884 public List<EcompRole> getEcompRolesOfApplication(HttpServletRequest request, HttpServletResponse response)
886 List<EcompRole> ecompRoles = null;
887 ObjectMapper mapper = new ObjectMapper();
888 List<CentralV2Role> cenRole = null;
890 fieldsValidation(request);
891 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
892 // Sync all roles from external system into ONAP portal DB
893 logger.debug(EELFLoggerDelegate.debugLogger,
894 "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
895 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
896 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
897 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
898 } catch (Exception e) {
899 sendErrorResponse(response, e);
900 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
902 if (cenRole != null) {
903 String res = mapper.writeValueAsString(cenRole);
904 ecompRoles = new ArrayList<>();
905 List<Role> roles = mapper.readValue(res,
906 TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
907 for (Role role : roles)
908 ecompRoles.add(UserUtils.convertToEcompRole(role));
909 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getEcompRolesOfApplication");