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("/functions", 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 = new Role();
  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("/role", 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                 String roleName = domainRole.getName().replaceAll(" ", "%20");
 112                 try {
 113                         restApiRequestBuilder.deleteViaRest("/deleteRole/"+ roleName, true, null, loginId);
 114                 } catch (Exception e) {
 115                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRole Failed", e);
 116                         throw new Exception(e.getMessage());
 117                 }
 118         }
 119         @Override
 120         public List<Role> getAvailableRoles(String requestedLoginId) throws Exception {
 121                 ObjectMapper mapper = new ObjectMapper();
 122                 String roleList = restApiRequestBuilder.getViaREST("/roles", true, requestedLoginId);
 123                 List<Role> roles = null;
 124                 roles = mapper.readValue(roleList,
 125                                 TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
 126                 return roles;
 127         }
 128
 129         @Override
 130         public List<Role> getActiveRoles(String requestedLoginId) throws Exception {
 131                 ObjectMapper mapper = new ObjectMapper();
 132                 String roleString = restApiRequestBuilder.getViaREST("/activeRoles", true, requestedLoginId);
 133                 List<Role> roles = null;
 134                 roles = mapper.readValue(roleString,
 135                                 TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
 136                 return roles;
 137
 138         }
 139
 140         @Override
 141         public RoleFunction getRoleFunction(String requestedLoginId, String code) throws Exception {
 142                 ObjectMapper mapper = new ObjectMapper();
 143                 String responseString = restApiRequestBuilder.getViaREST("/function/" + code, true, requestedLoginId);
 144                 RoleFunction roleFunction = new RoleFunction();
 145                 if (!responseString.isEmpty()) {
 146                         roleFunction = mapper.readValue(responseString, RoleFunction.class);
 147                 }
 148                 return roleFunction;
 149         }
 150
 151         @Override
 152         public void saveRoleFunction(String requestedLoginId, RoleFunction domainRoleFunction) throws Exception {
 153                 ObjectMapper mapper = new ObjectMapper();
 154                 String roleFunction = mapper.writeValueAsString(domainRoleFunction);
 155                 try{
 156                 restApiRequestBuilder.postViaREST("/roleFunction", true, roleFunction, requestedLoginId);
 157                 }catch(Exception e){
 158                         logger.error(EELFLoggerDelegate.errorLogger, "saveRoleFunction Failed", e);
 159                         throw new Exception(e.getMessage());
 160                 }
 161         }
 162
 163         @Override
 164         public void deleteRoleFunction(String requestedLoginId, RoleFunction domainRoleFunction) throws Exception {
 165                 String code = domainRoleFunction.getCode();
 166                 try {
 167                         restApiRequestBuilder.deleteViaRest("/roleFunction/"+ code, true, null, requestedLoginId);
 168                 } catch (Exception e) {
 169                         logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleFunction Failed ", e);
 170                         throw new Exception(e.getMessage());
 171                 }
 172         }
 173
 174         @Override
 175         public void deleteDependcyRoleRecord(String requestedLoginId, Long id) {
 176                 try {
 177                         restApiRequestBuilder.deleteViaRest("/deleteDependcyRoleRecord/" + id, true, null, requestedLoginId);
 178                 } catch (Exception e) {
 179                         logger.error(EELFLoggerDelegate.errorLogger, "deleteDependcyRoleRecord Failed", e);
 180                 }
 181         }
 182
 183 }