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.portalsdk.core.service.UserService;
65 import org.onap.portalapp.portal.transport.CentralRole;
66 import org.onap.portalapp.portal.transport.CentralRoleFunction;
67 import org.onap.portalapp.portal.transport.CentralUser;
68 import org.onap.portalapp.portal.transport.CentralV2Role;
69 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
70 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
71 import org.onap.portalapp.portal.utils.EcompPortalUtils;
72 import org.onap.portalapp.portal.utils.PortalConstants;
73 import org.onap.portalapp.validation.DataValidator;
74 import org.onap.portalapp.validation.SecureString;
75 import org.onap.portalsdk.core.domain.AuditLog;
76 import org.onap.portalsdk.core.domain.Role;
77 import org.onap.portalsdk.core.domain.User;
78 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
79 import org.onap.portalsdk.core.restful.domain.EcompRole;
80 import org.onap.portalsdk.core.restful.domain.EcompUser;
81 import org.onap.portalsdk.core.service.AuditService;
82 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
83 import org.onap.portalsdk.core.util.SystemProperties;
84 import org.onap.portalsdk.core.web.support.UserUtils;
86 import org.springframework.beans.BeanUtils;
87 import org.springframework.beans.factory.annotation.Autowired;
88 import org.springframework.context.annotation.EnableAspectJAutoProxy;
89 import org.springframework.http.ResponseEntity;
90 import org.springframework.web.bind.annotation.PathVariable;
91 import org.springframework.web.bind.annotation.RequestBody;
92 import org.springframework.web.bind.annotation.RequestMapping;
93 import org.springframework.web.bind.annotation.RequestMethod;
94 import org.springframework.web.bind.annotation.RestController;
96 import com.fasterxml.jackson.databind.DeserializationFeature;
97 import com.fasterxml.jackson.databind.ObjectMapper;
98 import com.fasterxml.jackson.databind.type.TypeFactory;
100 import io.swagger.annotations.ApiOperation;
103 @RequestMapping("/auxapi")
104 @org.springframework.context.annotation.Configuration
105 @EnableAspectJAutoProxy
107 public class ExternalAccessRolesController implements BasicAuthenticationController {
108 private static final String ROLE_INVALID_CHARS = "%=():,\"\"";
109 private static final String SUCCESSFULLY_DELETED = "Successfully Deleted";
110 private static final String INVALID_UEB_KEY = "Invalid credentials!";
111 private static final String LOGIN_ID = "LoginId";
112 private static final String UEBKEY = "uebkey";
114 private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ExternalAccessRolesController.class);
115 private static final DataValidator DATA_VALIDATOR = new DataValidator();
118 private AuditService auditService;
121 private ExternalAccessRolesService externalAccessRolesService;
124 private UserService userservice = new UserServiceCentalizedImpl();
126 @ApiOperation(value = "Gets user role for an application.", response = CentralUser.class, responseContainer="List")
127 @RequestMapping(value = {
128 "/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
129 public CentralUser getUser(HttpServletRequest request, HttpServletResponse response,
130 @PathVariable("loginId") String loginId) throws Exception {
131 if (!DATA_VALIDATOR.isValid(new SecureString(loginId))){
132 sendErrorResponse(response, new Exception("Data is not valid"));
133 logger.error(EELFLoggerDelegate.errorLogger, "getUser not valid data");
136 CentralUser answer = null;
138 fieldsValidation(request);
139 answer = externalAccessRolesService.getUserRoles(loginId, request.getHeader(UEBKEY));
140 } catch (Exception e) {
141 sendErrorResponse(response, e);
142 logger.error(EELFLoggerDelegate.errorLogger, "getUser failed", e);
147 @ApiOperation(value = "Gets user roles for an application which is upgraded to newer version.", response = String.class, responseContainer="List")
148 @RequestMapping(value = {
149 "/v1/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
150 public String getV2UserList(HttpServletRequest request, HttpServletResponse response,
151 @PathVariable("loginId") String loginId) throws Exception {
152 if (!DATA_VALIDATOR.isValid(new SecureString(loginId))){
153 sendErrorResponse(response, new Exception("Data is not valid"));
154 logger.error(EELFLoggerDelegate.errorLogger, "getV2UserList not valid data");
155 return "Data is not valid";
157 String answer = null;
159 fieldsValidation(request);
160 answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
161 } catch (Exception e) {
162 sendErrorResponse(response, e);
163 logger.error(EELFLoggerDelegate.errorLogger, "getV2UserList failed", e);
168 @ApiOperation(value = "Gets roles for an application.", response = CentralRole.class, responseContainer="Json")
169 @RequestMapping(value = {
170 "/roles" }, method = RequestMethod.GET, produces = "application/json")
171 public List<CentralRole> getRolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
172 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRolesForApp");
173 List<CentralV2Role> v2CenRole = null;
174 List<CentralRole> cenRole = null;
176 fieldsValidation(request);
177 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
178 // Sync all roles from external system into ONAP portal DB
179 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
180 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
181 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
182 v2CenRole = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
183 cenRole = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(v2CenRole);
184 } catch (Exception e) {
185 sendErrorResponse(response, e);
186 logger.error(EELFLoggerDelegate.errorLogger, "getRolesForApp failed", e);
188 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRolesForApp");
192 @ApiOperation(value = "Gets roles for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
193 @RequestMapping(value = {
194 "/v1/roles" }, method = RequestMethod.GET, produces = "application/json")
195 public List<CentralV2Role> getV2RolesForApp(HttpServletRequest request, HttpServletResponse response) throws Exception {
196 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RolesForApp");
197 List<CentralV2Role> answer = null;
199 fieldsValidation(request);
200 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
201 // Sync all roles from external system into ONAP portal DB
202 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Entering into syncApplicationRolesWithEcompDB");
203 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
204 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RolesForApp: Finished syncApplicationRolesWithEcompDB");
205 answer = externalAccessRolesService.getRolesForApp(request.getHeader(UEBKEY));
206 } catch (Exception e) {
207 sendErrorResponse(response, e);
208 logger.error(EELFLoggerDelegate.errorLogger, "getV2RolesForApp failed", e);
210 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RolesForApp");
214 @ApiOperation(value = "Gets all role functions for an application for older version.", response = CentralRoleFunction.class, responseContainer="Json")
215 @RequestMapping(value = {
216 "/functions" }, method = RequestMethod.GET, produces = "application/json")
217 public List<CentralRoleFunction> getRoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
219 List<CentralV2RoleFunction> answer = null;
220 List<CentralRoleFunction> roleFuncList = null;
221 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleFunctionsList");
223 fieldsValidation(request);
224 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
225 // Sync all functions from external system into ONAP portal DB
226 logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
227 externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
228 logger.debug(EELFLoggerDelegate.debugLogger, "getRoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
229 answer = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
230 roleFuncList = externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(answer);
231 } catch (Exception e) {
232 sendErrorResponse(response, e);
233 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunctionsList failed", e);
235 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleFunctionsList");
239 @ApiOperation(value = "Gets all role functions for an application which is upgraded to newer version.", response = CentralV2RoleFunction.class, responseContainer="Json")
240 @RequestMapping(value = {
241 "/v1/functions" }, method = RequestMethod.GET, produces = "application/json")
242 public List<CentralV2RoleFunction> getV2RoleFunctionsList(HttpServletRequest request, HttpServletResponse response)
244 List<CentralV2RoleFunction> cenRoleFuncList = null;
245 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleFunctionsList");
247 fieldsValidation(request);
248 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
249 // Sync all functions from external system into ONAP portal DB
250 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Entering into syncRoleFunctionFromExternalAccessSystem");
251 externalAccessRolesService.syncRoleFunctionFromExternalAccessSystem(app);
252 logger.debug(EELFLoggerDelegate.debugLogger, "getV2RoleFunctionsList: Finished syncRoleFunctionFromExternalAccessSystem");
253 cenRoleFuncList = externalAccessRolesService.getRoleFuncList(request.getHeader(UEBKEY));
254 } catch (Exception e) {
255 sendErrorResponse(response, e);
256 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunctionsList failed", e);
258 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleFunctionsList");
259 return cenRoleFuncList;
263 @ApiOperation(value = "Gets role information for an application.", response = CentralRole.class, responseContainer="Json")
264 @RequestMapping(value = {
265 "/role/{role_id}" }, method = RequestMethod.GET, produces = "application/json")
266 public CentralRole getRoleInfo(HttpServletRequest request, HttpServletResponse response,
267 @PathVariable("role_id") Long roleId) throws Exception {
268 CentralV2Role answer = null;
269 CentralRole cenRole = null;
270 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getRoleInfo");
272 fieldsValidation(request);
273 answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
274 cenRole = externalAccessRolesService.convertV2CentralRoleToOldVerisonCentralRole(answer);
275 } catch (Exception e) {
276 sendErrorResponse(response, e);
277 logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo failed", e);
279 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getRoleInfo");
283 @ApiOperation(value = "Gets v2 role information for an application which is upgraded to newer version.", response = CentralV2Role.class, responseContainer="Json")
284 @RequestMapping(value = {
285 "/v1/role/{role_id}" }, method = RequestMethod.GET, produces = "application/json")
286 public CentralV2Role getV2RoleInfo(HttpServletRequest request, HttpServletResponse response,
287 @PathVariable("role_id") Long roleId) throws Exception {
288 CentralV2Role answer = null;
289 logger.debug(EELFLoggerDelegate.debugLogger, "Request received for getV2RoleInfo");
291 fieldsValidation(request);
292 answer = externalAccessRolesService.getRoleInfo(roleId, request.getHeader(UEBKEY));
293 } catch (Exception e) {
294 sendErrorResponse(response, e);
295 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleInfo failed", e);
297 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getV2RoleInfo");
301 @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralRoleFunction.class, responseContainer = "Json")
302 @RequestMapping(value = { "/function/{code}" }, method = RequestMethod.GET, produces = "application/json")
303 public CentralRoleFunction getRoleFunction(HttpServletRequest request, HttpServletResponse response,
304 @PathVariable("code") String code) throws Exception {
305 CentralV2RoleFunction centralV2RoleFunction = null;
306 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
307 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
308 sendErrorResponse(response, new Exception("Data is not valid"));
309 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunction failed", new Exception("Data is not valid"));
312 fieldsValidation(request);
313 centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
314 if(centralV2RoleFunction != null && EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
315 BeanUtils.copyProperties(centralV2RoleFunction, centralRoleFunction, "type","action");
317 } catch (Exception e) {
318 sendErrorResponse(response, e);
319 logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunction failed", e);
321 return centralRoleFunction;
324 @ApiOperation(value = "Gets role information for an application provided by function code.", response = CentralV2RoleFunction.class, responseContainer = "Json")
325 @RequestMapping(value = { "/v1/function/{code}" }, method = RequestMethod.GET, produces = "application/json")
326 public CentralV2RoleFunction getV2RoleFunction(HttpServletRequest request, HttpServletResponse response,
327 @PathVariable("code") String code) throws Exception {
328 CentralV2RoleFunction centralV2RoleFunction = null;
329 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
330 sendErrorResponse(response, new Exception("Data is not valid"));
331 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunction failed", new Exception("Data is not valid"));
334 fieldsValidation(request);
335 centralV2RoleFunction = externalAccessRolesService.getRoleFunction(code, request.getHeader(UEBKEY));
336 if(centralV2RoleFunction == null || !EcompPortalUtils.getFunctionCode(centralV2RoleFunction.getCode()).equals(code)) {
337 centralV2RoleFunction = new CentralV2RoleFunction();
339 } catch (Exception e) {
340 sendErrorResponse(response, e);
341 logger.error(EELFLoggerDelegate.errorLogger, "getV2RoleFunction failed", e);
343 return centralV2RoleFunction;
346 @ApiOperation(value = "Saves role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
347 @RequestMapping(value = { "/roleFunction" }, method = RequestMethod.POST, produces = "application/json")
348 public PortalRestResponse<String> saveRoleFunction(HttpServletRequest request, HttpServletResponse response,
349 @RequestBody String roleFunc) {
350 String status = "Successfully saved!";
351 if(!DATA_VALIDATOR.isValid(new SecureString(roleFunc))){
352 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed");
353 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
354 "Failed to roleFunc, not valid data.", "Failed");
357 fieldsValidation(request);
358 ObjectMapper mapper = new ObjectMapper();
359 List<EPApp> applicationList = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
360 EPApp requestedApp = applicationList.get(0);
361 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
362 CentralV2RoleFunction availableRoleFunction = mapper.readValue(roleFunc, CentralV2RoleFunction.class);
363 CentralV2RoleFunction domainRoleFunction = null;
364 boolean isCentralV2Version = false;
365 if(availableRoleFunction.getType()!=null && availableRoleFunction.getAction()!= null) {
366 isCentralV2Version = true;
368 if(isCentralV2Version) {
369 String code = availableRoleFunction.getType()+"|"+availableRoleFunction.getCode()+"|"+availableRoleFunction.getAction();
370 domainRoleFunction = externalAccessRolesService.getRoleFunction(code,
371 requestedApp.getUebKey());
373 domainRoleFunction = externalAccessRolesService.getRoleFunction(availableRoleFunction.getCode(),
374 requestedApp.getUebKey());
377 boolean saveOrUpdateResponse = false;
378 if (domainRoleFunction != null && isCentralV2Version && domainRoleFunction.getCode().equals(availableRoleFunction.getCode())
379 && domainRoleFunction.getType().equals(availableRoleFunction.getType())
380 && domainRoleFunction.getAction().equals(availableRoleFunction.getAction())) {
381 domainRoleFunction.setName(availableRoleFunction.getName());
382 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(domainRoleFunction,
385 availableRoleFunction.setAppId(requestedApp.getId());
386 saveOrUpdateResponse = externalAccessRolesService.saveCentralRoleFunction(availableRoleFunction,
390 if(domainRoleFunction != null) {
391 status = "Successfully updated!";
393 if (saveOrUpdateResponse) {
394 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
395 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
396 String activityCode = (!status.equals("Successfully updated!"))
397 ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_FUNCTION
398 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_FUNCTION;
399 logger.info(EELFLoggerDelegate.applicationLogger, "saveRoleFunction: succeeded for app {}, function {}",
400 app.getId(), availableRoleFunction.getCode());
401 AuditLog auditLog = new AuditLog();
402 auditLog.setUserId(user.getId());
403 auditLog.setActivityCode(activityCode);
404 auditLog.setComments(
405 EcompPortalUtils.truncateString(
406 "saveRoleFunction role for app:" + app.getId() + " and function:'"
407 + availableRoleFunction.getCode() + "'",
408 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
409 auditLog.setAffectedRecordId(user.getOrgUserId());
410 auditService.logActivity(auditLog, null);
411 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
412 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
413 EcompPortalUtils.calculateDateTimeDifferenceForLog(
414 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
415 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
416 logger.info(EELFLoggerDelegate.auditLogger,
417 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRoleFunction", activityCode,
418 String.valueOf(user.getId()), user.getOrgUserId(), availableRoleFunction.getCode()));
419 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
420 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
421 MDC.remove(SystemProperties.MDC_TIMER);
423 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed");
424 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
425 "Failed to saveRoleFunction for '" + availableRoleFunction.getCode() + "'", "Failed");
427 } catch (Exception e) {
428 if (e.getMessage() == null ||e.getMessage().contains(INVALID_UEB_KEY)) {
429 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
431 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
433 logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction failed", e);
434 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
436 return new PortalRestResponse<>(PortalRestStatusEnum.OK, status, "Success");
439 @ApiOperation(value = "Deletes role function for an application.", response = PortalRestResponse.class, responseContainer = "Json")
440 @RequestMapping(value = { "/roleFunction/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
441 public PortalRestResponse<String> deleteRoleFunction(HttpServletRequest request, HttpServletResponse response,
442 @PathVariable("code") String code) {
443 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
444 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
445 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
446 "Failed to deleteRoleFunction, not valid data.", "Failed");
449 fieldsValidation(request);
450 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
451 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
452 boolean getDelFuncResponse = externalAccessRolesService.deleteCentralRoleFunction(code, app);
453 if (getDelFuncResponse) {
454 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRoleFunction: succeeded for app {}, role {}",
456 AuditLog auditLog = new AuditLog();
457 auditLog.setUserId(user.getId());
458 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION);
459 auditLog.setComments(EcompPortalUtils.truncateString(
460 "Deleted function for app:" + app.getId() + " and function code:'" + code + "'",
461 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
462 auditLog.setAffectedRecordId(user.getOrgUserId());
463 auditService.logActivity(auditLog, null);
464 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
465 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
466 EcompPortalUtils.calculateDateTimeDifferenceForLog(
467 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
468 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
469 logger.info(EELFLoggerDelegate.auditLogger,
470 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRoleFunction",
471 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_FUNCTION, String.valueOf(user.getId()),
472 user.getOrgUserId(), code));
473 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
474 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
475 MDC.remove(SystemProperties.MDC_TIMER);
477 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed");
478 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
479 "Failed to deleteRoleFunction for '" + code + "'", "Failed");
481 } catch (Exception e) {
482 if (e.getMessage().contains(INVALID_UEB_KEY)) {
483 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
485 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
487 logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction failed", e);
488 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
490 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
494 @ApiOperation(value = "Saves role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
495 @RequestMapping(value = { "/role" }, method = RequestMethod.POST, produces = "application/json")
496 public PortalRestResponse<String> saveRole(HttpServletRequest request, HttpServletResponse response,
497 @RequestBody Role role) {
499 fieldsValidation(request);
500 ExternalRequestFieldsValidator saveRoleResult = null;
501 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
502 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
503 if(role.getId()!=null && StringUtils.containsAny(role.getName(), ROLE_INVALID_CHARS)) {
504 throw new InvalidRoleException("Invalid role name found for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed");
506 saveRoleResult = externalAccessRolesService.saveRoleForApplication(role, request.getHeader(UEBKEY));
507 if (saveRoleResult.isResult()) {
508 String activityCode = (role.getId() == null) ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_ROLE
509 : EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_ROLE_AND_FUNCTION;
510 logger.info(EELFLoggerDelegate.applicationLogger, "saveRole: succeeded for app {}, role {}",
511 app.getId(), role.getName());
512 AuditLog auditLog = new AuditLog();
513 auditLog.setUserId(user.getId());
514 auditLog.setActivityCode(activityCode);
515 auditLog.setComments(EcompPortalUtils.truncateString(
516 "saveRole role for app:" + app.getId() + " and role:'" + role.getName() + "'",
517 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
518 auditLog.setAffectedRecordId(user.getOrgUserId());
519 auditService.logActivity(auditLog, null);
520 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
521 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
522 EcompPortalUtils.calculateDateTimeDifferenceForLog(
523 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
524 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
525 logger.info(EELFLoggerDelegate.auditLogger,
526 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.saveRole", activityCode,
527 String.valueOf(user.getId()), user.getOrgUserId(), role.getName()));
528 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
529 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
530 MDC.remove(SystemProperties.MDC_TIMER);
532 if(saveRoleResult.getDetailMessage().contains("406")){
533 response.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
534 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
535 "Failed to create a role for '" + role.getName() + "'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed"
538 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
539 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
540 "Failed to saveRole for '" + role.getName() + "'", "Failed");
543 } catch (Exception e) {
544 if (e.getMessage().contains(INVALID_UEB_KEY)) {
545 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
547 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
549 logger.error(EELFLoggerDelegate.errorLogger, "saveRole failed", e);
550 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
552 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully Saved", "Success");
555 @ApiOperation(value = "Deletes role for an application.", response = PortalRestResponse.class, responseContainer = "Json")
556 @RequestMapping(value = { "/deleteRole/{code}" }, method = RequestMethod.DELETE, produces = "application/json")
557 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
558 @PathVariable String code) {
559 if(!DATA_VALIDATOR.isValid(new SecureString(code))){
560 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
561 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
562 "Failed to deleteRole, not valid data.", "Failed");
565 fieldsValidation(request);
566 boolean deleteResponse = externalAccessRolesService.deleteRoleForApplication(code,
567 request.getHeader(UEBKEY));
568 if (deleteResponse) {
569 EPUser user = externalAccessRolesService.getUser(request.getHeader(LOGIN_ID)).get(0);
570 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
571 logger.info(EELFLoggerDelegate.applicationLogger, "deleteRole: succeeded for app {}, role {}",
573 AuditLog auditLog = new AuditLog();
574 auditLog.setUserId(user.getId());
575 auditLog.setActivityCode(EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE);
576 auditLog.setComments(EcompPortalUtils.truncateString(
577 "Deleted role for app:" + app.getId() + " and role:'" + code + "'",
578 PortalConstants.AUDIT_LOG_COMMENT_SIZE));
579 auditLog.setAffectedRecordId(user.getOrgUserId());
580 auditService.logActivity(auditLog, null);
581 MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
582 MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
583 EcompPortalUtils.calculateDateTimeDifferenceForLog(
584 MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
585 MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
586 logger.info(EELFLoggerDelegate.auditLogger,
587 EPLogUtil.formatAuditLogMessage("ExternalAccessRolesController.deleteRole",
588 EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_DELETE_ROLE, String.valueOf(user.getId()),
589 user.getOrgUserId(), code));
590 MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
591 MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
592 MDC.remove(SystemProperties.MDC_TIMER);
594 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed");
595 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR,
596 "Failed to deleteRole for '" + code + "'", "Failed");
598 } catch (Exception e) {
599 if (e.getMessage().contains(INVALID_UEB_KEY)) {
600 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
602 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
604 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
605 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
607 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
610 @ApiOperation(value = "Gets active roles for an application.", response = CentralRole.class, responseContainer = "Json")
611 @RequestMapping(value = { "/activeRoles" }, method = RequestMethod.GET, produces = "application/json")
612 public List<CentralRole> getActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
613 List<CentralRole> roles = null;
615 fieldsValidation(request);
616 List<CentralV2Role> cenRoles= externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
617 roles = externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles);
618 } catch (Exception e) {
619 sendErrorResponse(response, e);
620 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
626 @ApiOperation(value = "Gets active roles for an application.", response = CentralV2Role.class, responseContainer = "Json")
627 @RequestMapping(value = { "/v1/activeRoles" }, method = RequestMethod.GET, produces = "application/json")
628 public List<CentralV2Role> getV2ActiveRoles(HttpServletRequest request, HttpServletResponse response) throws Exception {
629 List<CentralV2Role> cenRole = null;
631 fieldsValidation(request);
632 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
633 } catch (Exception e) {
634 sendErrorResponse(response, e);
635 logger.error(EELFLoggerDelegate.errorLogger, "getV2ActiveRoles failed", e);
641 @ApiOperation(value = "deletes user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
642 @RequestMapping(value = { "/deleteDependcyRoleRecord/{roleId}" }, method = RequestMethod.DELETE, produces = "application/json")
643 public PortalRestResponse<String> deleteDependencyRoleRecord(HttpServletRequest request, HttpServletResponse response,
644 @PathVariable("roleId") Long roleId) {
645 ExternalRequestFieldsValidator removeResult = null;
647 fieldsValidation(request);
648 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
649 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
650 if (!removeResult.isResult()) {
651 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
652 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteDependencyRoleRecord",
655 } catch (Exception e) {
656 if (e.getMessage().contains(INVALID_UEB_KEY)) {
657 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
659 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
661 logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord failed", e);
662 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
664 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
668 @ApiOperation(value = "deletes roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
669 @RequestMapping(value = { "/v2/deleteRole/{roleId}" }, method = RequestMethod.DELETE, produces = "application/json")
670 public PortalRestResponse<String> deleteRole(HttpServletRequest request, HttpServletResponse response,
671 @PathVariable("roleId") Long roleId) {
672 ExternalRequestFieldsValidator removeResult = null;
674 fieldsValidation(request);
675 removeResult = externalAccessRolesService.deleteDependencyRoleRecord(roleId,
676 request.getHeader(UEBKEY), request.getHeader(LOGIN_ID));
677 if (!removeResult.isResult()) {
678 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
679 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to deleteRole",
682 } catch (Exception e) {
683 if (e.getMessage().contains(INVALID_UEB_KEY)) {
684 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
686 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
688 logger.error(EELFLoggerDelegate.errorLogger, "deleteRole failed", e);
689 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.getMessage(), "Failed");
691 return new PortalRestResponse<>(PortalRestStatusEnum.OK, SUCCESSFULLY_DELETED, "Success");
695 @ApiOperation(value = "Bulk upload functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
696 @RequestMapping(value = { "/upload/portal/functions" }, method = RequestMethod.POST, produces = "application/json")
697 public PortalRestResponse<String> bulkUploadFunctions(HttpServletRequest request, HttpServletResponse response) {
700 result = externalAccessRolesService.bulkUploadFunctions(request.getHeader(UEBKEY));
701 } catch (Exception e) {
702 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
703 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
704 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
706 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
709 @ApiOperation(value = "Bulk upload roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
710 @RequestMapping(value = { "/upload/portal/roles" }, method = RequestMethod.POST, produces = "application/json")
711 public PortalRestResponse<String> bulkUploadRoles(HttpServletRequest request, HttpServletResponse response) {
714 result = externalAccessRolesService.bulkUploadRoles(request.getHeader(UEBKEY));
715 } catch (Exception e) {
716 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
717 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
718 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
720 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
723 @ApiOperation(value = "Bulk upload role functions for an application.", response = PortalRestResponse.class, responseContainer = "Json")
724 @RequestMapping(value = { "/upload/portal/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
725 public PortalRestResponse<String> bulkUploadRoleFunctions(HttpServletRequest request, HttpServletResponse response) {
728 result = externalAccessRolesService.bulkUploadRolesFunctions(request.getHeader(UEBKEY));
729 } catch (Exception e) {
730 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
731 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoleFunctions failed", e);
732 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoleFunctions", "Failed");
734 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
737 @ApiOperation(value = "Bulk upload user roles for an application.", response = PortalRestResponse.class, responseContainer = "Json")
738 @RequestMapping(value = { "/upload/portal/userRoles" }, method = RequestMethod.POST, produces = "application/json")
739 public PortalRestResponse<String> bulkUploadUserRoles(HttpServletRequest request, HttpServletResponse response) {
742 result = externalAccessRolesService.bulkUploadUserRoles(request.getHeader(UEBKEY));
743 } catch (Exception e) {
744 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
745 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUserRoles failed", e);
746 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUserRoles", "Failed");
748 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
751 @ApiOperation(value = "Bulk upload users for renamed role of an application.", response = PortalRestResponse.class, responseContainer = "Json")
752 @RequestMapping(value = { "/upload/portal/userRole/{roleId}" }, method = RequestMethod.POST, produces = "application/json")
753 public PortalRestResponse<String> bulkUploadUsersSingleRole(HttpServletRequest request, HttpServletResponse response, @PathVariable Long roleId) {
756 String roleName = request.getHeader("RoleName");
757 result = externalAccessRolesService.bulkUploadUsersSingleRole(request.getHeader(UEBKEY), roleId, roleName);
758 } catch (Exception e) {
759 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
760 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadUsersSingleRole failed", e);
761 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadUsersSingleRole", "Failed");
763 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added: " + result, "Success");
766 @ApiOperation(value = "Bulk upload functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
767 @RequestMapping(value = { "/upload/partner/functions" }, method = RequestMethod.POST, produces = "application/json")
768 public PortalRestResponse<String> bulkUploadPartnerFunctions(HttpServletRequest request, HttpServletResponse response) {
769 Integer addedFunctions = 0;
771 addedFunctions = externalAccessRolesService.bulkUploadPartnerFunctions(request.getHeader(UEBKEY));
772 } catch (Exception e) {
773 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
774 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions failed", e);
775 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadFunctions", "Failed");
777 return new PortalRestResponse<>(PortalRestStatusEnum.OK,
778 "Successfully added: '" + addedFunctions + "' functions", "Success");
781 @ApiOperation(value = "Bulk upload roles for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
782 @RequestMapping(value = { "/upload/partner/roles" }, method = RequestMethod.POST, produces = "application/json")
783 public PortalRestResponse<String> bulkUploadPartnerRoles(HttpServletRequest request, HttpServletResponse response, @RequestBody List<Role> upload) {
785 externalAccessRolesService.bulkUploadPartnerRoles(request.getHeader(UEBKEY), upload);
786 } catch (Exception e) {
787 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
788 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles failed", e);
789 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadRoles", "Failed");
791 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Successfully added", "Success");
794 @ApiOperation(value = "Bulk upload role functions for an partner application.", response = PortalRestResponse.class, responseContainer = "Json")
795 @RequestMapping(value = { "/upload/partner/roleFunctions" }, method = RequestMethod.POST, produces = "application/json")
796 public PortalRestResponse<String> bulkUploadPartnerRoleFunctions(HttpServletRequest request, HttpServletResponse response) {
797 Integer addedRoleFunctions = 0;
799 addedRoleFunctions = externalAccessRolesService.bulkUploadPartnerRoleFunctions(request.getHeader(UEBKEY));
800 } catch (Exception e) {
801 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
802 logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadPartnerRoleFunctions failed", e);
803 return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Failed to bulkUploadPartnerRoleFunctions",
806 return new PortalRestResponse<>(PortalRestStatusEnum.OK,
807 "Successfully added: '" + addedRoleFunctions + "' role functions", "Success");
810 @ApiOperation(value = "Gets all functions along with global functions", response = List.class, responseContainer = "Json")
811 @RequestMapping(value = { "/menuFunctions" }, method = RequestMethod.GET, produces = "application/json")
812 public List<String> getMenuFunctions(HttpServletRequest request, HttpServletResponse response) throws Exception {
813 List<String> functionsList = null;
815 fieldsValidation(request);
816 functionsList = externalAccessRolesService.getMenuFunctionsList(request.getHeader(UEBKEY));
817 } catch (Exception e) {
818 sendErrorResponse(response, e);
819 logger.error(EELFLoggerDelegate.errorLogger, "getMenuFunctions failed", e);
821 return functionsList;
824 @ApiOperation(value = "Gets all active Users of application", response = String.class, responseContainer = "Json")
825 @RequestMapping(value = { "/users" }, method = RequestMethod.GET, produces = "application/json")
826 public List<EcompUser> getUsersOfApplication(HttpServletRequest request, HttpServletResponse response) throws Exception {
827 List<EcompUser> users = null;
829 fieldsValidation(request);
830 users = externalAccessRolesService.getAllAppUsers(request.getHeader(UEBKEY));
831 } catch (Exception e) {
832 sendErrorResponse(response, e);
833 logger.error(EELFLoggerDelegate.errorLogger, "getUsersOfApplication failed", e);
840 * It checks the input uebkey of the application and throws exception if it is invalid key
845 private void fieldsValidation(HttpServletRequest request) throws Exception{
846 List<EPApp> app = externalAccessRolesService.getApp(request.getHeader(UEBKEY));
848 throw new Exception(INVALID_UEB_KEY);
850 if(!app.isEmpty() && app.get(0).getCentralAuth()){
851 ResponseEntity<String> response = externalAccessRolesService.getNameSpaceIfExists(app.get(0));
852 if (response.getStatusCode().value() == HttpServletResponse.SC_NOT_FOUND)
853 throw new Exception("Invalid NameSpace");
859 * It returns http response with appropriate message
863 * @throws IOException
865 private void sendErrorResponse(HttpServletResponse response, Exception e) throws IOException {
866 response.setContentType("application/json");
867 response.setCharacterEncoding("UTF-8");
868 final Map<String,String> uebkeyResponse = new HashMap<>();
869 ObjectMapper mapper = new ObjectMapper();
871 if (e.getMessage().contains(INVALID_UEB_KEY)) {
872 uebkeyResponse.put("error",INVALID_UEB_KEY);
873 reason = mapper.writeValueAsString(uebkeyResponse);
874 response.getWriter().write(reason);
875 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
877 uebkeyResponse.put("error",e.getMessage());
878 reason = mapper.writeValueAsString(uebkeyResponse);
879 response.getWriter().write(reason);
880 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
884 @ApiOperation(value = "Gets ecompUser of an application.", response = CentralUser.class, responseContainer = "List")
885 @RequestMapping(value = { "/v2/user/{loginId}" }, method = RequestMethod.GET, produces = "application/json")
886 public String getEcompUser(HttpServletRequest request, HttpServletResponse response,
887 @PathVariable("loginId") String loginId) throws Exception {
888 if(!DATA_VALIDATOR.isValid(new SecureString(loginId))){
889 sendErrorResponse(response, new Exception("getEcompUser failed"));
890 logger.error(EELFLoggerDelegate.errorLogger, "getEcompUser failed", new Exception("getEcompUser failed"));
892 EcompUser user = new EcompUser();
893 ObjectMapper mapper = new ObjectMapper();
894 String answer = null;
896 fieldsValidation(request);
898 answer = externalAccessRolesService.getV2UserWithRoles(loginId, request.getHeader(UEBKEY));
899 if (answer != null) {
900 User ecompUser = userservice.userMapper(answer);
901 user = UserUtils.convertToEcompUser(ecompUser);
902 List<EcompRole> missingRolesOfUser = externalAccessRolesService.missingUserApplicationRoles(request.getHeader(UEBKEY), loginId, user.getRoles());
903 if (missingRolesOfUser.size() > 0) {
904 Set<EcompRole> roles = new TreeSet<>(missingRolesOfUser);
905 user.getRoles().addAll(roles);
908 } catch (Exception e) {
909 sendErrorResponse(response, e);
910 logger.error(EELFLoggerDelegate.errorLogger, "getEcompUser failed", e);
912 return mapper.writeValueAsString(user);
915 @ApiOperation(value = "Gets user ecomp role for an application.", response = CentralUser.class, responseContainer = "List")
916 @RequestMapping(value = { "/v2/roles" }, method = RequestMethod.GET, produces = "application/json")
917 public List<EcompRole> getEcompRolesOfApplication(HttpServletRequest request, HttpServletResponse response)
919 List<EcompRole> ecompRoles = null;
920 ObjectMapper mapper = new ObjectMapper();
921 List<CentralV2Role> cenRole = null;
923 fieldsValidation(request);
924 EPApp app = externalAccessRolesService.getApp(request.getHeader(UEBKEY)).get(0);
925 // Sync all roles from external system into ONAP portal DB
926 logger.debug(EELFLoggerDelegate.debugLogger,
927 "getRolesForApp: Entering into syncApplicationRolesWithEcompDB");
928 externalAccessRolesService.syncApplicationRolesWithEcompDB(app);
929 logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished syncApplicationRolesWithEcompDB");
930 cenRole = externalAccessRolesService.getActiveRoles(request.getHeader(UEBKEY));
931 } catch (Exception e) {
932 sendErrorResponse(response, e);
933 logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles failed", e);
935 if (cenRole != null) {
936 String res = mapper.writeValueAsString(cenRole);
937 ecompRoles = new ArrayList<>();
938 List<Role> roles = mapper.readValue(res,
939 TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
940 for (Role role : roles)
941 ecompRoles.add(UserUtils.convertToEcompRole(role));
942 logger.debug(EELFLoggerDelegate.debugLogger, "Request completed for getEcompRolesOfApplication");