5/18 功能增删改查相关bug修改、会员相关bug修改

PCS/src/main/java/cn/cslg/permission/common/model/dto/TenantVipTypeFunctionAddNewDTO.java

@@ -1,12 +1,9 @@
 package cn.cslg.permission.common.model.dto;
 
-import com.fasterxml.jackson.annotation.JsonFormat;
 import lombok.Data;
 import lombok.experimental.Accessors;
-import org.springframework.format.annotation.DateTimeFormat;
 
 import java.io.Serializable;
-import java.util.Date;
 import java.util.List;
 
 /**
@@ -19,7 +16,7 @@ import java.util.List;
 @Data
 public class TenantVipTypeFunctionAddNewDTO implements Serializable {
     /**
-     * 租户会员类型名称
+     * 会员名称
      */
     private String tenantVipName;
     /**

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

@@ -48,7 +48,11 @@ public class FunctionController {
     @PostMapping("/update")
     @Operation(summary = "修改功能")
     public String updateFunction(@RequestBody FunctionVO functionVO) {
-        functionService.updateFunction(functionVO);
+        try {
+            functionService.updateFunction(functionVO);
+        } catch (XiaoShiException e) {
+            return Response.error(e.getMessage());
+        }
         return Response.success(true);
     }
 

PCS/src/main/java/cn/cslg/permission/domain/AssoTenantVipTypeAndFunction.java

@@ -16,15 +16,15 @@ import java.io.Serializable;
 @Data
 public class AssoTenantVipTypeAndFunction implements Serializable {
     /**
-     * 主键ID
+     * 主键id
      */
     private Integer id;
     /**
-     * 租户会员类型ID
+     * 会员id
      */
     private Integer tenantVipTypeId;
     /**
-     * 功能ID
+     * 功能id
      */
     private Integer functionId;
     /**

PCS/src/main/java/cn/cslg/permission/domain/TenantVipType.java

@@ -1,5 +1,8 @@
 package cn.cslg.permission.domain;
 
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 import lombok.experimental.Accessors;
 
@@ -13,12 +16,14 @@ import java.util.Date;
  * @Author chenyu
  * @Data 2023/2/15
  */
