2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
6 * ===================================================================
7 * Modification Copyright © 2020 IBM.
8 * ===================================================================
10 * Unless otherwise specified, all software contained herein is licensed
11 * under the Apache License, Version 2.0 (the "License");
12 * you may not use this software except in compliance with the License.
13 * You may obtain a copy of the License at
15 * http://www.apache.org/licenses/LICENSE-2.0
17 * Unless required by applicable law or agreed to in writing, software
18 * distributed under the License is distributed on an "AS IS" BASIS,
19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20 * See the License for the specific language governing permissions and
21 * limitations under the License.
23 * Unless otherwise specified, all documentation contained herein is licensed
24 * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
25 * you may not use this documentation except in compliance with the License.
26 * You may obtain a copy of the License at
28 * https://creativecommons.org/licenses/by/4.0/
30 * Unless required by applicable law or agreed to in writing, documentation
31 * distributed under the License is distributed on an "AS IS" BASIS,
32 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
33 * See the License for the specific language governing permissions and
34 * limitations under the License.
36 * ============LICENSE_END============================================
40 package org.onap.portalapp.portal.controller;
43 import java.io.IOException;
44 import java.util.ArrayList;
45 import java.util.HashMap;
46 import java.util.List;
49 import java.util.TreeSet;
51 import javax.servlet.http.HttpServletRequest;
52 import javax.servlet.http.HttpServletResponse;
54 import org.apache.commons.lang.StringUtils;
55 import org.onap.portalapp.portal.domain.CentralV2RoleFunction;
56 import org.onap.portalapp.portal.domain.EPApp;
57 import org.onap.portalapp.portal.domain.EPUser;
58 import org.onap.portalapp.portal.domain.EcompAuditLog;
59 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
60 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
61 import org.onap.portalapp.portal.exceptions.InvalidRoleException;
62 import org.onap.portalapp.portal.logging.aop.EPAuditLog;
63 import org.onap.portalapp.portal.logging.aop.EPEELFLoggerAdvice;
64 import org.onap.portalapp.portal.logging.logic.EPLogUtil;
65 import org.onap.portalapp.portal.service.ExternalAccessRolesService;
66 import org.onap.portalsdk.core.service.UserService;
67 import org.onap.portalapp.portal.transport.CentralRole;
68 import org.onap.portalapp.portal.transport.CentralRoleFunction;
69 import org.onap.portalapp.portal.transport.CentralUser;
70 import org.onap.portalapp.portal.transport.CentralV2Role;
71 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
72 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
73 import org.onap.portalapp.portal.utils.EcompPortalUtils;
74 import org.onap.portalapp.portal.utils.PortalConstants;
75 import org.onap.portalapp.validation.DataValidator;
76 import org.onap.portalapp.validation.SecureString;
77 import org.onap.portalsdk.core.domain.AuditLog;
78 import org.onap.portalsdk.core.domain.Role;
79 import org.onap.portalsdk.core.domain.User;
80 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
81 import org.onap.portalsdk.core.restful.domain.EcompRole;
82 import org.onap.portalsdk.core.restful.domain.EcompUser;
83 import org.onap.portalsdk.core.service.AuditService;
84 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
85 import org.onap.portalsdk.core.util.SystemProperties;
86 import org.onap.portalsdk.core.web.support.UserUtils;
88 import org.springframework.beans.BeanUtils;
89 import org.springframework.beans.factory.annotation.Autowired;
90 import org.springframework.context.annotation.EnableAspectJAutoProxy;
91 import org.springframework.http.ResponseEntity;
92 import org.springframework.web.bind.annotation.PathVariable;
93 import org.springframework.web.bind.annotation.RequestBody;
94 import org.springframework.web.bind.annotation.RequestMapping;
95 import org.springframework.web.bind.annotation.GetMapping;
96 import org.springframework.web.bind.annotation.PostMapping;
97 import org.springframework.web.bind.annotation.PutMapping;
98 import org.springframework.web.bind.annotation.DeleteMapping;
99 import org.springframework.web.bind.annotation.RequestMethod;
100 import org.springframework.web.bind.annotation.RestController;
102 import com.fasterxml.jackson.databind.DeserializationFeature;
103 import com.fasterxml.jackson.databind.ObjectMapper;
104 import com.fasterxml.jackson.databind.type.TypeFactory;
106 import io.swagger.annotations.ApiOperation;
109 @RequestMapping("/auxapi")
110 @org.springframework.context.annotation.Configuration
111 @EnableAspectJAutoProxy
113 public class ExternalAccessRolesController implements BasicAuthenticationController {
114 private static final String ROLE_INVALID_CHARS = "%=():,\"\"";
115 private static final String SUCCESSFULLY_DELETED = "Successfully Deleted";
116 private static final String INVALID_UEB_KEY = "Invalid credentials!";
117 private static final String LOGIN_ID = "LoginId";
118 private static final String UEBKEY = "uebkey";
120 private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ExternalAccessRolesController.class);
121 private static final DataValidator DATA_VALIDATOR = new DataValidator();
124 private AuditService auditService;
127 private ExternalAccessRolesService externalAccessRolesService;
130 private UserService userservice = new UserServiceCentalizedImpl();
132 @ApiOperation(value = "Gets user role for an application.", response = CentralUser.class, responseContainer="List")
133 @GetMapping(value = {
134 "/user/{loginId}" }, produces = "application/json")
135 public CentralUser getUser(HttpServletRequest request, HttpServletResponse response,
136 @PathVariable("loginId") String loginId) throws Exception {
137 if (!DATA_VALIDATOR.isValid(new SecureString(loginId))){
138 sendErrorResponse(response, new Exception("Data is not valid"));
139 logger.error(EELFLoggerDelegate.errorLogger, "getUser not valid data");
142 CentralUser answer = null;
144 fieldsValidation(request);
145 answer = externalAccessRolesService.getUserRoles(loginId, request.getHeader(UEBKEY));
146 } catch (Exception e) {
147 sendErrorResponse(response, e);
148 logger.error(EELFLoggerDelegate.errorLogger, "getUser failed", e);
153 @ApiOperation(value = "Gets user roles for an application which is upgraded to newer version.", response = String.class, responseContainer="List")
154 @GetMapping(value = {
155 "/v1/user/{loginId}" }, produces = "application/json")
156 public String getV2UserList(HttpServletRequest request, HttpServletResponse response,
157 @PathVariable("loginId") String loginId) throws Exception {
158 if (!DATA_VALIDATOR.isValid(new SecureString(loginId))){
159 sendErrorResponse(response, new Exception("Data is not valid"));
160 logger.error(EELFLoggerDelegate.errorLogger, "getV2UserList not valid data");
161 return "Data is not valid";
163 String answer = null;
165 fieldsValidation(request);
166 answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
167 } catch (Exception e) {
168 sendErrorResponse(response, e);
169 logger.error(EELFLoggerDelegate.errorLogger, "getV2UserList failed", e);
174 @ApiOperation(value = "Gets roles for an application.", response = CentralRole.class, responseContainer="Json")
175 @GetMapping(value = {
176 "/roles" }, produces = "application/json")
177 public List<CentralRole> getRolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
178 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRolesForApp");
179 List<CentralV2Role> v2CenRole = null;
180 List<CentralRole> cenRole = null;
182 fieldsValidation(request);
183 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
184 // Sync all roles from external system into ONAP portal DB
185 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
186 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
187 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
188 v2CenRole = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
189 cenRole = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(v2CenRole);
190 } catch (Exception e) {
191 sendErrorResponse(response, e);
192 logger.error(EELFLoggerDelegate.errorLogger, "getRolesForApp failed", e);
194 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRolesForApp");
198 @ApiOperation(value = "Gets roles for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
199 @GetMapping(value = {
200 "/v1/roles" }, produces = "application/json")
201 public List<CentralV2Role> getV2RolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
202 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RolesForApp");
203 List<CentralV2Role> answer = null;
205 fieldsValidation(request);
206 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
207 // Sync all roles from external system into ONAP portal DB
208 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Entering into syncApplicationRolesWithEcompDB");
209 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
210 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Finished syncApplicationRolesWithEcompDB");
211 answer = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
212 } catch (Exception e) {
213 sendErrorResponse(response, e);
214 logger.error(EELFLoggerDelegate.errorLogger, "getV2RolesForApp failed", e);
216 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RolesForApp");
220 @ApiOperation(value = "Gets all role functions for an application for older version.", response = CentralRoleFunction.class, responseContainer="Json")
221 @GetMapping(value = {
222 "/functions" }, produces = "application/json")
223 public List<CentralRoleFunction> getRoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
225 List<CentralV2RoleFunction> answer = null;
226 List<CentralRoleFunction> roleFuncList = null;
227 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleFunctionsList");
229 fieldsValidation(request);
230 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
231 // Sync all functions from external system into ONAP portal DB
232 logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
233 externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
234 logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
235 answer = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
236 roleFuncList = externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(answer);
237 } catch (Exception e) {
238 sendErrorResponse(response, e);
239 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunctionsList failed", e);
241 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleFunctionsList");
245 @ApiOperation(value = "Gets all role functions for an application which is upgraded to newer version.", response = CentralV2RoleFunction.class, responseContainer="Json")
246 @GetMapping(value = {
247 "/v1/functions" }, produces = "application/json")
248 public List<CentralV2RoleFunction> getV2RoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
250 List<CentralV2RoleFunction> cenRoleFuncList = null;
251 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleFunctionsList");
253 fieldsValidation(request);
254 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
255 // Sync all functions from external system into ONAP portal DB
256 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
257 externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
258 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
259 cenRoleFuncList = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
260 } catch (Exception e) {
261 sendErrorResponse(response, e);
262 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunctionsList failed", e);
264 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleFunctionsList");
265 return cenRoleFuncList;
269 @ApiOperation(value = "Gets role information for an application.", response = CentralRole.class, responseContainer="Json")
270 @GetMapping(value = {
271 "/role/{role_id}" }, produces = "application/json")
272 public CentralRole getRoleInfo(HttpServletRequest request, HttpServletResponse response,
273 @PathVariable("role_id") Long roleId) throws Exception {
274 CentralV2Role answer = null;
275 CentralRole cenRole = null;
276 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleInfo");
278 fieldsValidation(request);
279 answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
280 cenRole = externalAccessRolesService.convertV2CentralRoleToOldVerisonCentralRole(answer);
281 } catch (Exception e) {
282 sendErrorResponse(response, e);
283 logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo failed", e);
285 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleInfo");
289 @ApiOperation(value = "Gets v2 role information for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
290 @GetMapping(value = {
291 "/v1/role/{role_id}" }, produces = "application/json")
292 public CentralV2Role getV2RoleInfo(HttpServletRequest request, HttpServletResponse response,
293 @PathVariable("role_id") Long roleId) throws Exception {
294 CentralV2Role answer = null;
295 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleInfo");
297 fieldsValidation(request);
298 answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
299 } catch (Exception e) {
300 sendErrorResponse(response, e);
301 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleInfo failed", e);
303 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleInfo");
307 @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralRoleFunction.class, responseContainer = "Json")
308 @GetMapping(value = { "/function/{code}" }, produces = "application/json")
309 public CentralRoleFunction getRoleFunction(HttpServletRequest request, HttpServletResponse response,
310 @PathVariable("code") String code) throws Exception {
311 CentralV2RoleFunction centralV2RoleFunction = null;
312 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
313 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
314 sendErrorResponse(response, new Exception("Data is not valid"));
315 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunction failed", new Exception("Data is not valid"));
318 fieldsValidation(request);
319 centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
320 if(centralV2RoleFunction != null && EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
321 BeanUtils.copyProperties(centralV2RoleFunction, centralRoleFunction, "type","action");
323 } catch (Exception e) {
324 sendErrorResponse(response, e);
325 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunction failed", e);
327 return centralRoleFunction;
330 @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralV2RoleFunction.class, responseContainer = "Json")
331 @GetMapping(value = { "/v1/function/{code}" }, produces = "application/json")
332 public CentralV2RoleFunction getV2RoleFunction(HttpServletRequest request, HttpServletResponse response,
333 @PathVariable("code") String code) throws Exception {
334 CentralV2RoleFunction centralV2RoleFunction = null;
335 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
336 sendErrorResponse(response, new Exception("Data is not valid"));
337 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunction failed", new Exception("Data is not valid"));
340 fieldsValidation(request);
341 centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
342 if(centralV2RoleFunction == null || !EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
343 centralV2RoleFunction = new CentralV2RoleFunction();
345 } catch (Exception e) {
346 sendErrorResponse(response, e);
347 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunction failed", e);
349 return centralV2RoleFunction;
352 @ApiOperation(value = "Saves role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
353 @PostMapping(value = { "/roleFunction" }, produces = "application/json")
354 public PortalRestResponse<String> saveRoleFunction(HttpServletRequest request, HttpServletResponse response,
355 @RequestBody String roleFunc) {
356 String status = "Successfully saved!";
357 if(!DATA_VALIDATOR.isValid(new SecureString(roleFunc))){
358 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed");
359 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
360 "Failed to roleFunc, not valid data.", "Failed");
363 fieldsValidation(request);
364 ObjectMapper mapper = new ObjectMapper();
365 List<EPApp> applicationList = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
366 EPApp requestedApp = applicationList.get(0);
367 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
368 CentralV2RoleFunction availableRoleFunction = mapper.readValue(roleFunc, CentralV2RoleFunction.class);
369 CentralV2RoleFunction domainRoleFunction = null;
370 boolean isCentralV2Version = false;
371 if(availableRoleFunction.getType()!=null && availableRoleFunction.getAction()!= null) {
372 isCentralV2Version = true;
374 if(isCentralV2Version) {
375 String code = availableRoleFunction.getType()+"|"+availableRoleFunction.getCode()+"|"+availableRoleFunction.getAction();
376 domainRoleFunction = externalAccessRolesService.getRoleFunction(code,
377 requestedApp.getUebKey());
379 domainRoleFunction = externalAccessRolesService.getRoleFunction(availableRoleFunction.getCode(),
380 requestedApp.getUebKey());
383 boolean saveOrUpdateResponse = false;
384 if (domainRoleFunction != null && isCentralV2Version && domainRoleFunction.getCode().equals(availableRoleFunction.getCode())
385 && domainRoleFunction.getType().equals(availableRoleFunction.getType())
386 && domainRoleFunction.getAction().equals(availableRoleFunction.getAction())) {
387 domainRoleFunction.setName(availableRoleFunction.getName());
388 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(domainRoleFunction,
391 availableRoleFunction.setAppId(requestedApp.getId());
392 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(availableRoleFunction,
396 if(domainRoleFunction != null) {
397 status = "Successfully updated!";
399 if (saveOrUpdateResponse) {
400 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
401 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
402 String activityCode = (!status.equals("Successfully updated!"))
403 ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_FUNCTION
404 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_FUNCTION;
405 logger.info(EELFLoggerDelegate.applicationLogger, "saveRoleFunction: succeeded for app {}, function {}",
406 app.getId(), availableRoleFunction.getCode());
407 AuditLog auditLog = new AuditLog();
408 auditLog.setUserId(user.getId());
409 auditLog.setActivityCode(activityCode);
410 auditLog.setComments(
411 EcompPortalUtils.truncateString(
412 "saveRoleFunction role for app:" + app.getId() + " and function:'"
413 + availableRoleFunction.getCode() + "'",
414 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
415 auditLog.setAffectedRecordId(user.getOrgUserId());
416 auditService.logActivity(auditLog, null);
417 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
418 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
419 EcompPortalUtils.calculateDateTimeDifferenceForLog(
420 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
421 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
422 logger.info(EELFLoggerDelegate.auditLogger,
423 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRoleFunction", activityCode,
424 String.valueOf(user.getId()), user.getOrgUserId(), availableRoleFunction.getCode()));
425 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
426 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
427 MDC.remove(SystemProperties.MDC_TIMER);
429 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed");
430 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
431 "Failed to saveRoleFunction for '" + availableRoleFunction.getCode() + "'", "Failed");
433 } catch (Exception e) {
434 if (e.getMessage() == null ||e.getMessage().contains(INVALID_UEB_KEY)) {
435 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
437 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
439 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed", e);
440 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
442 return new PortalRestResponse<>(PortalRestStatusEnum.OK, status, "Success");
445 @ApiOperation(value = "Deletes role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
446 @DeleteMapping(value = { "/roleFunction/{code}" }, produces = "application/json")
447 public PortalRestResponse<String> deleteRoleFunction(HttpServletRequest request, HttpServletResponse response,
448 @PathVariable("code") String code) {
449 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
450 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
451 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
452 "Failed to deleteRoleFunction, not valid data.", "Failed");
455 fieldsValidation(request);
456 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
457 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
458 boolean getDelFuncResponse = externalAccessRolesService.deleteCentralRoleFunction(code, app);
459 if (getDelFuncResponse) {
460 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRoleFunction: succeeded for app {}, role {}",
462 AuditLog auditLog = new AuditLog();
463 auditLog.setUserId(user.getId());
464 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION);
465 auditLog.setComments(EcompPortalUtils.truncateString(
466 "Deleted function for app:" + app.getId() + " and function code:'" + code + "'",
467 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
468 auditLog.setAffectedRecordId(user.getOrgUserId());
469 auditService.logActivity(auditLog, null);
470 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
471 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
472 EcompPortalUtils.calculateDateTimeDifferenceForLog(
473 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
474 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
475 logger.info(EELFLoggerDelegate.auditLogger,
476 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRoleFunction",
477 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION, String.valueOf(user.getId()),
478 user.getOrgUserId(), code));
479 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
480 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
481 MDC.remove(SystemProperties.MDC_TIMER);
483 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
484 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
485 "Failed to deleteRoleFunction for '" + code + "'", "Failed");
487 } catch (Exception e) {
488 if (e.getMessage().contains(INVALID_UEB_KEY)) {
489 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
491 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
493 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed", e);
494 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
496 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
500 @ApiOperation(value = "Saves role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
501 @PostMapping(value = { "/role" }, produces = "application/json")
502 public PortalRestResponse<String> saveRole(HttpServletRequest request, HttpServletResponse response,
503 @RequestBody Role role) {
505 fieldsValidation(request);
506 ExternalRequestFieldsValidator saveRoleResult = null;
507 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
508 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
509 if(role.getId()!=null && StringUtils.containsAny(role.getName(), ROLE_INVALID_CHARS)) {
510 throw new InvalidRoleException("Invalid role name found for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed");
512 saveRoleResult = externalAccessRolesService.saveRoleForApplication(role, request.getHeader(UEBKEY));
513 if (saveRoleResult.isResult()) {
514 String activityCode = (role.getId() == null) ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_ROLE
515 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_ROLE_AND_FUNCTION;
516 logger.info(EELFLoggerDelegate.applicationLogger, "saveRole: succeeded for app {}, role {}",
517 app.getId(), role.getName());
518 AuditLog auditLog = new AuditLog();
519 auditLog.setUserId(user.getId());
520 auditLog.setActivityCode(activityCode);
521 auditLog.setComments(EcompPortalUtils.truncateString(
522 "saveRole role for app:" + app.getId() + " and role:'" + role.getName() + "'",
523 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
524 auditLog.setAffectedRecordId(user.getOrgUserId());
525 auditService.logActivity(auditLog, null);
526 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
527 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
528 EcompPortalUtils.calculateDateTimeDifferenceForLog(
529 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
530 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
531 logger.info(EELFLoggerDelegate.auditLogger,
532 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRole", activityCode,
533 String.valueOf(user.getId()), user.getOrgUserId(), role.getName()));
534 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
535 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
536 MDC.remove(SystemProperties.MDC_TIMER);
538 if(saveRoleResult.getDetailMessage().contains("406")){
539 response.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
540 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
541 "Failed to create a role for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed"
544 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
545 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
546 "Failed to saveRole for '" + role.getName() + "'", "Failed");
549 } catch (Exception e) {
550 if (e.getMessage().contains(INVALID_UEB_KEY)) {
551 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
553 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
555 logger.error(EELFLoggerDelegate.errorLogger, "saveRole failed", e);
556 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
558 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
561 @ApiOperation(value = "Deletes role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
562 @DeleteMapping(value = { "/deleteRole/{code}" }, produces = "application/json")
563 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
564 @PathVariable String code) {
565 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
566 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
567 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
568 "Failed to deleteRole, not valid data.", "Failed");
571 fieldsValidation(request);
572 boolean deleteResponse = externalAccessRolesService.deleteRoleForApplication(code,
573 request.getHeader(UEBKEY));
574 if (deleteResponse) {
575 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
576 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
577 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRole: succeeded for app {}, role {}",
579 AuditLog auditLog = new AuditLog();
580 auditLog.setUserId(user.getId());
581 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE);
582 auditLog.setComments(EcompPortalUtils.truncateString(
583 "Deleted role for app:" + app.getId() + " and role:'" + code + "'",
584 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
585 auditLog.setAffectedRecordId(user.getOrgUserId());
586 auditService.logActivity(auditLog, null);
587 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
588 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
589 EcompPortalUtils.calculateDateTimeDifferenceForLog(
590 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
591 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
592 logger.info(EELFLoggerDelegate.auditLogger,
593 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRole",
594 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE, String.valueOf(user.getId()),
595 user.getOrgUserId(), code));
596 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
597 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
598 MDC.remove(SystemProperties.MDC_TIMER);
600 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
601 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
602 "Failed to deleteRole for '" + code + "'", "Failed");
604 } catch (Exception e) {
605 if (e.getMessage().contains(INVALID_UEB_KEY)) {
606 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
608 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
610 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
611 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
613 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
616 @ApiOperation(value = "Gets active roles for an application.", response = CentralRole.class, responseContainer = "Json")
617 @GetMapping(value = { "/activeRoles" }, produces = "application/json")
618 public List<CentralRole> getActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
619 List<CentralRole> roles = null;
621 fieldsValidation(request);
622 List<CentralV2Role> cenRoles= externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
623 roles = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles);
624 } catch (Exception e) {
625 sendErrorResponse(response, e);
626 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
632 @ApiOperation(value = "Gets active roles for an application.", response = CentralV2Role.class, responseContainer = "Json")
633 @GetMapping(value = { "/v1/activeRoles" }, produces = "application/json")
634 public List<CentralV2Role> getV2ActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
635 List<CentralV2Role> cenRole = null;
637 fieldsValidation(request);
638 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
639 } catch (Exception e) {
640 sendErrorResponse(response, e);
641 logger.error(EELFLoggerDelegate.errorLogger, "getV2ActiveRoles failed", e);
647 @ApiOperation(value = "deletes user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
648 @DeleteMapping(value = { "/deleteDependcyRoleRecord/{roleId}" }, produces = "application/json")
649 public PortalRestResponse<String> deleteDependencyRoleRecord(HttpServletRequest request, HttpServletResponse response,
650 @PathVariable("roleId") Long roleId) {
651 ExternalRequestFieldsValidator removeResult = null;
653 fieldsValidation(request);
654 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
655 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
656 if (!removeResult.isResult()) {
657 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
658 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteDependencyRoleRecord",
661 } catch (Exception e) {
662 if (e.getMessage().contains(INVALID_UEB_KEY)) {
663 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
665 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
667 logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord failed", e);
668 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
670 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
674 @ApiOperation(value = "deletes roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
675 @DeleteMapping(value = { "/v2/deleteRole/{roleId}" }, produces = "application/json")
676 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
677 @PathVariable("roleId") Long roleId) {
678 ExternalRequestFieldsValidator removeResult = null;
680 fieldsValidation(request);
681 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
682 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
683 if (!removeResult.isResult()) {
684 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
685 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteRole",
688 } catch (Exception e) {
689 if (e.getMessage().contains(INVALID_UEB_KEY)) {
690 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
692 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
694 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
695 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
697 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
701 @ApiOperation(value = "Bulk upload functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
702 @PostMapping(value = { "/upload/portal/functions" }, produces = "application/json")
703 public PortalRestResponse<String> bulkUploadFunctions(HttpServletRequest request, HttpServletResponse response) {
706 result = externalAccessRolesService.bulkUploadFunctions(request.getHeader(UEBKEY));
707 } catch (Exception e) {
708 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
709 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
710 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
712 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
715 @ApiOperation(value = "Bulk upload roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
716 @PostMapping(value = { "/upload/portal/roles" }, produces = "application/json")
717 public PortalRestResponse<String> bulkUploadRoles(HttpServletRequest request, HttpServletResponse response) {
720 result = externalAccessRolesService.bulkUploadRoles(request.getHeader(UEBKEY));
721 } catch (Exception e) {
722 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
723 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
724 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
726 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
729 @ApiOperation(value = "Bulk upload role functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
730 @PostMapping(value = { "/upload/portal/roleFunctions" }, produces = "application/json")
731 public PortalRestResponse<String> bulkUploadRoleFunctions(HttpServletRequest request, HttpServletResponse response) {
734 result = externalAccessRolesService.bulkUploadRolesFunctions(request.getHeader(UEBKEY));
735 } catch (Exception e) {
736 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
737 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoleFunctions failed", e);
738 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoleFunctions", "Failed");
740 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
743 @ApiOperation(value = "Bulk upload user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
744 @PostMapping(value = { "/upload/portal/userRoles" }, produces = "application/json")
745 public PortalRestResponse<String> bulkUploadUserRoles(HttpServletRequest request, HttpServletResponse response) {
748 result = externalAccessRolesService.bulkUploadUserRoles(request.getHeader(UEBKEY));
749 } catch (Exception e) {
750 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
751 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUserRoles failed", e);
752 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUserRoles", "Failed");
754 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
757 @ApiOperation(value = "Bulk upload users for renamed role of an application.", response = PortalRestResponse.class, responseContainer = "Json")
758 @PostMapping(value = { "/upload/portal/userRole/{roleId}" }, produces = "application/json")
759 public PortalRestResponse<String> bulkUploadUsersSingleRole(HttpServletRequest request, HttpServletResponse response, @PathVariable Long roleId) {
762 String roleName = request.getHeader("RoleName");
763 result = externalAccessRolesService.bulkUploadUsersSingleRole(request.getHeader(UEBKEY), roleId, roleName);
764 } catch (Exception e) {
765 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
766 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUsersSingleRole failed", e);
767 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUsersSingleRole", "Failed");
769 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
772 @ApiOperation(value = "Bulk upload functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
773 @PostMapping(value = { "/upload/partner/functions" }, produces = "application/json")
774 public PortalRestResponse<String> bulkUploadPartnerFunctions(HttpServletRequest request, HttpServletResponse response) {
775 Integer addedFunctions = 0;
777 addedFunctions = externalAccessRolesService.bulkUploadPartnerFunctions(request.getHeader(UEBKEY));
778 } catch (Exception e) {
779 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
780 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
781 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
783 return new PortalRestResponse<>(PortalRestStatusEnum.OK,
784 "Successfully added: '" + addedFunctions + "' functions", "Success");
787 @ApiOperation(value = "Bulk upload roles for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
788 @PostMapping(value = { "/upload/partner/roles" }, produces = "application/json")
789 public PortalRestResponse<String> bulkUploadPartnerRoles(HttpServletRequest request, HttpServletResponse response, @RequestBody List<Role> upload) {
791 externalAccessRolesService.bulkUploadPartnerRoles(request.getHeader(UEBKEY), upload);
792 } catch (Exception e) {
793 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
794 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
795 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
797 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added", "Success");
800 @ApiOperation(value = "Bulk upload role functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
801 @PostMapping(value = { "/upload/partner/roleFunctions" }, produces = "application/json")
802 public PortalRestResponse<String> bulkUploadPartnerRoleFunctions(HttpServletRequest request, HttpServletResponse response) {
803 Integer addedRoleFunctions = 0;
805 addedRoleFunctions = externalAccessRolesService.bulkUploadPartnerRoleFunctions(request.getHeader(UEBKEY));
806 } catch (Exception e) {
807 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
808 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadPartnerRoleFunctions failed", e);
809 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadPartnerRoleFunctions",
812 return new PortalRestResponse<>(PortalRestStatusEnum.OK,
813 "Successfully added: '" + addedRoleFunctions + "' role functions", "Success");
816 @ApiOperation(value = "Gets all functions along with global functions", response = List.class, responseContainer = "Json")
817 @GetMapping(value = { "/menuFunctions" }, produces = "application/json")
818 public List<String> getMenuFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
819 List<String> functionsList = null;
821 fieldsValidation(request);
822 functionsList = externalAccessRolesService.getMenuFunctionsList(request.getHeader(UEBKEY));
823 } catch (Exception e) {
824 sendErrorResponse(response, e);
825 logger.error(EELFLoggerDelegate.errorLogger, "getMenuFunctions failed", e);
827 return functionsList;
830 @ApiOperation(value = "Gets all active Users of application", response = String.class, responseContainer = "Json")
831 @GetMapping(value = { "/users" }, produces = "application/json")
832 public List<EcompUser> getUsersOfApplication(HttpServletRequest request, HttpServletResponse response) throws Exception {
833 List<EcompUser> users = null;
835 fieldsValidation(request);
836 users = externalAccessRolesService.getAllAppUsers(request.getHeader(UEBKEY));
837 } catch (Exception e) {
838 sendErrorResponse(response, e);
839 logger.error(EELFLoggerDelegate.errorLogger, "getUsersOfApplication failed", e);
846 * It checks the input uebkey of the application and throws exception if it is invalid key
851 private void fieldsValidation(HttpServletRequest request) throws Exception{
852 List<EPApp> app = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
854 throw new Exception(INVALID_UEB_KEY);
856 if(!app.isEmpty() && app.get(0).getCentralAuth()){
857 ResponseEntity<String> response = externalAccessRolesService.getNameSpaceIfExists(app.get(0));
858 if (response.getStatusCode().value() == HttpServletResponse.SC_NOT_FOUND)
859 throw new Exception("Invalid NameSpace");
865 * It returns http response with appropriate message
869 * @throws IOException
871 private void sendErrorResponse(HttpServletResponse response, Exception e) throws IOException {
872 response.setContentType("application/json");
873 response.setCharacterEncoding("UTF-8");
874 final Map<String,String> uebkeyResponse = new HashMap<>();
875 ObjectMapper mapper = new ObjectMapper();
877 if (e.getMessage().contains(INVALID_UEB_KEY)) {
878 uebkeyResponse.put("error",INVALID_UEB_KEY);
879 reason = mapper.writeValueAsString(uebkeyResponse);
880 response.getWriter().write(reason);
881 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
883 uebkeyResponse.put("error",e.getMessage());
884 reason = mapper.writeValueAsString(uebkeyResponse);
885 response.getWriter().write(reason);
886 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
890 @ApiOperation(value = "Gets ecompUser of an application.", response = CentralUser.class, responseContainer = "List")
891 @GetMapping(value = { "/v2/user/{loginId}" }, produces = "application/json")
892 public String getEcompUser(HttpServletRequest request, HttpServletResponse response,
893 @PathVariable("loginId") String loginId) throws Exception {
894 if(!DATA_VALIDATOR.isValid(new SecureString(loginId))){
895 sendErrorResponse(response, new Exception("getEcompUser failed"));
896 logger.error(EELFLoggerDelegate.errorLogger, "getEcompUser failed", new Exception("getEcompUser failed"));
898 EcompUser user = new EcompUser();
899 ObjectMapper mapper = new ObjectMapper();
900 String answer = null;
902 fieldsValidation(request);
904 answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
905 if (answer != null) {
906 User ecompUser = userservice.userMapper(answer);
907 user = UserUtils.convertToEcompUser(ecompUser);
908 List<EcompRole> missingRolesOfUser = externalAccessRolesService.missingUserApplicationRoles(request.getHeader(UEBKEY), loginId, user.getRoles());
909 if (missingRolesOfUser.size() > 0) {
910 Set<EcompRole> roles = new TreeSet<>(missingRolesOfUser);
911 user.getRoles().addAll(roles);
914 } catch (Exception e) {
915 sendErrorResponse(response, e);
916 logger.error(EELFLoggerDelegate.errorLogger, "getEcompUser failed", e);
918 return mapper.writeValueAsString(user);
921 @ApiOperation(value = "Gets user ecomp role for an application.", response = CentralUser.class, responseContainer = "List")
922 @GetMapping(value = { "/v2/roles" }, produces = "application/json")
923 public List<EcompRole> getEcompRolesOfApplication(HttpServletRequest request, HttpServletResponse response)
925 List<EcompRole> ecompRoles = null;
926 ObjectMapper mapper = new ObjectMapper();
927 List<CentralV2Role> cenRole = null;
929 fieldsValidation(request);
930 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
931 // Sync all roles from external system into ONAP portal DB
932 logger.debug(EELFLoggerDelegate.debugLogger,
933 "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
934 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
935 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
936 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
937 } catch (Exception e) {
938 sendErrorResponse(response, e);
939 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
941 if (cenRole != null) {
942 String res = mapper.writeValueAsString(cenRole);
943 ecompRoles = new ArrayList<>();
944 List<Role> roles = mapper.readValue(res,
945 TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
946 for (Role role : roles)
947 ecompRoles.add(UserUtils.convertToEcompRole(role));
948 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getEcompRolesOfApplication");