2/27 因租户会员类型的新需求加入，原租户和功能关联的需求及涉及到的所有关联代码大改

PCS/src/main/java/cn/cslg/permission/common/model/vo/TenantVO.java

@@ -64,23 +64,23 @@ public class TenantVO extends BaseVO {
      */
     private String password;
 
-    /**
-     * Front:功能权限路径
-     * Back:
-     */
-    private List<String> functions;
-
-    /**
-     * Front:功能权限IDList
-     * Back:
-     */
-    private List<List<Integer>> function;
-
-    /**
-     * Front:功能权限内容List
-     * Back:
-     */
-    private List<FunctionVO> functionList;
+//    /**
+//     * Front:功能权限路径
+//     * Back:
+//     */
+//    private List<String> functions;
+//
+//    /**
+//     * Front:功能权限IDList
+//     * Back:
+//     */
+//    private List<List<Integer>> function;
+//
+//    /**
+//     * Front:功能权限内容List
+//     * Back:
+//     */
+//    private List<FunctionVO> functionList;
 
     /**
      * Front:状态

PCS/src/main/java/cn/cslg/permission/controller/ApplicationController.java

@@ -22,7 +22,7 @@ import org.springframework.web.bind.annotation.*;
 @RequestMapping(Constants.PERMISSION_API + "/application")
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class ApplicationController {
-    private final  ApplicationService applicationService;
+    private final ApplicationService applicationService;
 
     @checkAuth(FunId = "/admin/apply/add")
     @PostMapping("/add")

PCS/src/main/java/cn/cslg/permission/controller/FunctionController.java

@@ -4,6 +4,7 @@ import cn.cslg.permission.common.core.base.Constants;
 import cn.cslg.permission.common.model.vo.FunctionVO;
 import cn.cslg.permission.common.utils.Response;
 import cn.cslg.permission.common.utils.auth.checkAuth;
+import cn.cslg.permission.exception.XiaoShiException;
 import cn.cslg.permission.service.FunctionService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -35,7 +36,12 @@ public class FunctionController {
     @PostMapping("/delete")
     @Operation(summary = "删除功能")
     public String deleteFunction(FunctionVO functionVO) {
-        return functionService.deleteFunction(functionVO);
+        try {
+            functionService.deleteFunction(functionVO);
+        } catch (XiaoShiException e) {
+            return Response.error(e.getMessage());
+        }
+        return Response.success();
     }
 
     @checkAuth(FunId = "/admin/function/modify")

PCS/src/main/java/cn/cslg/permission/domain/associate/AssoTenantFunction.java

@@ -1,38 +0,0 @@
-package cn.cslg.permission.domain.associate;
-
-import cn.cslg.permission.common.model.BaseEntity;
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.experimental.Accessors;
-
-/**
- * @author 沈永艺
- * @date 2022-8-12
- * @description 关联类 租户对应功能
- */
-
-@Data
-@Accessors(chain = true)
-@EqualsAndHashCode(callSuper = true)
-@TableName(value = "ASSOCIATE_TENANT_FUNCTION")
-public class AssoTenantFunction extends BaseEntity<AssoTenantFunction> {
-    /**
-     * 租户ID
-     */
-    @TableField(value = "TENANT_ID")
-    private Integer tenantId;
-
-    /**
-     * 功能ID
-     */
-    @TableField(value = "FUNCTION_ID")
-    private Integer functionId;
-
-    /**
-     * 功能编辑组件路径
-     */
-    @TableField(value = "FUNCTION_MODIFY_PATH")
-    private String functionModifyPath;
-}

PCS/src/main/java/cn/cslg/permission/mapper/AssoTenantVipTypeFunctionMapper.java

@@ -31,6 +31,30 @@ public interface AssoTenantVipTypeFunctionMapper {
     int deleteByTenantVipTypeId(Integer tenantVipTypeId);
 
     /**
+     * 根据功能id删除数据
+     *
+     * @param functionId 功能id
+     * @return 返回受影响的行数
+     */
+    int deleteByFunctionId(Integer functionId);
+
+    /**
+     * 根据功能ids批量删除数据
+     *
+     * @param functionIds 功能ids
+     * @return 返回受影响的行数
+     */
+    int deleteByFunctionIds(List<Integer> functionIds);
+
+    /**
+     * 根据功能id查询租户会员类型
+     *
+     * @param functionId 功能id
+     * @return 返回查询到的数据
+     */
+    List<Integer> selectTenantVipTypeIdsByFunctionId(Integer functionId);
+
+    /**
      * 根据租户会员类型id查询数据
      *
      * @param tenantVipTypeId 租户会员类型id

PCS/src/main/java/cn/cslg/permission/mapper/TenantMapper.java

@@ -21,4 +21,44 @@ public interface TenantMapper {
      */
     List<Integer> getTenantIdsByTenantVipType(Integer tenantVipType);
 
+    /**
+     * 根据租户会员类型统计数量
+     *
+     * @param tenantVipType 租户会员类型
+     * @return 返回统计到的数量
+     */
+    int countByTenantVipType(Integer tenantVipType);
+
+    /**
+     * 根据租户会员类型统计数量
+     *
+     * @param tenantVipTypes 租户会员类型
+     * @return 返回统计到的数量
+     */
+    int countByTenantVipTypes(List<Integer> tenantVipTypes);
+
+    /**
+     * 根据id查询数据
+     *
+     * @param id id
+     * @return 返回受影响的行数
+     */
+    TenantVO getStandardById(Integer id);
+
+    /**
+     * 根据租户会员类型查询数据
+     *
+     * @param tenantVipType 租户会员类型
+     * @return 返回查询到的数据
+     */
+    List<TenantVO> selectByTenantVipType(Integer tenantVipType);
+
+    /**
+     * 根据租户会员类型修改数据
+     *
+     * @param tenantVipType 租户会员类型
+     * @return 返回受影响的行数
+     */
+    int updateByTenantVipType(Integer tenantVipType);
+
 }

PCS/src/main/java/cn/cslg/permission/mapper/associate/AssoTenantFunctionMapper.java

@@ -1,40 +0,0 @@
-package cn.cslg.permission.mapper.associate;
-
-import cn.cslg.permission.domain.associate.AssoTenantFunction;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Param;
-import org.apache.ibatis.annotations.Select;
-
-import java.util.List;
-
-/**
- * @author 沈永艺
- * @date 2022-8-29
- * @description 关联类 功能对应租户 Mapper 层
- */
-@Mapper
-public interface AssoTenantFunctionMapper extends BaseMapper<AssoTenantFunction> {
-    @Select("SELECT * FROM ASSOCIATE_TENANT_FUNCTION WHERE FUNCTION_ID = #{functionId} AND TENANT_ID = #{tenantId}")
-    AssoTenantFunction getOneById(@Param("functionId") Object functionId, @Param("tenantId") Integer tenantId);
-
-    @Select("UPDATE ASSOCIATE_TENANT_FUNCTION SET IS_DELETE=0 WHERE ID=#{id}")
-    void updateIsDeleteById(@Param("id") Integer id);
-
-    /**
-     * 根据租户ids批量删除数据
-     *
-     * @param tenantIds 租户ids
-     * @return 返回受影响的行数
-     */
-    int deleteByTenantIds(List<Integer> tenantIds);
-
-    /**
-     * 批量插入数据
-     *
-     * @param assoTenantFunctions 数据对象集合
-     * @return 返回受影响的行数
-     */
-    int insertBatch(List<AssoTenantFunction> assoTenantFunctions);
-
-}

PCS/src/main/java/cn/cslg/permission/service/ApplicationService.java

@@ -10,8 +10,8 @@ import cn.cslg.permission.domain.Function;
 import cn.cslg.permission.domain.Tenant;
 import cn.cslg.permission.domain.associate.AssoApplicationTenant;
 import cn.cslg.permission.mapper.ApplicationMapper;
+import cn.cslg.permission.mapper.AssoTenantVipTypeFunctionMapper;
 import cn.cslg.permission.service.associate.ApplicationTenantService;
-import cn.cslg.permission.service.associate.TenantFunctionService;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
@@ -38,9 +38,10 @@ import java.util.stream.Collectors;
 public class ApplicationService extends ServiceImpl<ApplicationMapper, Application> {
     private final PersonnelService personnelService;
     private final ApplicationTenantService applicationTenantService;
-    private final TenantFunctionService tenantFunctionService;
+    //private final TenantFunctionService tenantFunctionService;
     private final TenantService tenantService;
     private final FunctionService functionService;
+    private final AssoTenantVipTypeFunctionMapper assoTenantVipTypeFunctionMapper;
 
     /**
      * 新增应用
@@ -92,8 +93,11 @@ public class ApplicationService extends ServiceImpl<ApplicationMapper, Applicati
                 List<Integer> ids = functionService.list(lambdaQueryWrapper1).stream().map(Function::getId).collect(Collectors.toList());
                 //用IDList 删除对应的功能数据
                 functionService.removeByIds(ids);
-                //用IDList 删除对应的功能与租户的关联数据
-                tenantFunctionService.delete(null, null, ids);
+//                用IDList 删除对应的功能与租户的关联数据
+//                tenantFunctionService.delete(null, null, ids);
+                //用IDList删除对应的会员和功能关联表数据
+                assoTenantVipTypeFunctionMapper.deleteByFunctionIds(ids);
+
             }
         } catch (Exception e) {
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

PCS/src/main/java/cn/cslg/permission/service/DeleteService.java

@@ -34,7 +34,7 @@ public class DeleteService {
     private final PersonRoleService personRoleService;
     private final PositionRoleService positionRoleService;
     private final RoleFunctionDataService roleFunctionDataService;
-    private final TenantFunctionService tenantFunctionService;
+//    private final TenantFunctionService tenantFunctionService;
     private final PersonGroupService personGroupService;
     private final UserGroupRoleService userGroupRoleService;
 
@@ -72,8 +72,8 @@ public class DeleteService {
             LambdaQueryWrapper<AssoApplicationTenant> applicationTenant = new LambdaQueryWrapper<>();
             applicationTenant.eq(AssoApplicationTenant::getTenantId, tenantId);
 
-            LambdaQueryWrapper<AssoTenantFunction> tenantFunction = new LambdaQueryWrapper<>();
-            tenantFunction.eq(AssoTenantFunction::getTenantId, tenantId);
+//            LambdaQueryWrapper<AssoTenantFunction> tenantFunction = new LambdaQueryWrapper<>();
+//            tenantFunction.eq(AssoTenantFunction::getTenantId, tenantId);
 
             //获取 部门,职位,人员 关联数据
             LambdaQueryWrapper<AssoDepartPos> departPosition = new LambdaQueryWrapper<>();
@@ -117,7 +117,7 @@ public class DeleteService {
             }
             perDpService.remove(personnelDepartmentPosition);
             applicationTenantService.remove(applicationTenant);
-            tenantFunctionService.remove(tenantFunction);
+//            tenantFunctionService.remove(tenantFunction);
 
             //删除实体表数据
             departmentService.removeByIds(departmentIds);

PCS/src/main/java/cn/cslg/permission/service/FunctionService.java

@@ -1,17 +1,18 @@
 package cn.cslg.permission.service;
 
+import cn.cslg.permission.common.model.vo.AssoTenantVipTypeAndFunctionVO;
 import cn.cslg.permission.common.model.vo.FunctionVO;
+import cn.cslg.permission.common.model.vo.TenantVO;
 import cn.cslg.permission.common.utils.CacheUtils;
 import cn.cslg.permission.common.utils.DataUtils;
 import cn.cslg.permission.common.utils.Response;
 import cn.cslg.permission.domain.Application;
 import cn.cslg.permission.domain.Function;
-import cn.cslg.permission.domain.associate.AssoTenantFunction;
+import cn.cslg.permission.exception.XiaoShiException;
+import cn.cslg.permission.mapper.AssoTenantVipTypeFunctionMapper;
 import cn.cslg.permission.mapper.FunctionMapper;
-import cn.cslg.permission.mapper.TenantEntityMapper;
-import cn.cslg.permission.mapper.TenantVipTypeMapper;
+import cn.cslg.permission.mapper.TenantMapper;
 import cn.cslg.permission.service.associate.RoleFunctionDataService;
-import cn.cslg.permission.service.associate.TenantFunctionService;
 import cn.dev33.satoken.stp.StpUtil;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.lang.tree.Tree;
@@ -21,6 +22,7 @@ import cn.hutool.core.lang.tree.TreeUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -35,16 +37,16 @@ import java.util.stream.Collectors;
  * @description 功能类 Service 层
  */
 
+@Slf4j
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class FunctionService extends ServiceImpl<FunctionMapper, Function> {
     private final ApplicationService applicationService;
     private final RoleFunctionDataService roleFunctionDataService;
-    private final TenantFunctionService tenantFunctionService;
+    //private final TenantFunctionService tenantFunctionService;
     private final FunctionMapper functionMapper;
-    //private final TenantMapper tenantMapper;
-    private final TenantVipTypeMapper tenantVipTypeMapper;
-
+    private final AssoTenantVipTypeFunctionMapper assoTenantVipTypeFunctionMapper;
+    private final TenantMapper tenantMapper;
     private final CacheUtils cacheUtils;
 
     @Transactional(rollbackFor = Exception.class)
@@ -78,34 +80,73 @@ public class FunctionService extends ServiceImpl<FunctionMapper, Function> {
     }
 
     @Transactional(rollbackFor = Exception.class)
-    public String deleteFunction(FunctionVO functionVO) {
+    public void deleteFunction(FunctionVO functionVO) {
+//        try {
+//            LambdaQueryWrapper<AssoTenantFunction> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+//            lambdaQueryWrapper.eq(AssoTenantFunction::getFunctionId, functionVO.getId());
+//            List<AssoTenantFunction> tenantFunctionList = tenantFunctionService.list(lambdaQueryWrapper);
+//
+//            if (tenantFunctionList.size() > 0) {
+//                return Response.error("该功能仍有使用者,无法删除");
+//            } else {
+//                List<Function> lst = functionMapper.getFunctionInPathByIdWithoutType(functionVO.getId());
+//                if (lst.size() > 0) {
+//                    this.removeByIds(lst.stream().map(Function::getId).collect(Collectors.toList()));
+//                    tenantFunctionService.delete(null, null, lst.stream().map(Function::getId).collect(Collectors.toList()));
+//                    roleFunctionDataService.delete(null, null, lst.stream().map(Function::getId).collect(Collectors.toList()), null);
+//                } else {
+//                    Function function = new Function();
+//                    function.setId(functionVO.getId());
+//                    function.deleteById();
+//
+//                    tenantFunctionService.delete(null, functionVO.getId(), null);
+//                    roleFunctionDataService.delete(null, functionVO.getId(), null, null);
+//                }
+//            }
+//        } catch (Exception e) {
+//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+//            e.printStackTrace();
+//        }
+//        return Response.success(true);
+        log.info("开始处理【删除功能】的业务，参数为：{}", functionVO);
         try {
-            LambdaQueryWrapper<AssoTenantFunction> lambdaQueryWrapper = new LambdaQueryWrapper<>();
-            lambdaQueryWrapper.eq(AssoTenantFunction::getFunctionId, functionVO.getId());
-            List<AssoTenantFunction> tenantFunctionList = tenantFunctionService.list(lambdaQueryWrapper);
+            Integer functionId = functionVO.getId();
+            //根据功能id查询所有拥有该功能的会员类型ids
+            List<Integer> tenantVipTypeIds = assoTenantVipTypeFunctionMapper.selectTenantVipTypeIdsByFunctionId(functionId);
+            //根据会员类型ids统计选择了这些会员类型的租户的数量，如果数量大于0则意味着该功能有租户正在使用，禁止删除
+            int count = tenantMapper.countByTenantVipTypes(tenantVipTypeIds);
+            if (count > 0) {
+                String message = "删除功能失败，该功能仍有使用者,无法删除";
+                log.info("{}", message);
+                throw new XiaoShiException(message);
+            }
 
-            if (tenantFunctionList.size() > 0) {
-                return Response.error("该功能仍有使用者,无法删除");
+            List<Function> functions = functionMapper.getFunctionInPathByIdWithoutType(functionId);
+            if (functions.size() > 0) {
+                List<Integer> functionIds = functions.stream().map(Function::getId).collect(Collectors.toList());
+                //批量删除功能表数据
+                this.removeByIds(functionIds);
+                //批量删除租户会员类型和功能关联表数据
+                assoTenantVipTypeFunctionMapper.deleteByFunctionIds(functionIds);
+                //批量删除角色和功能关联表数据
+                roleFunctionDataService.delete(null, null, functionIds, null);
             } else {
-                List<Function> lst = functionMapper.getFunctionInPathByIdWithoutType(functionVO.getId());
-                if (lst.size() > 0) {
-                    this.removeByIds(lst.stream().map(Function::getId).collect(Collectors.toList()));
-                    tenantFunctionService.delete(null, null, lst.stream().map(Function::getId).collect(Collectors.toList()));
-                    roleFunctionDataService.delete(null, null, lst.stream().map(Function::getId).collect(Collectors.toList()), null);
-                } else {
-                    Function function = new Function();
-                    function.setId(functionVO.getId());
-                    function.deleteById();
-
-                    tenantFunctionService.delete(null, functionVO.getId(), null);
-                    roleFunctionDataService.delete(null, functionVO.getId(), null, null);
-                }
+                Function function = new Function();
+                function.setId(functionId);
+                //删除功能表数据
+                function.deleteById();
+                //删除租户会员类型和功能关联表数据
+                assoTenantVipTypeFunctionMapper.deleteByFunctionId(functionId);
+                //删除角色和功能关联表数据
+                roleFunctionDataService.delete(null, functionId, null, null);
             }
         } catch (Exception e) {
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
             e.printStackTrace();
         }
-        return Response.success(true);
+
+        log.info("删除功能完成");
+
     }
 
     @Transactional(rollbackFor = Exception.class)
@@ -272,17 +313,36 @@ public class FunctionService extends ServiceImpl<FunctionMapper, Function> {
     }
 
     public String getFuncListByTypeIsShow(String tenant) {
-        //获得当前登陆人所属的租户的租户id
-        Integer tenantId = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt()).getTenantId();
-        LambdaQueryWrapper<AssoTenantFunction> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+//        获取当前登陆人所属的租户的租户id
+//        Integer tenantId = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt()).getTenantId();
+//        LambdaQueryWrapper<AssoTenantFunction> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+//        if (tenant != null && !tenant.equals("")) {
+//            lambdaQueryWrapper.eq(AssoTenantFunction::getTenantId, tenant);
+//        } else {
+//            lambdaQueryWrapper.eq(AssoTenantFunction::getTenantId, tenantId);
+//        }
+//
+//        List<Integer> functionIds = tenantFunctionService.list(lambdaQueryWrapper).stream().map(AssoTenantFunction::getFunctionId).collect(Collectors.toList());
+        log.info("开始处理【查询类型为展示的功能】的业务，参数为：{}", tenant);
+        Integer tenantVipType = null;
+        //如果前端传来了tenant(租户id)就直接用，如果没传来租户id就获取当前登陆人所属的租户的租户id
         if (tenant != null && !tenant.equals("")) {
-            lambdaQueryWrapper.eq(AssoTenantFunction::getTenantId, tenant);
+            int tenantId = Integer.parseInt(tenant);
+            TenantVO tenantVO = tenantMapper.getStandardById(tenantId);
+            tenantVipType = tenantVO.getTenantVipType();
         } else {
-            lambdaQueryWrapper.eq(AssoTenantFunction::getTenantId, tenantId);
+            //获取当前登陆人所属的租户的租户id
+            Integer tenantId = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt()).getTenantId();
+            TenantVO tenantVO = tenantMapper.getStandardById(tenantId);
+            tenantVipType = tenantVO.getTenantVipType();
         }
 
-        List<Integer> functionIds = tenantFunctionService.list(lambdaQueryWrapper).stream().map(AssoTenantFunction::getFunctionId).collect(Collectors.toList());
-
+        List<AssoTenantVipTypeAndFunctionVO> assoTenantVipTypeAndFunctionVOS = assoTenantVipTypeFunctionMapper.selectByTenantVipTypeId(tenantVipType);
+        ArrayList<Integer> functionIds = new ArrayList<>();
+        for (AssoTenantVipTypeAndFunctionVO assoTenantVipTypeAndFunctionVO : assoTenantVipTypeAndFunctionVOS) {
+            Integer functionId = assoTenantVipTypeAndFunctionVO.getFunctionId();
+            functionIds.add(functionId);
+        }
 
         LambdaQueryWrapper<Function> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper

PCS/src/main/java/cn/cslg/permission/service/LoginService.java

@@ -107,17 +107,12 @@ public class LoginService extends ServiceImpl<PersonnelMapper, Personnel> {
                         .setRoleId(roleVO.getId())
                         .setRoleName(roleVO.getName());
                 //如果登录人的类型为 系统管理员1 租户管理员2
-                if (roleVO.getRoleType().equals(1) || roleVO.getRoleType().equals(2)) {
-                    switch (roleVO.getRoleType()) {
-                        case 1:
-                            flag = 1;
-                            break;
-                        case 2:
-                            flag = 2;
-                            break;
-                        default:
-                            flag = 0;
-                    }
+                if (flag == 0 && roleVO.getRoleType().equals(1)) {
+                    flag = 1;
+                } else if (flag == 0 && roleVO.getRoleType().equals(2)) {
+                    flag = 2;
+                } else if (flag == 2 && roleVO.getRoleType().equals(1)) {
+                    flag = 1;
                 }
                 roleList.add(perRole);
             }

PCS/src/main/java/cn/cslg/permission/service/RoleService.java

@@ -141,13 +141,17 @@ public class RoleService extends ServiceImpl<RoleMapper, Role> {
 
         for (Role role : roleList) {
             RoleVO roleVO = new RoleVO();
+            String name = "";
+            if (tenantService.getById(role.getTenantId()) != null) {
+                name = tenantService.getById(role.getTenantId()).getTenantName();
+            }
             roleVO
                     .setId(role.getId())
                     .setRemark(role.getRoleDescription())
                     .setName(role.getRoleName())
                     .setPermissionData(roleFunctionDataService.getPermissionDataByRoleId(role))
                     .setTenant(role.getTenantId())
-                    .setTenantName(tenantService.getById(role.getTenantId()).getTenantName());
+                    .setTenantName(name);
 
             roleVOS.add(roleVO);
         }

PCS/src/main/java/cn/cslg/permission/service/TenantService.java

@@ -13,7 +13,6 @@ import cn.cslg.permission.mapper.AssoTenantVipTypeFunctionMapper;
 import cn.cslg.permission.mapper.TenantEntityMapper;
 import cn.cslg.permission.service.associate.PersonRoleService;
 import cn.cslg.permission.service.associate.RoleFunctionDataService;
-import cn.cslg.permission.service.associate.TenantFunctionService;
 import cn.dev33.satoken.stp.StpUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
@@ -25,7 +24,9 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.interceptor.TransactionAspectSupport;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 import java.util.stream.Collectors;
 
 /**
@@ -38,7 +39,7 @@ import java.util.stream.Collectors;
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
     private final PersonnelService personnelService;
-    private final TenantFunctionService tenantFunctionService;
+    //private final TenantFunctionService tenantFunctionService;
     private final DepartmentService departmentService;
     private final RoleFunctionDataService roleFunctionDataService;
     private final PersonRoleService personRoleService;
@@ -88,42 +89,49 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
             }
 
             //准备租户和功能关联表保存信息
-            Integer tenantVipTypeId = tenant.getTenantVipType();
-            List<AssoTenantVipTypeAndFunctionVO> assoTenantVipTypeAndFunctionVOS = assoTenantVipTypeFunctionMapper.selectByTenantVipTypeId(tenantVipTypeId);
-            List<String> functions = new ArrayList<>();
+//            Integer tenantVipTypeId = tenant.getTenantVipType();
+//            List<AssoTenantVipTypeAndFunctionVO> assoTenantVipTypeAndFunctionVOS = assoTenantVipTypeFunctionMapper.selectByTenantVipTypeId(tenantVipTypeId);
+//            List<String> functions = new ArrayList<>();
+//            for (AssoTenantVipTypeAndFunctionVO assoTenantVipTypeAndFunctionVO : assoTenantVipTypeAndFunctionVOS) {
+//                String functionModifyPath = assoTenantVipTypeAndFunctionVO.getFunctionModifyPath();
+//                functions.add(functionModifyPath);
+//                //将以逗号分隔的功能组件树字符串路径转换为Integer集合
+//                List<Integer> functionId = Arrays.stream(functionModifyPath.split(",")).map(Integer::parseInt).collect(Collectors.toList());
+//            }
+//            tenantVO.setFunctions(functions);
+            //租户和功能关联表保存信息
+//            tenantFunctionService.add(tenantVO, tenant);
+
+            //角色功能权限关联表,角色表保存信息
+            Integer tenantVipType = tenantVO.getTenantVipType();
+            List<AssoTenantVipTypeAndFunctionVO> assoTenantVipTypeAndFunctionVOS = assoTenantVipTypeFunctionMapper.selectByTenantVipTypeId(tenantVipType);
+            List<List<Integer>> functions = new ArrayList<>();
             for (AssoTenantVipTypeAndFunctionVO assoTenantVipTypeAndFunctionVO : assoTenantVipTypeAndFunctionVOS) {
                 String functionModifyPath = assoTenantVipTypeAndFunctionVO.getFunctionModifyPath();
-                functions.add(functionModifyPath);
                 //将以逗号分隔的功能组件树字符串路径转换为Integer集合
-                List<Integer> functionId = Arrays.stream(functionModifyPath.split(",")).map(Integer::parseInt).collect(Collectors.toList());
+                List<Integer> function = Arrays.stream(functionModifyPath.split(",")).map(Integer::parseInt).collect(Collectors.toList());
+                functions.add(function);
             }
-            tenantVO.setFunctions(functions);
-            //租户和功能关联表保存信息
-            tenantFunctionService.add(tenantVO, tenant);
 
-            //角色功能权限关联表,角色表保存信息
             List<RoleVO.Permission> permissions = new ArrayList<>();
-            if (tenantVO.getFunction() != null) {
-                List<List<Integer>> lists = tenantVO.getFunction();
-                List<Integer> ids = new ArrayList<>(); //作为判断是否有重复functionId的标识
-                lists.forEach(item -> {
-                            if (item.size() > 1) {
-                                //从第二个开始遍历
-                                for (int i = 1; i < item.size(); i++) {
-                                    if (!ids.contains(item.get(i))) {
-                                        ids.add(item.get(i));
-                                        RoleVO.Permission permission = new RoleVO.Permission();
-                                        DataVO dataVO = new DataVO();
-                                        dataVO.setId(0);
-                                        permission.setData(dataVO);
-                                        permission.setFunctionId(item.get(i));
-                                        permissions.add(permission);
-                                    }
+            List<Integer> ids = new ArrayList<>(); //作为判断是否有重复functionId的标识
+            functions.forEach(item -> {
+                        if (item.size() > 1) {
+                            //从第二个开始遍历
+                            for (int i = 1; i < item.size(); i++) {
+                                if (!ids.contains(item.get(i))) {
+                                    ids.add(item.get(i));
+                                    RoleVO.Permission permission = new RoleVO.Permission();
+                                    DataVO dataVO = new DataVO();
+                                    dataVO.setId(0);
+                                    permission.setData(dataVO);
+                                    permission.setFunctionId(item.get(i));
+                                    permissions.add(permission);
                                 }
                             }
                         }
-                );
-            }
+                    }
+            );
 
             RoleVO roleVO = new RoleVO();
             roleVO.setTenant(tenant.getId());
@@ -189,14 +197,14 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
             personnelService.updatePersonnel(personnelVO1);
             //修改关联
             //修改租户和功能关联表信息
-            List<AssoTenantVipTypeAndFunctionVO> assoTenantVipTypeAndFunctionVOS = assoTenantVipTypeFunctionMapper.selectByTenantVipTypeId(tenant.getTenantVipType());
-            List<String> functions = new ArrayList<>();
-            for (AssoTenantVipTypeAndFunctionVO assoTenantVipTypeAndFunctionVO : assoTenantVipTypeAndFunctionVOS) {
-                String functionModifyPath = assoTenantVipTypeAndFunctionVO.getFunctionModifyPath();
-                functions.add(functionModifyPath);
-            }
-            tenantVO.setFunctions(functions);
-            tenantFunctionService.updateRoleFunctionData(tenantVO, tenant);
+//            List<AssoTenantVipTypeAndFunctionVO> assoTenantVipTypeAndFunctionVOS = assoTenantVipTypeFunctionMapper.selectByTenantVipTypeId(tenant.getTenantVipType());
+//            List<String> functions = new ArrayList<>();
+//            for (AssoTenantVipTypeAndFunctionVO assoTenantVipTypeAndFunctionVO : assoTenantVipTypeAndFunctionVOS) {
+//                String functionModifyPath = assoTenantVipTypeAndFunctionVO.getFunctionModifyPath();
+//                functions.add(functionModifyPath);
+//            }
+//            tenantVO.setFunctions(functions);
+//            tenantFunctionService.updateRoleFunctionData(tenantVO, tenant);
             //修改部门表里的TenantName(租户名称)字段
             LambdaQueryWrapper<Department> lambdaQueryWrapper = new LambdaQueryWrapper<>();
             lambdaQueryWrapper
@@ -255,27 +263,26 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
     private Object setTenantToVO(List<Tenant> tenantList) {
         List<TenantVO> tenantVOs = new ArrayList<>();
         for (Tenant tenant : tenantList) {
-            List<String> functionModifyPath = tenantFunctionService.getFunctionModifyPath(tenant.getId());
-
-            List<List<Integer>> lst = new ArrayList<>();
-            Set<Integer> set = new HashSet<>();
-            for (String s : functionModifyPath) {
-                String[] split = s.split(",");
-                List<Integer> modifyPathList = new ArrayList<>();
-
-                for (String value : split) {
-                    modifyPathList.add(Integer.valueOf(value));
-                }
-
-                set.add(Integer.valueOf(split[0]));
-                lst.add(modifyPathList);
-            }
-            List<Integer> appId = new ArrayList<>(set);
-            for (Integer integer : appId) {
-                List<Integer> a = new ArrayList<>();
-                a.add(integer);
-                lst.add(a);
-            }
+//            List<String> functionModifyPath = tenantFunctionService.getFunctionModifyPath(tenant.getId());
+//            List<List<Integer>> lst = new ArrayList<>();
+//            Set<Integer> set = new HashSet<>();
+//            for (String s : functionModifyPath) {
+//                String[] split = s.split(",");
+//                List<Integer> modifyPathList = new ArrayList<>();
+//
+//                for (String value : split) {
+//                    modifyPathList.add(Integer.valueOf(value));
+//                }
+//
+//                set.add(Integer.valueOf(split[0]));
+//                lst.add(modifyPathList);
+//            }
+//            List<Integer> appId = new ArrayList<>(set);
+//            for (Integer integer : appId) {
+//                List<Integer> a = new ArrayList<>();
+//                a.add(integer);
+//                lst.add(a);
+//            }
 
             TenantVO tenantVO = new TenantVO();
             tenantVO
@@ -290,9 +297,9 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
                     .setType(tenant.getTenantType())
                     .setTenantVipType(tenant.getTenantVipType())
                     .setUsername(personnelService.getById(tenant.getPersonnelId()).getPersonnelUserName())
-                    .setPersonnelId(tenant.getPersonnelId())
-                    .setFunction(lst)
-                    .setFunctionList(tenantFunctionService.getFunction(tenant.getId()));
+                    .setPersonnelId(tenant.getPersonnelId());
+//                    .setFunction(lst)
+//                    .setFunctionList(tenantFunctionService.getFunction(tenant.getId()));
 
             tenantVOs.add(tenantVO);
         }

PCS/src/main/java/cn/cslg/permission/service/UserGroupService.java

@@ -203,6 +203,10 @@ public class UserGroupService extends ServiceImpl<UserGroupMapper, UserGroup> {
             }
 
             UserGroupVO userGroupVO = new UserGroupVO();
+            String tenantName = "";
+            if (tenantService.getById(userGroup.getTenantId()) != null) {
+                tenantName = tenantService.getById(userGroup.getTenantId()).getTenantName();
+            }
             userGroupVO.setId(userGroup.getId())
                     .setRemark(userGroup.getUserGroupDescription())
                     .setName(userGroup.getUserGroupName())
@@ -211,7 +215,7 @@ public class UserGroupService extends ServiceImpl<UserGroupMapper, UserGroup> {
                     .setRole(roleVOS.stream().map(RoleVO::getId).collect(Collectors.toList()))
                     .setRoleList(roleVOS)
                     .setTenant(userGroup.getTenantId())
-                    .setTenantName(tenantService.getById(userGroup.getTenantId()).getTenantName());
+                    .setTenantName(tenantName);
 
 
             userGroupVOS.add(userGroupVO);

PCS/src/main/java/cn/cslg/permission/service/associate/RoleFunctionDataService.java

@@ -285,6 +285,7 @@ public class RoleFunctionDataService extends ServiceImpl<AssoRoleFunctionDataMap
         LambdaQueryWrapper<AssoPersonRole> lambdaQueryWrapper = new LambdaQueryWrapper<>();
         lambdaQueryWrapper.eq(AssoPersonRole::getPersonnelId, loginId);
         List<Integer> roleIds = personRoleService.list(lambdaQueryWrapper).stream().map(AssoPersonRole::getRoleId).collect(Collectors.toList());
+        System.out.println(roleIds);
         LambdaQueryWrapper<AssoRoleFunctionData> lambdaQueryWrapper1 = new LambdaQueryWrapper<>();
         if (roleIds.size() > 0) {
             lambdaQueryWrapper1.in(AssoRoleFunctionData::getRoleId, roleIds);

PCS/src/main/java/cn/cslg/permission/service/associate/TenantFunctionService.java

@@ -1,221 +0,0 @@
-package cn.cslg.permission.service.associate;
-
-import cn.cslg.permission.common.model.vo.DataVO;
-import cn.cslg.permission.common.model.vo.FunctionVO;
-import cn.cslg.permission.common.model.vo.RoleVO;
-import cn.cslg.permission.common.model.vo.TenantVO;
-import cn.cslg.permission.common.utils.DataUtils;
-import cn.cslg.permission.domain.Function;
-import cn.cslg.permission.domain.Role;
-import cn.cslg.permission.domain.Tenant;
-import cn.cslg.permission.domain.associate.AssoRoleFunctionData;
-import cn.cslg.permission.domain.associate.AssoTenantFunction;
-import cn.cslg.permission.mapper.associate.AssoTenantFunctionMapper;
-import cn.cslg.permission.service.FunctionService;
-import cn.cslg.permission.service.RoleService;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import lombok.RequiredArgsConstructor;
-import org.springframework.context.annotation.Lazy;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-import org.springframework.transaction.interceptor.TransactionAspectSupport;
-
-import java.util.*;
-import java.util.stream.Collectors;
-
-/**
- * @author 沈永艺
- * @date 2022-8-29
- * @description 关联类 功能对应租户 Service 层
- */
-
-@Service
-@RequiredArgsConstructor(onConstructor_ = {@Lazy})
-public class TenantFunctionService extends ServiceImpl<AssoTenantFunctionMapper, AssoTenantFunction> {
-    private final AssoTenantFunctionMapper assoTenantFunctionMapper;
-    private final FunctionService functionService;
-    private final RoleFunctionDataService roleFunctionDataService;
-    private final RoleService roleService;
-
-    @Transactional(rollbackFor = Exception.class)
-    public void add(TenantVO tenantVO, Tenant tenant) {
-        try {
-            List<AssoTenantFunction> tfList = new ArrayList<>();
-            tenantVO.getFunctions().forEach(item -> {
-                AssoTenantFunction assoTenantFunction = new AssoTenantFunction();
-                if (item.split(",").length > 1) {
-                    assoTenantFunction
-                            .setTenantId(tenant.getId())
-                            .setFunctionModifyPath(item)
-                            .setFunctionId(Integer.valueOf(item.split(",")[item.split(",").length - 1]));
-                }
-                tfList.add(assoTenantFunction);
-            });
-            if (tfList.size() != 0) {
-                this.saveBatch(tfList);
-            }
-        } catch (Exception e) {
-            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-            e.printStackTrace();
-        }
-    }
-
-    @Transactional(rollbackFor = Exception.class)
-    public void delete(Integer tenantId, Integer functionId, List<Integer> functionIds) {
-        try {
-            LambdaQueryWrapper<AssoTenantFunction> queryWrapper = new LambdaQueryWrapper<>();
-            if (functionIds != null) {
-                queryWrapper
-                        .in(AssoTenantFunction::getFunctionId, functionIds);
-            } else {
-                if (tenantId != null) {
-                    queryWrapper.eq(AssoTenantFunction::getTenantId, tenantId);
-                } else if (functionId != null) {
-                    queryWrapper
-                            .eq(AssoTenantFunction::getFunctionId, functionId);
-                }
-            }
-            this.remove(queryWrapper);
-        } catch (Exception e) {
-            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-            e.printStackTrace();
-        }
-    }
-
-    @Transactional(rollbackFor = Exception.class)
-    public void updateRoleFunctionData(TenantVO tenantVO, Tenant tenant) {
-        try {
-            //查询角色ID下的有哪些功能ID
-            LambdaQueryWrapper<AssoTenantFunction> lambdaQueryWrapper = new LambdaQueryWrapper<>();
-            lambdaQueryWrapper.eq(AssoTenantFunction::getTenantId, tenantVO.getId());
-            List<AssoTenantFunction> tfList = this.list(lambdaQueryWrapper);
-            //获取已有功能List
-            List<Integer> assoList = tfList.stream().map(AssoTenantFunction::getFunctionId).collect(Collectors.toList());
-
-            //解析前台传入数据有哪些功能ID
-            List<Integer> paramList = new ArrayList<>();
-            List<Map<String, Object>> mapList = new ArrayList<>();
-            tenantVO.getFunctions().forEach(item -> {
-                Map<String, Object> map = new HashMap<>();
-                map.put(item.split(",")[(item.split(",").length - 1)], item);
-                mapList.add(map);
-                paramList.add(Integer.valueOf(item.split(",")[(item.split(",").length - 1)]));
-            });
-
-            processDataByDiff(tenantVO, tenant, assoList, paramList, mapList);
-        } catch (Exception e) {
-            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-            e.printStackTrace();
-        }
-    }
-
-
-    private void processDataByDiff(TenantVO tenantVO, Tenant tenant, List<Integer> assoList, List<Integer> paramList, List<Map<String, Object>> mapList) {
-        Map<String, List<Integer>> compare = DataUtils.compareTwoList(assoList, paramList);
-        List<Integer> reduce = compare.get("reduce");
-        List<Integer> change = compare.get("change");
-        if (reduce.size() > 0) {
-            LambdaQueryWrapper<AssoTenantFunction> lambdaQueryWrapper1 = new LambdaQueryWrapper<>();
-            lambdaQueryWrapper1
-                    .in(AssoTenantFunction::getFunctionId, reduce)
-                    .eq(AssoTenantFunction::getTenantId, tenantVO.getId());
-            this.remove(lambdaQueryWrapper1);
-
-            List<Integer> roleIds = roleService.list(new LambdaQueryWrapper<Role>().eq(Role::getTenantId, tenantVO.getId())).stream().map(Role::getId).collect(Collectors.toList());
-            if (roleIds.size() > 0) {
-                roleFunctionDataService.delete(null, null, reduce, roleIds);
-            }
-
-
-            //移除该租户下角色的 租户已经没有的功能
-            LambdaQueryWrapper<Role> queryWrapperRole = new LambdaQueryWrapper<>();
-            queryWrapperRole.eq(Role::getTenantId, tenant.getId());
-            List<Role> roles = roleService.list(queryWrapperRole);
-            List<Integer> Ids = new ArrayList<>();
-            roles.forEach((item -> {
-                Ids.add(item.getId());
-            }));
-            LambdaQueryWrapper<AssoRoleFunctionData> queryWrapper = new LambdaQueryWrapper<>();
-            queryWrapper.in(AssoRoleFunctionData::getFunctionId, reduce).in(AssoRoleFunctionData::getRoleId, Ids);
-            roleFunctionDataService.remove(queryWrapper);
-        }
-        if (change.size() > 0) {
-            change.forEach(item -> {
-                AssoTenantFunction assoTenantFunction = assoTenantFunctionMapper.getOneById(item, tenantVO.getId());
-
-                if (assoTenantFunction != null && assoTenantFunction.getIsDelete() == 1) {
-                    assoTenantFunctionMapper.updateIsDeleteById(assoTenantFunction.getId());
-                } else {
-                    final String[] modifyPath = new String[1];
-                    mapList.forEach(x -> {
-                        if (x.containsKey(item.toString())) {
-                            modifyPath[0] = (String) x.get(item.toString());
-                        }
-                    });
-                    tenantVO.setFunctions(Collections.singletonList(modifyPath[0]));
-
-                    this.add(tenantVO, tenant);
-                }
-            });
-
-            //给该租户下的管理员添加功能
-            LambdaQueryWrapper<Role> queryWrapperMaster = new LambdaQueryWrapper<>();
-            queryWrapperMaster.eq(Role::getTenantId, tenant.getId()).eq(Role::getRoleType, 2);
-            List<Role> roleList = roleService.list(queryWrapperMaster);
-            if (roleList != null && roleList.size() != 0) {
-                Integer roleId = roleList.get(0).getId();
-                RoleVO roleVO = new RoleVO();
-                roleVO.setId(roleId);
-                List<RoleVO.Permission> permissions = new ArrayList<>();
-                change.forEach(item -> {
-                    RoleVO.Permission permission = new RoleVO.Permission();
-                    permission.setFunctionId(item);
-                    DataVO dataVO = new DataVO();
-                    dataVO.setId(0);
-                    permission.setData(dataVO);
-                    permissions.add(permission);
-
-                });
-                roleVO.setPermissionData(permissions);
-                roleFunctionDataService.add(roleVO);
-
-            }
-
-
-        }
-    }
-
-    public List<String> getFunctionModifyPath(Integer tenantId) {
-        List<String> functionModifyPathList = new ArrayList<>();
-        LambdaQueryWrapper<AssoTenantFunction> lambdaQueryWrapper = new LambdaQueryWrapper<>();
-        lambdaQueryWrapper.eq(AssoTenantFunction::getTenantId, tenantId);
-        List<AssoTenantFunction> rfdList = this.list(lambdaQueryWrapper);
-        for (AssoTenantFunction assoTenantFunction : rfdList) {
-            functionModifyPathList.add(assoTenantFunction.getFunctionModifyPath());
-        }
-        return functionModifyPathList;
-    }
-
-    public List<FunctionVO> getFunction(Integer tenantId) {
-        LambdaQueryWrapper<AssoTenantFunction> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(AssoTenantFunction::getTenantId, tenantId);
-        List<AssoTenantFunction> tfList = this.list(queryWrapper);
-        List<FunctionVO> functionVOList = new ArrayList<>();
-        if (!tfList.isEmpty()) {
-            List<Integer> idList = tfList.stream().map(AssoTenantFunction::getFunctionId).collect(Collectors.toList());
-            List<Function> functionList = functionService.listByIds(idList);
-            for (Function function : functionList) {
-                FunctionVO functionVO = new FunctionVO();
-                functionVO
-                        .setId(function.getId())
-                        .setName(function.getFunctionName())
-                        .setDescribe(function.getFunctionDescription());
-                functionVOList.add(functionVO);
-            }
-        }
-
-        return functionVOList;
-    }
-
-}

PCS/src/main/java/cn/cslg/permission/service/impl/TenantVipTypeService.java

@@ -4,19 +4,16 @@ import cn.cslg.permission.common.JsonPage;
 import cn.cslg.permission.common.model.dto.PageDTO2;
 import cn.cslg.permission.common.model.dto.TenantVipTypeFunctionAddNewDTO;
 import cn.cslg.permission.common.model.dto.TenantVipTypeFunctionUpdateDTO;
-import cn.cslg.permission.common.model.vo.AssoTenantVipTypeAndFunctionVO;
+import cn.cslg.permission.common.model.vo.TenantVO;
 import cn.cslg.permission.common.model.vo.TenantVipTypeFunctionVO;
 import cn.cslg.permission.domain.AssoTenantVipTypeAndFunction;
 import cn.cslg.permission.domain.FunctionIdPathNameDescription;
 import cn.cslg.permission.domain.TenantVipType;
-import cn.cslg.permission.domain.associate.AssoTenantFunction;
 import cn.cslg.permission.exception.XiaoShiException;
 import cn.cslg.permission.mapper.AssoTenantVipTypeFunctionMapper;
 import cn.cslg.permission.mapper.TenantMapper;
 import cn.cslg.permission.mapper.TenantVipTypeMapper;
-import cn.cslg.permission.mapper.associate.AssoTenantFunctionMapper;
 import cn.cslg.permission.service.ITenantVipTypeService;
-import cn.cslg.permission.service.associate.TenantFunctionService;
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
 import lombok.RequiredArgsConstructor;
@@ -43,8 +40,8 @@ public class TenantVipTypeService implements ITenantVipTypeService {
     private final TenantVipTypeMapper tenantVipTypeMapper;
     private final AssoTenantVipTypeFunctionMapper assoTenantVipTypeFunctionMapper;
     private final TenantMapper tenantMapper;
-    private final AssoTenantFunctionMapper assoTenantFunctionMapper;
-    private final TenantFunctionService tenantFunctionService;
+    //private final AssoTenantFunctionMapper assoTenantFunctionMapper;
+    //private final TenantFunctionService tenantFunctionService;
 
     /**
      * 新增租户会员类型(绑定对应的功能权限)
@@ -139,7 +136,7 @@ public class TenantVipTypeService implements ITenantVipTypeService {
 
         //遍历租户会员类型，取出每个会员类型中的功能ID、功能组件树路径、功能名称、功能描述集合
         for (TenantVipTypeFunctionVO tenantVipTypeFunctionVO : queryResults) {
-            ArrayList<List<Integer>> functions = new ArrayList<>();
+            List<List<Integer>> functions = new ArrayList<>();
             List<FunctionIdPathNameDescription> functionIdPathNameDescriptions = tenantVipTypeFunctionVO.getFunctionIdPathNameDescriptions();
             //遍历功能ID、功能组件树路径、功能名称、功能描述集合，取出每个集合中的功能组件树路径
             for (FunctionIdPathNameDescription functionIdPathNameDescription : functionIdPathNameDescriptions) {
@@ -214,29 +211,6 @@ public class TenantVipTypeService implements ITenantVipTypeService {
             throw new XiaoShiException(message);
         }
 
-        //修改租户和功能关联表数据 ↓
-        //根据租户会员类型查询租户tenantIds
-        log.info("根据租户会员类型查询租户表的tenantIds");
-        List<Integer> tenantIds = tenantMapper.getTenantIdsByTenantVipType(tenantVipTypeId);
-        //删除选择该租户会员类型的原租户和功能关联表数据
-        log.info("批量删除选择该租户会员类型的原租户和功能关联表数据");
-        assoTenantFunctionMapper.deleteByTenantIds(tenantIds);
-        //遍历选择该会员的租户，新数据入租户和功能关联表
-        for (Integer tenantId : tenantIds) {
-            List<AssoTenantFunction> assoTenantFunctions = new ArrayList<>();
-            for (String functionModifyPath : functionModifyPaths) {
-                String functionStringId = functionModifyPath.split(",")[functionModifyPath.split(",").length - 1];
-                int functionId = Integer.parseInt(functionStringId);
-                AssoTenantFunction assoTenantFunction = new AssoTenantFunction()
-                        .setTenantId(tenantId)
-                        .setFunctionId(functionId)
-                        .setFunctionModifyPath(functionModifyPath);
-                assoTenantFunctions.add(assoTenantFunction);
-            }
-            //用mybatis-plus的方法(因为这里数据插入租户和功能关联表时还有创建时间、创建人、IS_DELETE字段，租户和功能关联表实体类中使用了注解@TableField(value = "CREATE_USER", fill = FieldFill.INSERT))
-            tenantFunctionService.saveBatch(assoTenantFunctions);
-        }
-
         log.info("修改租户会员类型完成");
 
     }
@@ -259,6 +233,13 @@ public class TenantVipTypeService implements ITenantVipTypeService {
             throw new XiaoShiException(message);
         }
 
+        //检查该会员类型是否有租户使用
+        count = tenantMapper.countByTenantVipType(id);
+        if (count > 0) {
+            //将所有使用该会员的租户的租户会员类型修改为null
+            tenantMapper.updateByTenantVipType(id);
+        }
+
         //删除租户会员类型表数据
         log.info("删除租户会员类型表数据");
         int rows = tenantVipTypeMapper.deleteById(id);

PCS/src/main/resources/mapper/AssoTenantFunctionMapper.xml

@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-
-
-<mapper namespace="cn.cslg.permission.mapper.associate.AssoTenantFunctionMapper">
-
-    <!--根据租户ids批量删除数据-->
-    <!--int deleteByTenantIds(List<Integer> tenantIds);-->
-    <delete id="deleteByTenantIds">
-        delete
-        from associate_tenant_function
-        where TENANT_ID in (
-        <foreach collection="list" item="n" separator=",">
-            #{n}
-        </foreach>
-        )
-    </delete>
-
-    <!--批量插入数据-->
-    <!--int insertBatch(List<AssoTenantFunction> assoTenantFunctions);-->
-    <insert id="insertBatch" useGeneratedKeys="true" keyProperty="id">
-        insert into associate_tenant_function (TENANT_ID, FUNCTION_ID, FUNCTION_MODIFY_PATH, CREATE_USER,
-                                               CREATE_TIME, IS_DELETE)
-        VALUES
-        <foreach collection="list" item="n" separator=",">
-            (#{n.}, #{n.}, #{n.}, #{n.}, #{n.}, #{n.})
-        </foreach>
-    </insert>
-
-
-</mapper>

PCS/src/main/resources/mapper/AssoTenantVipTypeFunctionMapper.xml

@@ -7,7 +7,7 @@
     <!--批量插入数据-->
     <!--int insertBatch(List<AssoTenantVipTypeAndFunction> assoTenantVipTypeAndFunctions);-->
     <insert id="insertBatch" useGeneratedKeys="true" keyProperty="id">
-        insert into ASSO_TENANTVIPTYPE_FUNCTION (TENANT_VIP_TYPE_ID, FUNCTION_ID, FUNCTION_MODIFY_PATH)
+        insert into asso_tenantviptype_function (TENANT_VIP_TYPE_ID, FUNCTION_ID, FUNCTION_MODIFY_PATH)
         VALUES
         <foreach collection="list" item="n" separator=",">
             (#{n.tenantVipTypeId}, #{n.functionId}, #{n.functionModifyPath})
@@ -18,21 +18,50 @@
     <!--int deleteByTenantVipTypeId(Integer tenantVipTypeId);-->
     <delete id="deleteByTenantVipTypeId">
         delete
-        from ASSO_TENANTVIPTYPE_FUNCTION
+        from asso_tenantviptype_function
         where TENANT_VIP_TYPE_ID = #{tenantVipTypeId}
     </delete>
 
+    <!--根据功能id删除数据-->
+    <!--int deleteByFunctionId(Integer functionId);-->
+    <delete id="deleteByFunctionId">
+        delete
+        from asso_tenantviptype_function
+        where FUNCTION_ID = #{functionId}
+    </delete>
+
+    <!--根据功能ids批量删除数据-->
+    <!--int deleteByFunctionIds(List<Integer> functionIds);-->
+    <delete id="deleteByFunctionIds">
+        delete
+        from asso_tenantviptype_function
+        where FUNCTION_ID in (
+        <foreach collection="list" item="n" separator=",">
+            #{n}
+        </foreach>
+        )
+    </delete>
+
+    <!--根据功能id查询租户会员类型-->
+    <!--List<Integer> selectTenantVipTypeIdsByFunctionId(Integer functionId);-->
+    <select id="selectTenantVipTypeIdsByFunctionId" resultType="int">
+        select TENANT_VIP_TYPE_ID
+        from asso_tenantviptype_function
+        where FUNCTION_ID = #{functionId}
+    </select>
+
     <!--根据租户会员类型id查询数据-->
     <!--List<AssoTenantVipTypeAndFunctionVO> selectByTenantVipTypeId(Integer tenantVipTypeId);-->
     <select id="selectByTenantVipTypeId" resultMap="selectByTenantVipTypeIdMap">
-        select FUNCTION_MODIFY_PATH
-        from ASSO_TENANTVIPTYPE_FUNCTION
+        select TENANT_VIP_TYPE_ID, FUNCTION_ID, FUNCTION_MODIFY_PATH
+        from asso_tenantviptype_function
         where TENANT_VIP_TYPE_ID = #{tenantVipTypeId}
     </select>
 
     <resultMap id="selectByTenantVipTypeIdMap" type="cn.cslg.permission.common.model.vo.AssoTenantVipTypeAndFunctionVO">
+        <result column="TENANT_VIP_TYPE_ID" property="tenantVipType"/>
+        <result column="FUNCTION_ID" property="functionId"/>
         <result column="FUNCTION_MODIFY_PATH" property="functionModifyPath"/>
     </resultMap>
 
-
 </mapper>

PCS/src/main/resources/mapper/TenantMapper.xml

@@ -11,4 +11,82 @@
         where TENANT_VIP_TYPE = #{tenantVipType}
     </select>
 
+    <!--根据租户会员类型统计数量-->
+    <!--int countByTenantVipType(Integer tenantVipType);-->
+    <select id="countByTenantVipType" resultType="int">
+        select count(*)
+        from tenant
+        where TENANT_VIP_TYPE = #{tenantVipType}
+    </select>
+
+    <!--根据租户会员类型统计数量-->
+    <!--int countByTenantVipTypes(List<Integer> tenantVipTypes);-->
+    <select id="countByTenantVipTypes" resultType="int">
+        select count(*)
+        from tenant
+        where TENANT_VIP_TYPE in (
+        <foreach collection="list" item="n" separator=",">
+            #{n}
+        </foreach>
+        )
+    </select>
+
+    <!--根据id查询数据-->
+    <!--TenantVO getStandardById(Integer id);-->
+    <select id="getStandardById" resultMap="queryStandardMap">
+        select ID,
+               TENANT_NAME,
+               TENANT_ADDRESS,
+               TENANT_CONTACTS,
+               TENANT_EMAIL,
+               TENANT_DESCRIPTION,
+               TENANT_QUOTA,
+               TENANT_STATUS,
+               TENANT_TYPE,
+               TENANT_VIP_TYPE,
+               PERSONNEL_ID
+        from tenant
+        where ID = #{id}
+    </select>
+
+    <resultMap id="queryStandardMap" type="cn.cslg.permission.common.model.vo.TenantVO">
+        <id column="ID" property="id"/>
+        <result column="TENANT_NAME" property="name"/>
+        <result column="TENANT_ADDRESS" property="address"/>
+        <result column="TENANT_CONTACTS" property="contacts"/>
+        <result column="TENANT_EMAIL" property="email"/>
+        <result column="TENANT_DESCRIPTION" property="describe"/>
+        <result column="TENANT_QUOTA" property="number"/>
+        <result column="TENANT_STATUS" property="state"/>
+        <result column="TENANT_TYPE" property="type"/>
+        <result column="TENANT_VIP_TYPE" property="tenantVipType"/>
+        <result column="PERSONNEL_ID" property="personnelId"/>
+    </resultMap>
+
+    <!--TenantVipType(Integer tenantVipType);-->
+    <!--List<TenantVO> selectByTenantVipType(Integer tenantVipType);-->
+    <select id="selectByTenantVipType" resultMap="queryStandardMap">
+        select ID,
+               TENANT_NAME,
+               TENANT_ADDRESS,
+               TENANT_CONTACTS,
+               TENANT_EMAIL,
+               TENANT_DESCRIPTION,
+               TENANT_QUOTA,
+               TENANT_STATUS,
+               TENANT_TYPE,
+               TENANT_VIP_TYPE,
+               PERSONNEL_ID
+        from tenant
+        where TENANT_VIP_TYPE = #{tenantVipType}
+    </select>
+
+    <!--根据租户会员类型修改数据-->
+    <!--int updateByTenantVipType(Integer tenantVipType);-->
+    <update id="updateByTenantVipType">
+        update tenant
+        set TENANT_VIP_TYPE = null
+        where TENANT_VIP_TYPE = #{tenantVipType}
+    </update>
+
 </mapper>