+@TableName(value = "TENANT_VIP_TYPE")
 @Accessors(chain = true)
 @Data
 public class TenantVipType implements Serializable {
     /**
      * 主键ID
      */
+    @TableId(value = "id", type = IdType.AUTO)
     private Integer id;
     /**
      * 租户会员类型名称

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

@@ -6,6 +6,7 @@ import cn.cslg.permission.common.model.vo.FunctionVO;
 import cn.cslg.permission.common.model.vo.TenantVipTypeFunctionVO;
 import cn.cslg.permission.domain.Function;
 import cn.cslg.permission.domain.TenantVipType;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
@@ -17,7 +18,7 @@ import java.util.List;
  * @Data 2023/2/15
  */
 @Repository
-public interface TenantVipTypeMapper {
+public interface TenantVipTypeMapper extends BaseMapper<TenantVipType> {
     /**
      * 插入数据
      *

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

@@ -2,10 +2,9 @@ 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.PersonnelVO;
 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.common.utils.*;
 import cn.cslg.permission.domain.Application;
 import cn.cslg.permission.domain.Function;
 import cn.cslg.permission.exception.XiaoShiException;
@@ -43,19 +42,28 @@ import java.util.stream.Collectors;
 public class FunctionService extends ServiceImpl<FunctionMapper, Function> {
     private final ApplicationService applicationService;
     private final RoleFunctionDataService roleFunctionDataService;
-    //private final TenantFunctionService tenantFunctionService;
     private final FunctionMapper functionMapper;
     private final AssoTenantVipTypeFunctionMapper assoTenantVipTypeFunctionMapper;
     private final TenantMapper tenantMapper;
     private final CacheUtils cacheUtils;
+    private final LoginUtils loginUtils;
 
     @Transactional(rollbackFor = Exception.class)
     public String addFunction(FunctionVO functionVO) {
+        log.info("开始处理【新增功能】的业务，参数为：{}", functionVO);
+
+        //获取当前登录人信息，取出登陆人id
+        PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
+        Integer createUser = personnelVO.getId();
+
+        //根据功能标识和所属应用id查询功能表，判断功能标识是否已存在
         String modifyPath = functionVO.getSign();
         List<Function> functionList = this.list(new LambdaQueryWrapper<Function>().eq(Function::getFunctionPath, modifyPath).eq(Function::getApplicationId, functionVO.getApply()));
         if (functionList.size() > 0) {
-            return Response.error("该功能标识已被使用");
+            return Response.error("新增失败，该功能标识已被使用");
         }
+
+        //新增功能
         try {
             Function function = new Function();
             function
@@ -64,7 +72,8 @@ public class FunctionService extends ServiceImpl<FunctionMapper, Function> {
                     .setFunctionPath(functionVO.getSign())
                     .setApplicationId(functionVO.getApply())
                     .setFunctionType(functionVO.getFunctionType())
-                    .setFunctionDescription(functionVO.getDescribe());
+                    .setFunctionDescription(functionVO.getDescribe())
+                    .setCreateUser(createUser);
             if (functionVO.getFunction() == 0) {
                 function.setPath("0");
             } else {
@@ -84,35 +93,28 @@ public class FunctionService extends ServiceImpl<FunctionMapper, Function> {
         log.info("开始处理【删除功能】的业务，参数为：{}", functionVO);
         try {
             Integer functionId = functionVO.getId();
-            //根据功能id查询所有拥有该功能的会员类型ids
+            //根据功能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 (tenantVipTypeIds != null && tenantVipTypeIds.size() > 0) {
+                //根据会员ids统计租户的数量，如果数量大于0则意味着该功能有租户正在使用，禁止删除
+                int count = tenantMapper.countByTenantVipTypes(tenantVipTypeIds);
+                if (count > 0) {
+                    ThrowException.throwXiaoShiException("删除功能失败，该功能仍有使用者,无法删除");
+                }
             }
 
+            //根据当前要删除的功能id，查询功能表获得其所有子级功能
             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 {
-                Function function = new Function();
-                function.setId(functionId);
-                //删除功能表数据
-                function.deleteById();
-                //删除租户会员类型和功能关联表数据
-                assoTenantVipTypeFunctionMapper.deleteByFunctionId(functionId);
-                //删除角色和功能关联表数据
-                roleFunctionDataService.delete(null, functionId, null, null);
-            }
+            //获得其所有子级功能ids
+            List<Integer> functionIds = functions.stream().map(Function::getId).collect(Collectors.toList());
+            //子级ids集合将它们的顶父级(当前要删除的功能id)也加上
+            functionIds.add(functionId);
+            //批量删除功能表数据
+            this.removeByIds(functionIds);
+            //批量删除会员和功能关联表数据
+            assoTenantVipTypeFunctionMapper.deleteByFunctionIds(functionIds);
+            //批量删除角色和功能关联表数据
+            roleFunctionDataService.delete(null, null, functionIds, null);
         } catch (Exception e) {
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
             e.printStackTrace();
@@ -124,6 +126,13 @@ public class FunctionService extends ServiceImpl<FunctionMapper, Function> {
 
     @Transactional(rollbackFor = Exception.class)
     public void updateFunction(FunctionVO functionVO) {
+        //根据当前传来的功能的功能标识和所属应用id查询功能表，若有数据(除本身)则修改失败，返回错误提示"该功能标识已被使用"
+        LambdaQueryWrapper<Function> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(Function::getFunctionPath, functionVO.getSign()).eq(Function::getApplicationId, functionVO.getApply()).ne(Function::getId, functionVO.getId());
+        List<Function> functions = this.list(queryWrapper);
+        if (functions.size() > 0) {
+            ThrowException.throwXiaoShiException("修改失败，该功能标识已被使用");
+        }
         try {
             Function function = new Function();
             function

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

@@ -4,6 +4,8 @@ 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.domain.TenantVipType;
+import com.baomidou.mybatisplus.extension.service.IService;
 import org.springframework.transaction.annotation.Transactional;
 
 /**
@@ -12,7 +14,7 @@ import org.springframework.transaction.annotation.Transactional;
  * @Author chenyu
  * @Date 2023/2/15
  */
-public interface ITenantVipTypeService {
+public interface ITenantVipTypeService extends IService<TenantVipType> {
     /**
      * 新增租户会员类型(包含对应的功能权限)
      *

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

@@ -7,6 +7,7 @@ import cn.cslg.permission.common.model.dto.TenantVipTypeFunctionUpdateDTO;
 import cn.cslg.permission.common.model.vo.FunctionVO2;
 import cn.cslg.permission.common.model.vo.TenantVO;
 import cn.cslg.permission.common.model.vo.TenantVipTypeFunctionVO;
+import cn.cslg.permission.common.utils.ThrowException;
 import cn.cslg.permission.domain.AssoTenantVipTypeAndFunction;
 import cn.cslg.permission.domain.FunctionIdPathNameDescription;
 import cn.cslg.permission.domain.TenantVipType;
@@ -16,6 +17,8 @@ import cn.cslg.permission.mapper.FunctionMapper;
 import cn.cslg.permission.mapper.TenantMapper;
 import cn.cslg.permission.mapper.TenantVipTypeMapper;
 import cn.cslg.permission.service.ITenantVipTypeService;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
 import lombok.RequiredArgsConstructor;
@@ -38,13 +41,11 @@ import java.util.stream.Collectors;
 @RequiredArgsConstructor
 @Slf4j
 @Service
-public class TenantVipTypeService implements ITenantVipTypeService {
+public class TenantVipTypeService extends ServiceImpl<TenantVipTypeMapper, TenantVipType> implements ITenantVipTypeService {
     private final TenantVipTypeMapper tenantVipTypeMapper;
     private final AssoTenantVipTypeFunctionMapper assoTenantVipTypeFunctionMapper;
     private final TenantMapper tenantMapper;
     private final FunctionMapper functionMapper;
-    //private final AssoTenantFunctionMapper assoTenantFunctionMapper;
-    //private final TenantFunctionService tenantFunctionService;
 
     /**
      * 新增租户会员类型(绑定对应的功能权限)
@@ -55,35 +56,31 @@ public class TenantVipTypeService implements ITenantVipTypeService {
     public void addNew(TenantVipTypeFunctionAddNewDTO tenantVipTypeFunctionAddNewDTO) {
         log.info("开始处理【新增租户会员类型】的业务，参数为：{}", tenantVipTypeFunctionAddNewDTO);
 
-        //检查租户会员类型名称是否已存在
+        //检查会员名称是否已存在
         String tenantVipName = tenantVipTypeFunctionAddNewDTO.getTenantVipName();
-        log.info("检查租户会员类型名称是否被占用");
+        log.info("检查会员名称是否已存在");
         int count = tenantVipTypeMapper.countByTenantVipName(tenantVipName);
         if (count > 0) {
-            String message = "新增租户会员类型失败，【" + tenantVipName + "】已存在，请尝试更换名称";
-            log.info("{}", message);
-            throw new XiaoShiException(message);
+            ThrowException.throwXiaoShiException("新增租户会员类型失败，会员名称【" + tenantVipName + "】已存在，请尝试更换名称");
         }
 
         //将DTO数据对象复制给实体类
         TenantVipType tenantVipType = new TenantVipType();
         BeanUtils.copyProperties(tenantVipTypeFunctionAddNewDTO, tenantVipType);
-        //是否启用属性暂时默认都设置为启用(禁用0 启用1)，若以后前端有需求再调整
+        //是否启用属性暂时默认都设置为启用(禁用0 启用1)，若以后有需求再调整
         tenantVipType.setCreateTime(new Date()).setEnable(1);
 
-        //数据插入租户会员类型表
-        log.info("数据插入租户会员类型表");
+        //数据入会员表
+        log.info("数据入会员表");
         int rows = tenantVipTypeMapper.insert(tenantVipType);
         if (rows != 1) {
-            String message = "数据插入租户会员类型表失败，新增租户会员类型失败，服务器忙请稍后再试";
-            log.info("{}", message);
-            throw new XiaoShiException(message);
+            ThrowException.throwXiaoShiException("数据插入租户会员类型表失败，新增租户会员类型失败，服务器忙请稍后再试");
         }
 
         Integer tenantVipTypeId = tenantVipType.getId();
-        //创建租户会员类型和功能关联表实体类集合，准备将集合进行批量插入租户会员类型和功能关联表
+        //创建会员和功能关联表实体类集合，准备批量插入关联表
         ArrayList<AssoTenantVipTypeAndFunction> assoTenantVipTypeAndFunctions = new ArrayList<>();
-        //从DTO对象中取出功能组件权限路径集合，遍历集合进行操作给租户会员类型和功能关联表实体类赋值
+        //从DTO中取出功能组件权限路径集合，遍历集合给会员和功能关联表实体类赋值
         List<String> functionModifyPaths = tenantVipTypeFunctionAddNewDTO.getFunctionModifyPaths();
         for (String functionModifyPath : functionModifyPaths) {
             //从功能组件树路径中提取出功能id
@@ -109,13 +106,11 @@ public class TenantVipTypeService implements ITenantVipTypeService {
 //                assoTenantVipTypeAndFunctions.add(assoTenantVipTypeAndFunction2);
 //            }
         }
-        //数据插入租户会员类型和功能关联表
+        //数据入会员和功能关联表
         log.info("数据插入租户会员类型和功能关联表");
         rows = assoTenantVipTypeFunctionMapper.insertBatch(assoTenantVipTypeAndFunctions);
         if (rows != assoTenantVipTypeAndFunctions.size()) {
-            String message = "数据插入租户会员类型和功能关联表失败，新增租户会员类型失败，服务器忙请稍后再试";
-            log.info("{}", message);
-            throw new XiaoShiException(message);
+            ThrowException.throwXiaoShiException("新增租户会员类型失败，数据入会员和功能关联表失败，服务器忙请稍后再试");
         }
 
         log.info("新增租户会员类型完成");
@@ -131,6 +126,7 @@ public class TenantVipTypeService implements ITenantVipTypeService {
     @Override
     public JsonPage queryTenantVipType(PageDTO2 pageDTO2) {
         log.info("开始处理【查询租户会员类型列表】的业务，参数为：{}", pageDTO2);
+
         Integer page = pageDTO2.getPage();
         Integer pageSize = pageDTO2.getPageSize();
         String likeName = pageDTO2.getLikeName();
@@ -183,30 +179,35 @@ public class TenantVipTypeService implements ITenantVipTypeService {
 
         //检查尝试修改的数据是否存在
         Integer tenantVipTypeId = tenantVipTypeFunctionUpdateDTO.getId();
+        String tenantVipName = tenantVipTypeFunctionUpdateDTO.getTenantVipName();
         log.info("检查尝试修改的数据是否存在");
         int count = tenantVipTypeMapper.countById(tenantVipTypeId);
         if (count == 0) {
-            String message = "尝试修改的数据已不存在，修改失败，尝试访问的数据已不存在";
-            log.info("{}", message);
-            throw new XiaoShiException(message);
+            ThrowException.throwXiaoShiException("修改失败，尝试访问的数据已不存在");
+        }
+
+        //检查尝试修改的名称是否已存在
+        LambdaQueryWrapper<TenantVipType> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(TenantVipType::getTenantVipName, tenantVipName).ne(TenantVipType::getId, tenantVipTypeId);
+        List<TenantVipType> tenantVipTypes = this.list(queryWrapper);
+        if (tenantVipTypes.size() > 0) {
+            ThrowException.throwXiaoShiException("修改租户会员类型失败，会员名称【" + tenantVipName + "】已存在，请尝试更换名称");
         }
 
-        //修改租户会员类型表数据
+        //修改会员表数据
         TenantVipType tenantVipType = new TenantVipType();
         BeanUtils.copyProperties(tenantVipTypeFunctionUpdateDTO, tenantVipType);
-        log.info("修改租户会员类型表数据");
+        log.info("修改会员表数据");
         int rows = tenantVipTypeMapper.updateById(tenantVipType);
         if (rows != 1) {
-            String message = "修改租户会员类型表数据失败，修改失败，服务器忙请稍后再试";
-            log.info("{}", message);
-            throw new XiaoShiException(message);
+            ThrowException.throwXiaoShiException("修改失败，修改会员表数据失败，服务器忙请稍后再试");
         }
 
-        //删除原有租户会员类型和功能关联表数据
-        log.info("删除原有租户会员类型和功能关联表数据");
+        //删除原有会员和功能关联表数据
+        log.info("删除原有会员和功能关联表数据");
         assoTenantVipTypeFunctionMapper.deleteByTenantVipTypeId(tenantVipTypeId);
 
-        //新数据入租户会员类型和功能关联表
+        //新数据入会员和功能关联表
         List<AssoTenantVipTypeAndFunction> assoTenantVipTypeAndFunctions = new ArrayList<>();
         List<String> functionModifyPaths = tenantVipTypeFunctionUpdateDTO.getFunctionModifyPaths();
         for (String functionModifyPath : functionModifyPaths) {
@@ -236,12 +237,10 @@ public class TenantVipTypeService implements ITenantVipTypeService {
 //                assoTenantVipTypeAndFunctions.add(assoTenantVipTypeAndFunction2);
 //            }
         }
-        log.info("新数据入租户会员类型和功能关联表");
+        log.info("新数据入会员和功能关联表");
         rows = assoTenantVipTypeFunctionMapper.insertBatch(assoTenantVipTypeAndFunctions);
         if (rows != functionModifyPaths.size()) {
-            String message = "数据插入新租户会员类型和功能关联表失败，修改失败，服务器忙请稍后再试";
-            log.info("{}", message);
-            throw new XiaoShiException(message);
+            ThrowException.throwXiaoShiException("修改失败，新数据入会员和功能关联表失败，服务器忙请稍后再试");
         }
 
         log.info("修改租户会员类型完成");
@@ -261,9 +260,7 @@ public class TenantVipTypeService implements ITenantVipTypeService {
         log.info("检查要删除的数据是否存在");
         int count = tenantVipTypeMapper.countById(id);
         if (count == 0) {
-            String message = "删除租户会员类型失败，尝试访问的数据已不存在";
-            log.info("{}", message);
-            throw new XiaoShiException(message);
+            ThrowException.throwXiaoShiException("删除租户会员类型失败，尝试访问的数据已不存在");
         }
 
         //检查该会员类型是否有租户使用
@@ -273,19 +270,17 @@ public class TenantVipTypeService implements ITenantVipTypeService {
             tenantMapper.updateByTenantVipType(id);
         }
 
-        //删除租户会员类型表数据
-        log.info("删除租户会员类型表数据");
+        //删除会员和功能关联表数据
+        log.info("删除会员和功能关联表数据");
+        assoTenantVipTypeFunctionMapper.deleteByTenantVipTypeId(id);
+
+        //删除会员表数据
+        log.info("删除会员表数据");
         int rows = tenantVipTypeMapper.deleteById(id);
         if (rows != 1) {
-            String message = "删除租户会员类型失败，服务器忙请稍后再试";
-            log.info("{}", message);
-            throw new XiaoShiException(message);
+            ThrowException.throwXiaoShiException("删除租户会员类型失败，服务器忙请稍后再试");
         }
 
-        //删除租户会员类型和功能关联表数据
-        log.info("删除租户会员类型和功能关联表数据");
-        assoTenantVipTypeFunctionMapper.deleteByTenantVipTypeId(id);
-
     }
 
 }