gerrit.onap Code Review - portal/sdk.git/blob

   1 package org.openecomp.portalsdk.core.service;
   2
   3 import java.util.HashSet;
   4 import java.util.Iterator;
   5 import java.util.List;
   6 import java.util.Set;
   7 import java.util.TreeSet;
   8
   9 import org.openecomp.portalsdk.core.domain.Role;
  10 import org.openecomp.portalsdk.core.domain.RoleFunction;
  11 import org.openecomp.portalsdk.core.logging.logic.EELFLoggerDelegate;
  12 import org.springframework.beans.factory.annotation.Autowired;
  13 import org.springframework.transaction.annotation.Transactional;
  14
  15 import com.fasterxml.jackson.databind.ObjectMapper;
  16 import com.fasterxml.jackson.databind.type.TypeFactory;
  17
  18 @Transactional
  19 public class RoleServiceCentralizedAccess implements RoleService {
  20
  21         private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(RoleServiceCentralizedAccess.class);
  22
  23         @Autowired
  24         AppService appService;
  25
  26         @Autowired
  27         RestApiRequestBuilder restApiRequestBuilder;
  28
  29         @Override
  30         public List<RoleFunction> getRoleFunctions(String loginId) throws Exception {
  31
  32                 List<RoleFunction> roleFunctionList = null;
  33                 String role_function_list = "";
  34                 role_function_list = restApiRequestBuilder.getViaREST("/getAllRoleFunctions", true, loginId);
  35                 ObjectMapper mapper = new ObjectMapper();
  36                 roleFunctionList = mapper.readValue(role_function_list,
  37                                 TypeFactory.defaultInstance().constructCollectionType(List.class, RoleFunction.class));
  38                 return roleFunctionList;
  39         }
  40
  41         @Override
  42         public List<Role> getAvailableChildRoles(String loginId, Long roleId) throws Exception {
  43                 List<Role> availableChildRoles = getAvailableRoles(loginId);
  44                 if (roleId == null || roleId == 0) {
  45                         return availableChildRoles;
  46                 }
  47
  48                 Role currentRole = getRole(loginId, roleId);
  49                 Set<Role> allParentRoles = new TreeSet<Role>();
  50                 allParentRoles = getAllParentRolesAsList(loginId, currentRole, allParentRoles);
  51
  52                 Iterator<Role> availableChildRolesIterator = availableChildRoles.iterator();
  53                 while (availableChildRolesIterator.hasNext()) {
  54                         Role role = availableChildRolesIterator.next();
  55                         if (!role.getActive() || allParentRoles.contains(role) || role.getId().equals(roleId)) {
  56                                 availableChildRolesIterator.remove();
  57                         }
  58                 }
  59                 return availableChildRoles;
  60         }
  61
  62         @SuppressWarnings("unchecked")
  63         private Set<Role> getAllParentRolesAsList(String loginId, Role role, Set<Role> allParentRoles) {
  64                 Set<Role> parentRoles = role.getParentRoles();
  65                 allParentRoles.addAll(parentRoles);
  66                 Iterator<Role> parentRolesIterator = parentRoles.iterator();
  67                 while (parentRolesIterator.hasNext()) {
  68                         getAllParentRolesAsList(loginId, parentRolesIterator.next(), allParentRoles);
  69                 }
  70                 return allParentRoles;
  71         }
  72
  73         @Override
  74         public Role getRole(String loginId, Long id) throws Exception {
  75                 ObjectMapper mapper = new ObjectMapper();
  76                 String roleString = restApiRequestBuilder.getViaREST("/role/" + id, true, loginId);
  77                 Role role = null;
  78                 role = mapper.readValue(roleString, Role.class);
  79                 if (role.getRoleFunctions() != null) {
  80                         @SuppressWarnings("unchecked")
  81                         Set<RoleFunction> roleFunctionList = role.getRoleFunctions();
  82                         Set<RoleFunction> roleFunctionListNew = new HashSet<>();
  83                         Iterator<RoleFunction> itetaror = roleFunctionList.iterator();
  84                         while (itetaror.hasNext()) {
  85                                 Object nextValue = itetaror.next();
  86                                 RoleFunction roleFun = mapper.convertValue(nextValue, RoleFunction.class);
  87                                 roleFunctionListNew.add(roleFun);
  88                         }
  89
  90                         role.setRoleFunctions(roleFunctionListNew);
  91                 }
  92                 logger.info(EELFLoggerDelegate.applicationLogger, "role_id" + role.getId());
  93                 return role;
  94
  95         }
  96
  97         @Override
  98         public void saveRole(String loginId, Role domainRole) throws Exception {
  99                 ObjectMapper mapper = new ObjectMapper();
 100                 String role = mapper.writeValueAsString(domainRole);
 101                 try {
 102                         restApiRequestBuilder.postViaREST("/saveRole", true, role, loginId);
 103                 } catch (Exception e) {
 104                         logger.error(EELFLoggerDelegate.errorLogger, "saveRole Failed", e);
 105                         throw new Exception(e.getMessage());
 106                 }
 107         }
 108
 109         @Override
 110         public void deleteRole(String loginId, Role domainRole) throws Exception {
 111                 ObjectMapper mapper = new ObjectMapper();
 112                 String role = mapper.writeValueAsString(domainRole);
 113                 String filter = " where active_yn = 'Y' ";
 114                 try {
 115                         restApiRequestBuilder.deleteViaRest("/deleteRole", true, role, filter, loginId);
 116                 } catch (Exception e) {
 117                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRole Failed", e);
 118                         throw new Exception(e.getMessage());
 119                 }
 120         }
 121
 122         @Override
 123         public List<Role> getAvailableRoles(String requestedLoginId) throws Exception {
 124                 ObjectMapper mapper = new ObjectMapper();
 125                 String roleList = restApiRequestBuilder.getViaREST("/getRoles", true, requestedLoginId);
 126                 List<Role> roles = null;
 127                 roles = mapper.readValue(roleList,
 128                                 TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
 129                 return roles;
 130         }
 131
 132         @Override
 133         public List<Role> getActiveRoles(String requestedLoginId) throws Exception {
 134                 ObjectMapper mapper = new ObjectMapper();
 135                 String roleString = restApiRequestBuilder.getViaREST("/activeRoles", true, requestedLoginId);
 136                 List<Role> roles = null;
 137                 roles = mapper.readValue(roleString,
 138                                 TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
 139                 return roles;
 140
 141         }
 142
 143         @Override
 144         public RoleFunction getRoleFunction(String requestedLoginId, String code) throws Exception {
 145                 ObjectMapper mapper = new ObjectMapper();
 146                 String responseString = restApiRequestBuilder.getViaREST("/getRoleFunction/" + code, true, requestedLoginId);
 147                 RoleFunction roleFunction = new RoleFunction();
 148                 if (!responseString.isEmpty()) {
 149                         roleFunction = mapper.readValue(responseString, RoleFunction.class);
 150                 }
 151                 return roleFunction;
 152         }
 153
 154         @Override
 155         public void saveRoleFunction(String requestedLoginId, RoleFunction domainRoleFunction) throws Exception {
 156                 ObjectMapper mapper = new ObjectMapper();
 157                 String roleFunction = mapper.writeValueAsString(domainRoleFunction);
 158                 try{
 159                 restApiRequestBuilder.postViaREST("/saveRoleFunction", true, roleFunction, requestedLoginId);
 160                 }catch(Exception e){
 161                         logger.error(EELFLoggerDelegate.errorLogger, "deleteDependcyRoleRecord Failed", e);
 162                         throw new Exception(e.getMessage());
 163                 }
 164         }
 165
 166         @Override
 167         public void deleteRoleFunction(String requestedLoginId, RoleFunction domainRoleFunction) throws Exception {
 168                 ObjectMapper mapper = new ObjectMapper();
 169                 String roleFunction = mapper.writeValueAsString(domainRoleFunction);
 170                 try {
 171                         restApiRequestBuilder.deleteViaRest("/deleteRoleFunction", true, roleFunction, null, requestedLoginId);
 172                 } catch (Exception e) {
 173                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction Failed", e);
 174                         throw new Exception(e.getMessage());
 175                 }
 176         }
 177
 178         @Override
 179         public void deleteDependcyRoleRecord(String requestedLoginId, Long id) {
 180                 try {
 181                         restApiRequestBuilder.deleteViaRest("/deleteDependcyRoleRecord/" + id, true, null, null, requestedLoginId);
 182                 } catch (Exception e) {
 183                         logger.error(EELFLoggerDelegate.errorLogger, "deleteDependcyRoleRecord Failed", e);
 184                 }
 185         }
 186
 187 }