Supwisdom Source - institute/sw-backend.git/blob

   1 package com.supwisdom.institute.backend.base.domain.service;
   2
   3 import java.util.ArrayList;
   4 import java.util.HashMap;
   5 import java.util.LinkedHashMap;
   6 import java.util.List;
   7 import java.util.Map;
   8
   9 import lombok.extern.slf4j.Slf4j;
  10
  11 import org.apache.commons.lang3.StringUtils;
  12 import org.springframework.beans.factory.annotation.Autowired;
  13 import org.springframework.data.domain.Example;
  14 import org.springframework.data.domain.ExampleMatcher;
  15 import org.springframework.data.domain.Page;
  16 import org.springframework.data.domain.PageRequest;
  17 import org.springframework.stereotype.Service;
  18
  19 import com.supwisdom.institute.backend.base.domain.entity.Permission;
  20 import com.supwisdom.institute.backend.base.domain.entity.PermissionResource;
  21 import com.supwisdom.institute.backend.base.domain.entity.Role;
  22 import com.supwisdom.institute.backend.base.domain.model.PermissionRoleSet;
  23 import com.supwisdom.institute.backend.base.domain.model.PermissionTreeNode;
  24 import com.supwisdom.institute.backend.base.domain.repo.PermissionRepository;
  25 import com.supwisdom.institute.backend.base.domain.repo.PermissionResourceRepository;
  26 import com.supwisdom.institute.backend.base.domain.repo.RoleRepository;
  27 import com.supwisdom.institute.backend.common.framework.entity.EntityUtils;
  28 import com.supwisdom.institute.backend.common.framework.service.ABaseService;
  29 import com.supwisdom.institute.backend.common.util.MapBeanUtils;
  30
  31 @Slf4j
  32 @Service
  33 public class PermissionService extends ABaseService<Permission, PermissionRepository> {
  34
  35   @Override
  36   public PermissionRepository getRepo() {
  37     return permissionRepository;
  38   }
  39
  40   @Autowired
  41   private PermissionRepository permissionRepository;
  42
  43   @Autowired
  44   private PermissionResourceRepository permissionResourceRepository;
  45
  46   @Autowired
  47   private RoleRepository roleRepository;
  48
  49   @Override
  50   public Permission insert(Permission entity) {
  51     Permission parentPermission = permissionRepository.selectById(entity.getParentId());
  52     if (parentPermission != null) {
  53       entity.setApplicationId(parentPermission.getApplicationId());
  54     }
  55
  56     return super.insert(entity);
  57   }
  58
  59   public void deleteBatch(List<String> ids) {
  60
  61     ids.stream().forEach(id -> {
  62       this.deleteById(id);
  63     });
  64   }
  65
  66
  67
  68   public Page<PermissionResource> selectPermissionResources(boolean loadAll, int pageIndex, int pageSize, Map<String, Object> mapBean) {
  69
  70     if (loadAll) {
  71       pageIndex = 0;
  72       pageSize = Integer.MAX_VALUE;
  73     }
  74
  75     PermissionResource probe = new PermissionResource();
  76     if (mapBean != null) {
  77       probe.setPermissionId(MapBeanUtils.getString(mapBean, "permissionId"));
  78       probe.setResourceId(MapBeanUtils.getString(mapBean, "resourceId"));
  79     }
  80
  81     ExampleMatcher matcher = ExampleMatcher.matching()
  82         .withMatcher("permissionId", ExampleMatcher.GenericPropertyMatchers.exact())
  83         .withMatcher("resourceId", ExampleMatcher.GenericPropertyMatchers.exact());
  84
  85     Example<PermissionResource> example = Example.of(probe, matcher);
  86
  87     PageRequest pageRequest = PageRequest.of(pageIndex, pageSize);
  88
  89     Page<PermissionResource> page = permissionResourceRepository.findAll(example, pageRequest); // FIXME: 多表关联查询
  90
  91     return page;
  92   }
  93
  94   public void relatePermissionResources(Permission permission, List<PermissionResource> permissionResources) {
  95
  96     List<PermissionResource> existPermissionResources = this.selectPermissionResourcesByPermissionId(permission.getId());
  97
  98     Map<String, PermissionResource> existMapPermissionResources = new LinkedHashMap<String, PermissionResource>();
  99     for (PermissionResource permissionResource : existPermissionResources) {
 100       String k = String.format("%s", permissionResource.getPermissionId());
 101       existMapPermissionResources.put(k, permissionResource);
 102     }
 103
 104     for (PermissionResource permissionResource : permissionResources) {
 105       String k = String.format("%s", permissionResource.getPermissionId());
 106
 107       if (existMapPermissionResources.containsKey(k)) {
 108         existMapPermissionResources.remove(k);
 109       } else {
 110         permissionResource.setCompanyId(permission.getCompanyId());
 111         permissionResource.setPermissionId(permission.getId());
 112
 113         permissionResourceRepository.insert(permissionResource);
 114       }
 115     }
 116
 117     for (PermissionResource permissionResource : existMapPermissionResources.values()) {
 118       permissionResourceRepository.deleteById(permissionResource.getId());
 119     }
 120   }
 121
 122   public List<PermissionResource> selectPermissionResourcesByPermissionId(String permissionId) {
 123
 124     PermissionResource probe = new PermissionResource();
 125     probe.setPermissionId(permissionId);
 126
 127     ExampleMatcher matcher = ExampleMatcher.matching().withMatcher("permissionId",
 128         ExampleMatcher.GenericPropertyMatchers.exact());
 129
 130     Example<PermissionResource> example = Example.of(probe, matcher);
 131
 132     List<PermissionResource> permissionResources = permissionResourceRepository.findAll(example);
 133
 134     return permissionResources;
 135   }
 136
 137
 138   private Permission selectApplicationPermission() {
 139     Permission permission = permissionRepository.selectById(Permission.APPLICATION_ID);
 140
 141     return permission;
 142   }
 143
 144   private List<Permission> selectApplicationPermissionList() {
 145     Map<String, Object> mapBean = new HashMap<String, Object>();
 146     mapBean.put("type", Permission.TYPE_APPLICATION);
 147
 148     return permissionRepository.selectList(true, -1, -1, mapBean, null);
 149   }
 150
 151   public PermissionTreeNode selectPermissionTree(String applicationId, String type) {
 152
 153     Map<String, Object> mapBean = new HashMap<String, Object>();
 154     if (StringUtils.isNotBlank(type)) {
 155       mapBean.put("type", type);
 156     }
 157
 158     String rootTreeNodeId = "0";
 159
 160     List<Permission> permissions = new ArrayList<Permission>();
 161
 162     if (StringUtils.isBlank(applicationId)) {
 163       Permission rootPermission = new Permission();
 164       rootPermission.setId(Permission.ROOT_PARENT_ID);
 165       rootPermission.setCode("root");
 166       rootPermission.setName("根");
 167
 168       permissions.add(rootPermission);
 169       rootTreeNodeId = rootPermission.getId();
 170
 171       List<Permission> applicationPermissions = this.selectApplicationPermissionList();
 172       permissions.addAll(applicationPermissions);
 173     } else {
 174       Permission applicationPermission = permissionRepository.selectById(applicationId); // this.selectApplicationPermissionByCode(applicationCode);
 175       if (applicationPermission == null) {
 176         return null;
 177       }
 178
 179       permissions.add(applicationPermission);
 180       rootTreeNodeId = applicationPermission.getId();
 181     }
 182
 183     List<Permission> menuPermissions = permissionRepository.selectList(true, -1, -1, mapBean, null);
 184     permissions.addAll(menuPermissions);
 185
 186     return convertPermissionTree(permissions, rootTreeNodeId);
 187   }
 188
 189   private PermissionTreeNode convertPermissionTree(List<Permission> permissions, String rootTreeNodeId) {
 190     if (permissions == null || permissions.size() == 0) {
 191       return null;
 192     }
 193
 194     Map<String, PermissionTreeNode> parentTreeNode = new LinkedHashMap<String, PermissionTreeNode>();
 195
 196     for (Permission permission : permissions) {
 197       PermissionTreeNode treeNode = EntityUtils.copy(permission, new PermissionTreeNode());
 198       treeNode.setChildren(new ArrayList<PermissionTreeNode>());
 199
 200       if (parentTreeNode.containsKey(treeNode.getId())) {
 201         continue;
 202       }
 203       parentTreeNode.put(treeNode.getId(), treeNode);
 204     }
 205
 206     for (PermissionTreeNode treeNode : parentTreeNode.values()) {
 207       if (!parentTreeNode.containsKey(treeNode.getParentId())) {
 208         continue;
 209       }
 210
 211       parentTreeNode.get(treeNode.getParentId()).getChildren().add(treeNode);
 212     }
 213
 214     return parentTreeNode.get(rootTreeNodeId);
 215   }
 216
 217
 218
 219 //  public Permission selectApplicationPermissionByCode(String code) {
 220 //    Permission probe = new Permission();
 221 //    probe.setCode(code);
 222 //    probe.setType("1");
 223 //
 224 //    ExampleMatcher matcher = ExampleMatcher.matching()
 225 //        .withMatcher("code", ExampleMatcher.GenericPropertyMatchers.exact())
 226 //        .withMatcher("type", ExampleMatcher.GenericPropertyMatchers.exact());
 227 //
 228 //    Example<Permission> example = Example.of(probe, matcher);
 229 //
 230 //    Optional<Permission> o = permissionRepository.findOne(example);
 231 //
 232 //    if (o.isPresent()) {
 233 //      return o.get();
 234 //    }
 235 //
 236 //    return null;
 237 //  }
 238
 239
 240   public List<Permission> selectByUsername(String username, String applicationId, String type) {
 241     List<Permission> permissions = new ArrayList<Permission>();
 242
 243 //    Permission applicationPermission = permissionRepository.selectById(applicationId);
 244 //    if (applicationPermission == null) {
 245 //      return permissions;
 246 //    }
 247 //
 248 //    int lft = applicationPermission.getLft();
 249 //    int rgt = applicationPermission.getRgt();
 250
 251     if (StringUtils.isBlank(applicationId)) {
 252       List<Permission> accountRolePermissions = permissionRepository.selectAccountRolePermissionByUsername(username, type);
 253       permissions.addAll(accountRolePermissions);
 254
 255       List<Permission> accountGroupRolePermissions = permissionRepository.selectAccountGroupRolePermissionByUsername(username, type);
 256       permissions.addAll(accountGroupRolePermissions);
 257     } else {
 258       List<Permission> accountRolePermissions = permissionRepository.selectAccountRolePermissionByUsername(username, applicationId, type);
 259       permissions.addAll(accountRolePermissions);
 260
 261       List<Permission> accountGroupRolePermissions = permissionRepository.selectAccountGroupRolePermissionByUsername(username, applicationId, type);
 262       permissions.addAll(accountGroupRolePermissions);
 263     }
 264
 265     return EntityUtils.distinctList(permissions);
 266   }
 267
 268   @Deprecated
 269   public PermissionTreeNode selectPermissionTreeByUsername(String username, String applicationId, String type) {
 270     String rootTreeNodeId = "0";
 271
 272     List<Permission> permissions = new ArrayList<Permission>();
 273
 274     if (StringUtils.isBlank(applicationId)) {
 275       Permission rootPermission = new Permission();
 276       rootPermission.setId(Permission.ROOT_PARENT_ID);
 277       rootPermission.setCode("root");
 278       rootPermission.setName("根");
 279
 280       permissions.add(rootPermission);
 281       rootTreeNodeId = rootPermission.getId();
 282
 283       List<Permission> applicationPermissions = this.selectApplicationPermissionList();
 284       permissions.addAll(applicationPermissions);
 285     } else {
 286       Permission applicationPermission = permissionRepository.selectById(applicationId); // this.selectApplicationPermissionByCode(applicationCode);
 287       if (applicationPermission == null) {
 288         return null;
 289       }
 290
 291       permissions.add(applicationPermission);
 292       rootTreeNodeId = applicationPermission.getId();
 293     }
 294
 295     List<Permission> menuPermissions = this.selectByUsername(username, applicationId, type);
 296     permissions.addAll(menuPermissions);
 297
 298     return convertPermissionTree(permissions, rootTreeNodeId);
 299   }
 300
 301   public List<PermissionRoleSet> selectPermissionRoleSet(Map<String, Object> mapBean) {
 302
 303     List<PermissionRoleSet> prsList = new ArrayList<>();
 304
 305     List<Permission> resourceList = permissionRepository.selectList(mapBean, null);
 306
 307     for (Permission permission : resourceList) {
 308
 309       List<Role> roleList = roleRepository.selectPermissionRolesByPermission(permission.getId());
 310
 311       PermissionRoleSet prs = new PermissionRoleSet(permission, roleList);
 312
 313       prsList.add(prs);
 314     }
 315
 316     return prsList;
 317   }
 318
 319 }