5/19 整理权限系统接口代码逻辑，添加注释与修改bug

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

@@ -66,6 +66,9 @@ public class FunctionVO extends BaseVO {
      */
     private Integer functionType;
 
+    /**
+     * 租户类型 1服务机构  非1企业
+     */
     private Integer type;
 
 }

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

@@ -103,6 +103,7 @@ public class PersonnelController {
         }
         return Response.success(true);
     }
+
     @PostMapping("/changePwd")
     @Operation(summary = "用户修改密码")
     public String changePwd(String oldPassword, String newPassword) {

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

@@ -38,16 +38,14 @@ public class RoleController {
     @PostMapping("/delete")
     @Operation(summary = "删除角色")
     public String deleteApplication(RoleVO roleVO) {
-
-        return  roleService.deleteRole(roleVO);
+        return roleService.deleteRole(roleVO);
     }
 
     @checkAuth(FunId = "/admin/role/modify")
     @PostMapping("/update")
     @Operation(summary = "修改角色")
     public String updateApplication(@RequestBody RoleVO roleVO) {
-  return roleService.updateRole(roleVO);
-
+        return roleService.updateRole(roleVO);
     }
 
     @checkAuth(FunId = "/admin/role/check")

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

@@ -13,6 +13,7 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.web.bind.annotation.*;
+
 @Slf4j
 @Tag(name = "租户管理")
 @RestController
@@ -26,11 +27,10 @@ public class TenantController {
     @Operation(summary = "新增租户")
     public String addApplication(@RequestBody TenantVO tenantVo) {
         Integer flag = tenantService.addTenant(tenantVo);
-        if(flag>0){
-            return  Response.success("租户新增成功");
-        }
-        else{
-            return  Response.success("租户管理员的账号已经存在");
+        if (flag > 0) {
+            return Response.success("租户新增成功");
+        } else {
+            return Response.error("租户管理员的账号已经存在");
         }
     }
 

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

@@ -1,6 +1,9 @@
 package cn.cslg.permission.domain;
 
+import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 import lombok.experimental.Accessors;
 
@@ -12,24 +15,29 @@ import java.io.Serializable;
  * @Author chenyu
  * @Data 2023/2/15
  */
+@TableName("ASSO_TENANTVIPTYPE_FUNCTION")
 @Accessors(chain = true)
 @Data
 public class AssoTenantVipTypeAndFunction implements Serializable {
     /**
      * 主键id
      */
+    @TableId(value = "id", type = IdType.AUTO)
     private Integer id;
     /**
      * 会员id
      */
+    @TableField(value = "TENANT_VIP_TYPE_ID")
     private Integer tenantVipTypeId;
     /**
      * 功能id
      */
+    @TableField(value = "FUNCTION_ID")
     private Integer functionId;
     /**
      * 功能编辑组件路径
      */
+    @TableField(value = "FUNCTION_MODIFY_PATH")
     private String functionModifyPath;
 
 }

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

@@ -83,6 +83,7 @@ public class DepartmentService extends ServiceImpl<DepartmentMapper, Department>
             }
             department.insert();
             if (department.getId() != null) {
+                //数据入部门角色关联表
                 departRoleService.addAssociateDepartRole(departmentVO.getRole(), department.getId());
             }
         } catch (Exception e) {
@@ -97,21 +98,19 @@ public class DepartmentService extends ServiceImpl<DepartmentMapper, Department>
         try {
             Department department = new Department();
             department.setId(departmentVO.getId());
-            department.deleteById();
+            //根据部门id，sql使用find_in_set查询部门表PATH，获得当前部门的所有子级部门列表
             List<Department> lst = departmentMapper.getDepartInPathById(department.getId());
-            if (lst.size() > 0) {
-                List<Integer> ids = new ArrayList<>();
-                lst.forEach(item -> ids.add(item.getId()));
-                this.removeByIds(ids);
-                ids.add(department.getId());
-                departRoleService.delAssociateDepartRole(null, null, ids);
-                departPosiService.deleteAssoDepartPosi(null, null, ids);
-                perDpService.deleteAssociatePerDp(null, null, null, ids);
-            } else {
-                departRoleService.delAssociateDepartRole(departmentVO.getId(), null, null);
-                departPosiService.deleteAssoDepartPosi(departmentVO.getId(), null, null);
-                perDpService.deleteAssociatePerDp(null, departmentVO.getId(), null, null);
-            }
+            List<Integer> ids = new ArrayList<>();
+            ids.add(department.getId());
+            lst.forEach(item -> ids.add(item.getId()));
+            //部门表删除所有当前部门及所有子级部门
+            this.removeByIds(ids);
+            //部门角色关联表删除所有关联关系
+            departRoleService.delAssociateDepartRole(null, null, ids);
+            //部门职位关联表删除所有关联关系
+            departPosiService.deleteAssoDepartPosi(null, null, ids);
+            //人员部门职位关联表删除所有关联关系
+            perDpService.deleteAssociatePerDp(null, null, null, ids);
         } catch (Exception e) {
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
             e.printStackTrace();
@@ -166,7 +165,7 @@ public class DepartmentService extends ServiceImpl<DepartmentMapper, Department>
     public String getTenantDepartments() {
         PersonnelVO personnelVO = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
         LambdaQueryWrapper<Department> queryWrapper = new LambdaQueryWrapper<>();
-            queryWrapper.eq(Department::getTenantId, personnelVO.getTenantId());
+        queryWrapper.eq(Department::getTenantId, personnelVO.getTenantId());
         List<Department> lst = this.list(queryWrapper);
         return Response.success(treeGenerate(lst));
     }
@@ -174,7 +173,7 @@ public class DepartmentService extends ServiceImpl<DepartmentMapper, Department>
     public String getDepartmentListForRMS() {
         PersonnelVO personnelVO = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
         LambdaQueryWrapper<Department> queryWrapper = new LambdaQueryWrapper<>();
-            queryWrapper.eq(Department::getTenantId, personnelVO.getTenantId());
+        queryWrapper.eq(Department::getTenantId, personnelVO.getTenantId());
         List<Department> lst = this.list(queryWrapper);
         return Response.success(treeGenerate(lst));
     }
@@ -212,6 +211,7 @@ public class DepartmentService extends ServiceImpl<DepartmentMapper, Department>
             lst.addAll(lstParent);//将所有数据放在一起来生成树需要的数据
         }
 
+        //装载树工具方法
         List<Tree<Integer>> tem = treeGenerate(lst);
 
         //分页

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

@@ -306,6 +306,7 @@ public class FunctionService extends ServiceImpl<FunctionMapper, Function> {
 //
 //        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("")) {

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

@@ -21,6 +21,7 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 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;
@@ -38,6 +39,7 @@ import java.util.stream.Collectors;
  * @description 人员类 Service 层
  */
 
+@Slf4j
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
@@ -51,11 +53,9 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
 
     @Transactional(rollbackFor = Exception.class)
     public Personnel addPersonnel(PersonnelVO personnelVO) {
-        Integer tenantId = personnelVO.getTenant();
-        if (tenantId == null) {
-            tenantId = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt()).getTenant();
-        }
-        Personnel personnel = new Personnel();
+        log.info("开始处理【新增人员】的业务，参数为：{}", personnelVO);
+
+        //检查用户名是否已存在
         LambdaQueryWrapper<Personnel> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(Personnel::getPersonnelUserName, personnelVO.getUsername());
         List<Personnel> personnelList = this.list(queryWrapper);
@@ -64,6 +64,52 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
             user.setPersonnelName("用户名已存在");
             return user;
         }
+
+        //判断若没有传租户id，则手动获取当前登陆人所属租户
+        Integer tenantId = personnelVO.getTenant();
+        if (tenantId == null) {
+            tenantId = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt()).getTenant();
+        }
+
+        //根据租户id统计人员表人员数量
+        LambdaQueryWrapper<Personnel> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.eq(Personnel::getTenantId, tenantId);
+        long count = this.count(lambdaQueryWrapper);
+        //根据租户id查询租户信息，取出租户账号配额
+        Tenant tenant = tenantService.getById(tenantId);
+        if (tenant != null) {
+            //判断若当前人员数量大于等于租户账号配额，则新增人员失败，超出配额
+            if (count >= tenant.getTenantQuota()) {
+                Personnel user = new Personnel();
+                user.setPersonnelName("超出配额");
+                return user;
+            }
+        }
+
+        //检查若选择了超级管理员角色，判断是否有选择系统管理员角色的权限
+        if (personnelVO.getAddType() == null) {
+            boolean flag = false; //判断是否有系统管理员角色
+            PersonnelVO localPer = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
+            List<PersonnelVO.PerRole> perRoles = localPer.getRList();
+            for (PersonnelVO.PerRole perRole : perRoles) {
+                if (perRole.getRoleId() == 1 && tenantId == 1) {
+                    flag = true;
+                    break;
+                }
+            }
+            if (personnelVO.getRole() != null) {
+                for (int i = 0; i < personnelVO.getRole().size(); i++) {
+                    if (personnelVO.getRole().get(i) == 1 && !flag) {
+                        Personnel user = new Personnel();
+                        user.setPersonnelName("没有设置系统管理员角色的权限");
+                        return user;
+                    }
+                }
+            }
+        }
+
+        //实体类装载数据
+        Personnel personnel = new Personnel();
         try {
             personnel.setPersonnelUserName(personnelVO.getUsername())
                     .setPersonnelName(personnelVO.getName())
@@ -77,46 +123,19 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
                     .setPersonnelUserSex(personnelVO.getGender())
                     .setTenantId(tenantId)
                     .setPersonnelPassword(personnelVO.getPassword());
+
+            //判断若添加类型为null，则手动获取登陆人id作为创建人id
             if (personnelVO.getAddType() == null) {
                 personnel.setCreateUser(StpUtil.getLoginIdAsInt());
             }
 
+            //判断若密码为null，则手动设置默认密码”123456“
             if (personnelVO.getPassword() != null) {
                 personnel.setPersonnelPassword(SecureUtil.md5(personnelVO.getPassword()));
             } else {
                 personnel.setPersonnelPassword(SecureUtil.md5("123456"));
             }
-            LambdaQueryWrapper<Personnel> lambdaQueryWrapper = new LambdaQueryWrapper<>();
-            lambdaQueryWrapper.eq(Personnel::getTenantId, personnelVO.getTenant());
-            long count = this.count(lambdaQueryWrapper);
-            Tenant tenant = tenantService.getById(personnelVO.getTenant());
-            if (tenant != null) {
-                if (count > tenant.getTenantQuota()) {
-                    Personnel user = new Personnel();
-                    user.setPersonnelName("超出配额");
-                    return user;
-                }
-            }
-            if (personnelVO.getAddType() == null) {
-                boolean flag = false; //判断是否有系统管理员角色
-                PersonnelVO localPer = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
-                List<PersonnelVO.PerRole> perRoles = localPer.getRList();
-                for (PersonnelVO.PerRole perRole : perRoles) {
-                    if (perRole.getRoleId() == 1 && tenantId == 1) {
-                        flag = true;
-                        break;
-                    }
-                }
-                if (personnelVO.getRole() != null) {
-                    for (int i = 0; i < personnelVO.getRole().size(); i++) {
-                        if (personnelVO.getRole().get(i) == 1 && !flag) {
-                            Personnel user = new Personnel();
-                            user.setPersonnelName("没有设置系统管理员角色的权限");
-                            return user;
-                        }
-                    }
-                }
-            }
+
             boolean suc = this.save(personnel);
             if (suc) {
                 if (personnelVO.getPositions() != null) {
@@ -138,19 +157,28 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
 
     @Transactional(rollbackFor = Exception.class)
     public String deletePersonnel(PersonnelVO personnelVO) {
+        log.info("开始处理【删除人员】的业务，参数为：{}", personnelVO.getId());
+
         try {
+            //根据人员id查询租户表
             LambdaQueryWrapper<Tenant> lambdaQueryWrapper = new LambdaQueryWrapper<>();
             lambdaQueryWrapper.eq(Tenant::getPersonnelId, personnelVO.getId());
             Tenant tenant = tenantService.getOne(lambdaQueryWrapper);
+            //判断若有租户则无法删除（说明该人员为租户的管理员账号）
             if (tenant != null) {
                 return Response.error("无法删除租户的管理员账号");
+                //若没有租户则可以删除（说明该人员为普通账号）
             } else {
+                //人员表删除数据（逻辑删除）
                 Personnel personnel = new Personnel();
                 personnel.setIsDelete(1);
                 personnel.setId(personnelVO.getId());
                 personnel.deleteById();
+                //人员与用户组关联表删除关联关系数据
                 personGroupService.delAssociatePerGroup(Collections.singletonList(personnelVO.getId()), null);
+                //人员与角色关联表删除关联关系数据
                 personRoleService.delAssociatePerRole(personnelVO.getId(), null);
+                //人员与部门与职位关联表删除关联关系数据
                 perDpService.deleteAssociatePerDp(personnelVO.getId(), null, null, null);
                 return Response.success(true);
             }
@@ -165,18 +193,7 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
     public Personnel updatePersonnel(PersonnelVO personnelVO) {
         Personnel personnel = new Personnel();
         try {
-            personnel.setPersonnelUserName(personnelVO.getUsername())
-                    .setPersonnelName(personnelVO.getName())
-                    .setPersonnelEmail(personnelVO.getEmail())
-                    .setPersonnelQQ(personnelVO.getQqNumber())
-                    .setPersonnelDing(personnelVO.getNail())
-                    .setPersonnelWechat(personnelVO.getWechat())
-                    .setPersonnelPhone(personnelVO.getMobile())
-                    .setPersonnelDescription(personnelVO.getRemark())
-                    .setPersonnelStatus(personnelVO.getState())
-                    .setPersonnelUserSex(personnelVO.getGender())
-                    .setTenantId(personnelVO.getTenant())
-                    .setId(personnelVO.getId());
+            //检查若选择了超级管理员角色，判断是否有选择系统管理员角色的权限
             boolean flag = false; //判断是否有系统管理员角色
             PersonnelVO localPer = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
             Integer tenantId = localPer.getTenantId();
@@ -197,6 +214,20 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
                 }
             }
 
+            //实体类装载数据
+            personnel.setPersonnelUserName(personnelVO.getUsername())
+                    .setPersonnelName(personnelVO.getName())
+                    .setPersonnelEmail(personnelVO.getEmail())
+                    .setPersonnelQQ(personnelVO.getQqNumber())
+                    .setPersonnelDing(personnelVO.getNail())
+                    .setPersonnelWechat(personnelVO.getWechat())
+                    .setPersonnelPhone(personnelVO.getMobile())
+                    .setPersonnelDescription(personnelVO.getRemark())
+                    .setPersonnelStatus(personnelVO.getState())
+                    .setPersonnelUserSex(personnelVO.getGender())
+                    .setTenantId(personnelVO.getTenant())
+                    .setId(personnelVO.getId());
+
             if (personnelVO.getPassword() != null) {
                 personnel.setPersonnelPassword(personnelVO.getPassword());
             } else {
@@ -204,14 +235,18 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
                 personnel.setPersonnelPassword(personnel1.getPersonnelPassword());
             }
             if (personnelVO.getPositions() != null) {
+                //人员与部门与职位关联表修改数据
                 perDpService.updateAssociatePerDp(personnelVO.getPositions(), personnel.getId());
             }
             if (personnelVO.getRole() != null) {
+                //人员与角色关联表修改数据
                 personRoleService.updateAssociatePerRole(personnelVO.getRole(), personnel.getId());
             }
             if (personnelVO.getGroup() != null) {
+                //人员与用户组关联表修改数据
                 personGroupService.updateAssociatePerGroup(personnelVO.getGroup(), Collections.singletonList(personnel.getId()));
             }
+            //人员表修改数据
             personnel.updateById();
             //更新完成后更新redis里登录信息(角色)
             List<RoleVO> roleVOList = personRoleService.getRoleListByPersonnelId(personnel.getId());
@@ -242,14 +277,20 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
 
 
     public String getPersonnelList(int roleId) {
+        //获取登陆人信息
         PersonnelVO personnelVO = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
+
         LambdaQueryWrapper<Personnel> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(Personnel::getPersonnelStatus, 1);
-        //TODO 代码控制只能查看本租户内容
+
+        //TODO 代码控制若不是超级管理员则只能查看本租户的人员列表
         if (personnelVO.getRoleType() == null || personnelVO.getRoleType() != 1) {
             queryWrapper.eq(Personnel::getTenantId, personnelVO.getTenantId());
         }
 
+        //查询人员状态为启用的人员列表
+        queryWrapper.eq(Personnel::getPersonnelStatus, 1);
+
+        //若前台有传角色id，则不查该角色对应的人员列表 ？？？
         if (roleId != 0) {
             LambdaQueryWrapper<AssoPersonRole> wrapper = new LambdaQueryWrapper<>();
             wrapper.eq(AssoPersonRole::getRoleId, roleId);
@@ -267,22 +308,26 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
 
 
     public String queryPageList(PersonnelVO personnelVO) {
+        //获取登陆人信息
         PersonnelVO personnelVO1 = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
+
         LambdaQueryWrapper<Personnel> queryWrapper = new LambdaQueryWrapper<>();
+        //TODO 代码控制若不是超级管理员则只能查看本租户的人员列表
+        if (personnelVO1.getRoleType() == null || personnelVO1.getRoleType() != 1) {
+            queryWrapper.eq(Personnel::getTenantId, personnelVO1.getTenantId());
+        }
+
+        //根据人员名称或是人员描述模糊查询人员列表
         if (personnelVO.getName() == null) {
             personnelVO.setName("");
         }
         queryWrapper
-                .and((wrapper) ->
-                        wrapper.like(Personnel::getPersonnelName, personnelVO.getName())
-                                .or()
-                                .like(Personnel::getPersonnelDescription, personnelVO.getName())
+                .and((wrapper) -> wrapper.like(Personnel::getPersonnelName, personnelVO.getName())
+                        .or()
+                        .like(Personnel::getPersonnelDescription, personnelVO.getName())
                 );
-        //TODO 代码控制只能查看本租户内容
-        if (personnelVO1.getRoleType() == null || personnelVO1.getRoleType() != 1) {
-            queryWrapper.eq(Personnel::getTenantId, personnelVO1.getTenantId());
-        }
 
+        //若前台有传部门ids，则根据部门ids查询人员列表
         if (personnelVO.getDepartmentIds() != null && personnelVO.getDepartmentIds().size() != 0) {
             LambdaQueryWrapper<AssoDepartPos> qw = new LambdaQueryWrapper<>();
             qw.in(AssoDepartPos::getDepartmentId, personnelVO.getDepartmentIds());
@@ -294,6 +339,7 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
             queryWrapper.in(Personnel::getId, perIds);
         }
 
+        //若前台有传职位ids，则根据职位ids查询人员列表
         if (personnelVO.getPositionIds() != null && personnelVO.getPositionIds().size() != 0) {
             LambdaQueryWrapper<AssoDepartPos> qw = new LambdaQueryWrapper<>();
             qw.in(AssoDepartPos::getPositionId, personnelVO.getPositionIds());
@@ -306,6 +352,7 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
             queryWrapper.in(Personnel::getId, perIds);
         }
 
+        //若前台有传租户id，则根据租户id查询人员列表
         if (personnelVO.getTenant() != null) {
             queryWrapper.eq(Personnel::getTenantId, personnelVO.getTenant());
         }
@@ -318,9 +365,11 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
     }
 
     public List<Integer> getByTenantId(Integer tenantId) {
+        //根据租户id查询人员列表
         LambdaQueryWrapper<Personnel> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(Personnel::getTenantId, tenantId);
         List<Personnel> personnelList = this.list(queryWrapper);
+        //遍历人员列表，装载人员ids
         List<Integer> ids = new ArrayList<>();
         personnelList.forEach(item -> ids.add(item.getId()));
         return ids;
@@ -356,12 +405,16 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
     }
 
     public String changePwd(String oldPassword, String newPassword) {
+        //获取登陆人id
         Integer userId = StpUtil.getLoginIdAsInt();
+        //根据登陆人id查询人员信息
         Personnel personnel = this.getById(userId);
+        //判断前台传来的用户输入的原密码是否正确，若不正确则修改失败返回错误提示“旧密码错误”
         boolean isPassword = SecureUtil.md5(oldPassword).equals(personnel.getPersonnelPassword());
         if (!isPassword) {
             return Response.error("旧密码错误");
         }
+        //修改密码，修改人员表数据
         personnel.setPersonnelPassword(SecureUtil.md5(newPassword));
         personnel.updateById();
         return Response.success(true);
@@ -373,14 +426,14 @@ public class PersonnelService extends ServiceImpl<PersonnelMapper, Personnel> {
         PersonnelVO localPer = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
         Personnel personnel = this.getById(StpUtil.getLoginIdAsInt());
         try {
-          personnel.setPersonnelName(personnelVO.getName());
-          personnel.setPersonnelPhone(personnelVO.getMobile());
-          personnel.setPersonnelEmail(personnelVO.getEmail());
+            personnel.setPersonnelName(personnelVO.getName());
+            personnel.setPersonnelPhone(personnelVO.getMobile());
+            personnel.setPersonnelEmail(personnelVO.getEmail());
             if (personnelVO.getPassword() != null) {
                 personnel.setPersonnelPassword(personnelVO.getPassword());
                 localPer.setPassword(personnelVO.getPassword());
             }
-            if(personnelVO.getGender()!=null){
+            if (personnelVO.getGender() != null) {
                 personnel.setPersonnelUserSex(personnelVO.getGender());
             }
             personnel.updateById();

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

@@ -17,6 +17,7 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 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;
@@ -31,6 +32,7 @@ import java.util.List;
  * @description 职位类 Service 层
  */
 
+@Slf4j
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class PositionService extends ServiceImpl<PositionMapper, Position> {
@@ -42,17 +44,25 @@ public class PositionService extends ServiceImpl<PositionMapper, Position> {
 
     @Transactional(rollbackFor = Exception.class)
     public String addPosition(PositionVO positionVO) {
+        log.info("开始处理【新增职位】的业务，参数为：{}", positionVO);
+
         try {
-                LambdaQueryWrapper<Position> lambdaQueryWrapper = new LambdaQueryWrapper<>();
-                lambdaQueryWrapper.eq(Position::getPositionName, positionVO.getPosition()).eq(Position::getTenantId, positionVO.getTenant());
-                if(!positionVO.getIsmore().equals(1)){
-                    lambdaQueryWrapper.eq(Position::getPositionIsOnly,1);
-                }
-
-                List<Position> positionList = this.list(lambdaQueryWrapper);
-                if (positionList.size() > 0) {
-                    return Response.error("职位名称已存在");
-                }
+            LambdaQueryWrapper<Position> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+
+            //检查职位是否已存在
+            //根据职位名称和租户id查询职位表，若该职位是否唯一字段为1即唯一，则再根据该字段查询职位表
+            lambdaQueryWrapper.eq(Position::getPositionName, positionVO.getPosition()).eq(Position::getTenantId, positionVO.getTenant());
+            if (!positionVO.getIsmore().equals(1)) {
+                lambdaQueryWrapper.eq(Position::getPositionIsOnly, 1);
+            }
+
+            //若有数据则新增失败，返回错误提示“职位名称已存在”
+            List<Position> positionList = this.list(lambdaQueryWrapper);
+            if (positionList.size() > 0) {
+                return Response.error("职位名称已存在");
+            }
+
+            //实体类装载数据
             Position position = new Position();
             position
                     .setPositionName(positionVO.getPosition())
@@ -62,6 +72,7 @@ public class PositionService extends ServiceImpl<PositionMapper, Position> {
             position.insert();
 
             if (position.getId() != null) {
+                //关联数据入职位与角色关联表
                 positionRoleService.addPositionRole(position.getId(), positionVO.getRole());
             }
         } catch (Exception e) {
@@ -73,13 +84,18 @@ public class PositionService extends ServiceImpl<PositionMapper, Position> {
 
     @Transactional(rollbackFor = Exception.class)
     public void deletePosition(PositionVO positionVO) {
+        log.info("开始处理【删除职位】的业务，参数为：{}", positionVO.getId());
+
         try {
+            //根据id删除职位表数据
             Position position = new Position();
             position.setId(positionVO.getId());
             position.deleteById();
-
+            //根据职位id删除职位与角色关联表数据
             positionRoleService.deletePositionRole(positionVO.getId(), null);
+            //根据职位id删除职位与部门关联表数据
             departPosiService.deleteAssoDepartPosi(null, positionVO.getId(), null);
+            //根据职位id删除人员与职位与部门关联表数据
             perDpService.deleteAssociatePerDp(null, null, positionVO.getId(), null);
         } catch (Exception e) {
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
@@ -89,6 +105,8 @@ public class PositionService extends ServiceImpl<PositionMapper, Position> {
 
     @Transactional(rollbackFor = Exception.class)
     public void updatePosition(PositionVO positionVO) {
+        log.info("开始处理【修改职位】的业务，参数为：{}", positionVO);
+
         try {
             Position position = new Position();
             position
@@ -98,6 +116,7 @@ public class PositionService extends ServiceImpl<PositionMapper, Position> {
             position.updateById();
 
             if (position.getId() != null) {
+                //修改职位与角色关联表数据
                 positionRoleService.updatePositionRole(position.getId(), positionVO.getRole());
             }
         } catch (Exception e) {
@@ -107,8 +126,12 @@ public class PositionService extends ServiceImpl<PositionMapper, Position> {
     }
 
     public String getPositionList() {
+        //获取登陆人信息
         PersonnelVO personnelVO = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
+
         LambdaQueryWrapper<Position> queryWrapper = new LambdaQueryWrapper<>();
+
+        //若当前登陆人不是超级管理员角色，则只能查看本租户内容
         if (personnelVO.getRoleType() == null || personnelVO.getRoleType() != 1) {
             //TODO 代码控制只能查看本租户内容
             queryWrapper.eq(Position::getTenantId, personnelVO.getTenantId());
@@ -119,18 +142,27 @@ public class PositionService extends ServiceImpl<PositionMapper, Position> {
     }
 
     public String queryPageList(PositionVO positionVO) {
+        //获取登陆人信息
         PersonnelVO personnelVO = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
+
         LambdaQueryWrapper<Position> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.and((wrapper) -> wrapper.like(Position::getPositionName, positionVO.getName())
-                .or()
-                .like(Position::getPositionDescription, positionVO.getName()));
+
+        //若当前登陆人不是超级管理员角色，则只能查看本租户内容
         if (personnelVO.getRoleType() == null || personnelVO.getRoleType() != 1) {
             //TODO 代码控制只能查看本租户内容
             queryWrapper.eq(Position::getTenantId, personnelVO.getTenantId());
         }
+
+        //根据职位名称或是职位描述模糊查询职位列表
+        queryWrapper.and((wrapper) -> wrapper.like(Position::getPositionName, positionVO.getName())
+                .or()
+                .like(Position::getPositionDescription, positionVO.getName()));
+
+        //若前台有传租户id则根据租户id查询职位列表
         if (positionVO.getTenant() != null) {
             queryWrapper.eq(Position::getTenantId, positionVO.getTenant());
         }
+
         SecurityUtils.startDataScope("/admin/position/check");
         List<Position> positionList = this.page(new Page<>(positionVO.getCurrent(), positionVO.getSize()), queryWrapper).getRecords();
         SecurityUtils.startDataScope("/admin/position/check");

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

@@ -14,7 +14,9 @@ import cn.dev33.satoken.stp.StpUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.sun.xml.internal.bind.v2.TODO;
 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;
@@ -29,6 +31,7 @@ import java.util.List;
  * @description 角色类 Service 层
  */
 
+@Slf4j
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class RoleService extends ServiceImpl<RoleMapper, Role> {
@@ -42,14 +45,18 @@ public class RoleService extends ServiceImpl<RoleMapper, Role> {
 
     @Transactional(rollbackFor = Exception.class)
     public void addRole(RoleVO roleVO) {
+        log.info("开始处理【新增角色】的业务，参数为：{}", roleVO);
+
         try {
             Role role = new Role();
             role
                     .setRoleName(roleVO.getName())
                     .setRoleDescription(roleVO.getRemark())
                     .setTenantId(roleVO.getTenant());
+            //数据入角色表
             role.insert();
             roleVO.setId(role.getId());
+            //数据入角色功能关联表
             roleFunctionDataService.add(roleVO);
         } catch (Exception e) {
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
@@ -59,29 +66,33 @@ public class RoleService extends ServiceImpl<RoleMapper, Role> {
 
     @Transactional(rollbackFor = Exception.class)
     public String deleteRole(RoleVO roleVO) {
+        log.info("开始处理【删除角色】的业务，参数为：{}", roleVO);
+
         try {
-            //根据角色id查询角色
- Integer roleType =this.getRoleType(roleVO.getId());
-            if(roleType.equals(1)){
+            //根据角色id查询角色，获得角色类型 （用于判断是否为管理员：1为系统管理员 2为租户管理员 0为普通角色）
+            Integer roleType = this.getRoleType(roleVO.getId());
+            //若为超级管理员或租户管理员则无法删除，返回错误提示
+            if (roleType.equals(1)) {
                 return Response.error("无法删除系统管理员");
+            } else if (roleType.equals(2)) {
+                return Response.error("无法删除租户管理员");
             }
-            else if(roleType.equals(2)){
-                return  Response.error("无法删除租户管理员");
-            }
+
+            //根据id删除角色表数据
             Role role = new Role();
             role.setId(roleVO.getId());
             role.deleteById();
 
             //删除关联表数据
-            //三关联
+            //角色功能数据权限关联表删除数据
             roleFunctionDataService.delete(roleVO.getId(), null, null, null);
-            //用户组角色
+            //用户组角色关联表删除数据
             userGroupRoleService.deleteUserGroupRole(null, roleVO.getId());
-            //人员角色
+            //人员角色关联表删除数据
             personRoleService.delAssociatePerRole(null, roleVO.getId());
-            //职位角色
+            //职位角色关联表删除数据
             positionRoleService.deletePositionRole(null, roleVO.getId());
-            //部门角色
+            //部门角色关联表删除数据
             departRoleService.delAssociateDepartRole(null, roleVO.getId(), null);
             return Response.success("删除成功");
         } catch (Exception e) {
@@ -93,13 +104,16 @@ public class RoleService extends ServiceImpl<RoleMapper, Role> {
 
     @Transactional(rollbackFor = Exception.class)
     public String updateRole(RoleVO roleVO) {
+        log.info("开始处理【修改角色】的业务，参数为：{}", roleVO);
+
         try {
-            Integer roleType =this.getRoleType(roleVO.getId());
-            if(roleType.equals(1)){
+            //根据角色id查询角色，获得角色类型 （用于判断是否为管理员：1为系统管理员 2为租户管理员 0为普通角色）
+            Integer roleType = this.getRoleType(roleVO.getId());
+            //若为超级管理员或租户管理员则无法修改，返回错误提示
+            if (roleType.equals(1)) {
                 return Response.error("无法修改系统管理员");
-            }
-            else if(roleType.equals(2)){
-                return  Response.error("无法修改租户管理员");
+            } else if (roleType.equals(2)) {
+                return Response.error("无法修改租户管理员");
             }
             Role role = new Role();
             role
@@ -107,6 +121,8 @@ public class RoleService extends ServiceImpl<RoleMapper, Role> {
                     .setRoleName(roleVO.getName())
                     .setId(roleVO.getId());
             role.updateById();
+
+            //角色功能数据权限关联表修改数据
             roleFunctionDataService.updateRoleFunctionData(roleVO);
             return Response.success("角色修改成功");
         } catch (Exception e) {
@@ -116,10 +132,15 @@ public class RoleService extends ServiceImpl<RoleMapper, Role> {
         return Response.success("角色修改成功");
     }
 
-    public String getRoleList() { //获取用户信息
+    public String getRoleList() {
+        //获取登陆人信息
         PersonnelVO personnelVO = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
+
         LambdaQueryWrapper<Role> queryWrapper = new LambdaQueryWrapper<>();
+
+        //若当前登陆人不是超级管理员角色，则只能查看本租户内容
         if (personnelVO.getRoleType() == null || personnelVO.getRoleType() != 1) {
+            //TODO 代码控制只能查看本租户内容
             queryWrapper.eq(Role::getTenantId, personnelVO.getTenantId()).last(" AND ID <> 1");
         }
         SecurityUtils.startDataScope("/admin/role/check");
@@ -128,22 +149,28 @@ public class RoleService extends ServiceImpl<RoleMapper, Role> {
     }
 
     public String queryPageList(RoleVO roleVO) {
-        //获取用户信息
+        //获取登陆人信息
         PersonnelVO personnelVO = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
+
         LambdaQueryWrapper<Role> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper
-                .and((wrapper) ->
-                        wrapper
-                                .like(Role::getRoleName, roleVO.getName())
-                                .or()
-                                .like(Role::getRoleDescription, roleVO.getName())
-                );
+
+        //TODO 代码控制只能查看本租户内容
         if (personnelVO.getRoleType() == null || personnelVO.getRoleType() != 1) {
             queryWrapper.eq(Role::getTenantId, personnelVO.getTenantId()).last(" AND ID <> 1");
         }
+
+        //根据角色名称或是角色描述模糊查询角色列表
+        queryWrapper.and((wrapper) -> wrapper
+                .like(Role::getRoleName, roleVO.getName())
+                .or()
+                .like(Role::getRoleDescription, roleVO.getName())
+        );
+
+        //若前台有传租户id则根据租户id查询角色列表
         if (roleVO.getTenant() != null) {
             queryWrapper.eq(Role::getTenantId, roleVO.getTenant());
         }
+
         SecurityUtils.startDataScope("/admin/role/check");
         List<Role> roleList = this.page(new Page<>(roleVO.getCurrent(), roleVO.getSize()), queryWrapper).getRecords();
         if (personnelVO.getRoleType() == null || personnelVO.getRoleType() != 1) {
@@ -178,9 +205,9 @@ public class RoleService extends ServiceImpl<RoleMapper, Role> {
         return roleVOS;
     }
 
-    private Integer getRoleType(Integer roleId){
-     Role role = this.getById(roleId);
-     return role.getRoleType();
+    private Integer getRoleType(Integer roleId) {
+        Role role = this.getById(roleId);
+        return role.getRoleType();
 
     }
 

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

@@ -54,16 +54,21 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
     private final RoleService roleService;
     private final SysDictItemMapper sysDictItemMapper;
     private final MessageUtils mailUtils;
+
     @Transactional(rollbackFor = Exception.class)
     public Integer addTenant(TenantVO tenantVO) {
+        log.info("开始处理【新增租户】的业务，参数为：{}", tenantVO);
+
         Personnel personnel = new Personnel();
 
+        //检查管理员账号是否已存在
         LambdaQueryWrapper<Personnel> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(Personnel::getPersonnelUserName, tenantVO.getUsername());
         List<Personnel> personnelList = personnelService.list(queryWrapper);
         if (personnelList.size() != 0) {
             return -1;
         }
+
         //租户表保存租户信息
         Tenant tenant = new Tenant();
         tenant
@@ -79,15 +84,18 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
         if (tenantVO.getAddType() == null) {
             tenant.setCreateUser(StpUtil.getLoginIdAsInt());
         }
+        //数据入租户表
         boolean suc = tenant.insert();
+
         if (suc) {
-            //更新客户
+            //更新客户表数据
             if (tenantVO.getClientId() != null && tenantVO.getClientId() > 0) {
                 Client client = clientService.getById(tenantVO.getClientId());
                 client.setTenantId(tenant.getId());
                 client.updateById();
             }
-            //保存管理员用户
+
+            //更新人员表数据，保存管理员用户
             PersonnelVO personnelVO1 = new PersonnelVO();
             personnelVO1
                     .setUsername(tenantVO.getUsername())
@@ -134,11 +142,13 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
                 }
         );
 
+        //数据入角色功能数据权限关联表
         RoleVO roleVO = new RoleVO();
         roleVO.setTenant(tenant.getId());
         roleVO.setName(tenantVO.getName() + "管理员");
         roleVO.setRemark("管理租户下所拥有的功能");
         roleVO.setPermissionData(permissions);
+        //数据入角色表
         Role role = new Role();
         role
                 .setRoleName(roleVO.getName())
@@ -146,8 +156,13 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
                 .setTenantId(roleVO.getTenant())
                 .setRoleType(2);
         role.insert();
+
+        //数据入角色表后拿到角色id，装载角色id
         roleVO.setId(role.getId());
+        //数据入角色功能数据权限关联表
         roleFunctionDataService.add(roleVO);
+
+        //数据入角色人员关联表
         List<Integer> roles = new ArrayList<>();
         roles.add(role.getId());
         personRoleService.addAssociatePerRole(roles, personnel.getId());
@@ -156,14 +171,21 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
 
     @Transactional(rollbackFor = Exception.class)
     public void deleteTenant(TenantVO tenantVO) {
+        log.info("开始处理【删除租户】的业务，参数为：{}", tenantVO.getId());
+
         try {
             Tenant tenant = new Tenant();
             Integer tenantId = tenantVO.getId();
             tenant.setId(tenantId);
+            //根据id删除租户
             tenant.deleteById();
+
+            //删除关联数据
             UpdateWrapper<Client> wrapper = new UpdateWrapper<>();
             wrapper.set("TENANT_ID", null).eq("TENANT_ID", tenant.getId());
+            //客户表更新数据
             clientService.update(wrapper);
+            //删除和租户有关的所有关联表数据
             deleteService.deleteTenantAsso(tenantId);
         } catch (Exception e) {
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
@@ -173,6 +195,8 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
 
     @Transactional(rollbackFor = Exception.class)
     public void updateTenant(TenantVO tenantVO) {
+        log.info("开始处理【修改租户】的业务，参数为：{}", tenantVO);
+
         try {
             //修改租户
             Tenant tenant = new Tenant();
@@ -188,12 +212,14 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
                     .setPersonnelId(tenantVO.getPersonnelId())
                     .setId(tenantVO.getId());
             tenant.updateById();
+
             //修改人员
             PersonnelVO personnelVO1 = new PersonnelVO();
             personnelVO1.setUsername(tenantVO.getUsername());
             personnelVO1.setPassword(tenantVO.getPassword());
             personnelVO1.setId(tenant.getPersonnelId());
             personnelService.updatePersonnel(personnelVO1);
+
             //修改关联客户
             //更新客户
             if (tenantVO.getClientId() != null && tenantVO.getClientId() > 0) {
@@ -204,6 +230,8 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
                 client.setTenantId(tenant.getId());
                 client.updateById();
             }
+
+            //更新部门
             LambdaQueryWrapper<Department> lambdaQueryWrapper = new LambdaQueryWrapper<>();
             lambdaQueryWrapper
                     .eq(Department::getTenantId, tenant.getId());
@@ -218,6 +246,8 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
 
     public String getTenantList() {
         LambdaQueryWrapper<Tenant> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+
+        //根据租户状态(1启用0停用)查询启用的租户列表
         lambdaQueryWrapper.eq(Tenant::getTenantStatus, 1);
         SecurityUtils.startDataScope("/admin/client/check");
         List<Tenant> tenantPeople = this.list(lambdaQueryWrapper);
@@ -226,6 +256,8 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
 
     public String queryPageList(TenantVO tenantVO) {
         LambdaQueryWrapper<Tenant> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+
+        //根据租户名称或是租户联系地址或是租户描述模糊查询租户列表
         lambdaQueryWrapper.and((wrapper) -> wrapper.like(Tenant::getTenantName, tenantVO.getName())
                 .or()
                 .like(Tenant::getTenantAddress, tenantVO.getName())
@@ -395,17 +427,22 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
 
     @Transactional(rollbackFor = Exception.class)
     public void addByInvitation3(TenantVO tenantVo) {
-        //根据验证码查询是否存在
+        log.info("开始处理【根据邀请码添加租户】的业务，参数为：{}", tenantVo);
+
+        //检查邀请码是否存在
         LambdaQueryWrapper<Invitation> wrapper = new LambdaQueryWrapper<>();
         wrapper.eq(Invitation::getInvitation, tenantVo.getInvitation());
         List<Invitation> invitations = invitationService.list(wrapper);
         if (invitations == null || invitations.size() == 0) {
             ThrowException.throwXiaoShiException("邀请码不存在");
         }
+
+        //检查邀请码是否有效（1无效 0有效）
         Invitation invitation = invitations.get(0);
         if (invitation.getIsInvalid().equals(1)) {
             ThrowException.throwXiaoShiException("邀请码已被使用");
         }
+
         //邀请码表更新信息
         //地址
         invitation.setAddress(tenantVo.getAddress());
@@ -419,30 +456,32 @@ public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
         invitation.setName(tenantVo.getName());
         invitation.setIsInvalid(1);
         invitation.updateById();
-       //从字典表里获得配置联系人数
-        LambdaQueryWrapper<SysDictItem> wrapper1 =new LambdaQueryWrapper<>();
-        wrapper1.eq(SysDictItem::getDictParentKey,"ADMIN_EMAIL");
-       List<SysDictItem> sysDictItems= sysDictItemMapper.selectList(wrapper1);
-       sysDictItems.forEach(item->{
-           Map<String, Object> map = new LinkedHashMap<>();
-           map.put("title", "激活码审核通知");
-           map.put("template", "mail/adminEmail.html");
-           map.put("value1", item.getDictChildLabel());
-           map.put("img", "/logo.png");
-           map.put("email", item.getDictChildValue());
-           map.put("value2",invitation.getInvitation());
-           map.put("value3",invitation.getName());
-           map.put("value4",invitation.getContacts());
-           map.put("value5",invitation.getEmail());
-           map.put("value6",invitation.getPhoneNumber());
-           map.put("value7",invitation.getAddress());
-           mailUtils.sendEmailMessage(map);
-       });
+
+        //从字典表里获得配置联系人数
+        LambdaQueryWrapper<SysDictItem> wrapper1 = new LambdaQueryWrapper<>();
+        wrapper1.eq(SysDictItem::getDictParentKey, "ADMIN_EMAIL");
+        List<SysDictItem> sysDictItems = sysDictItemMapper.selectList(wrapper1);
+        sysDictItems.forEach(item -> {
+            Map<String, Object> map = new LinkedHashMap<>();
+            map.put("title", "激活码审核通知");
+            map.put("template", "mail/adminEmail.html");
+            map.put("value1", item.getDictChildLabel());
+            map.put("img", "/logo.png");
+            map.put("email", item.getDictChildValue());
+            map.put("value2", invitation.getInvitation());
+            map.put("value3", invitation.getName());
+            map.put("value4", invitation.getContacts());
+            map.put("value5", invitation.getEmail());
+            map.put("value6", invitation.getPhoneNumber());
+            map.put("value7", invitation.getAddress());
+            mailUtils.sendEmailMessage(map);
+        });
 
     }
 
     public Invitation queryByInvitation(String invitation) {
         log.info("开始处理【根据邀请码查询租户】的业务，参数为：{}", invitation);
+
         LambdaQueryWrapper<Invitation> wrapper = new LambdaQueryWrapper<>();
         wrapper.eq(Invitation::getInvitation, invitation);
         List<Invitation> invitations = invitationService.list(wrapper);

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

@@ -86,12 +86,15 @@ public class UserGroupService extends ServiceImpl<UserGroupMapper, UserGroup> {
     @Transactional(rollbackFor = Exception.class)
     public void deleteUserGroup(UserGroupVO userGroupVO) {
         try {
+            //用户组角色关联表删除关联关系
+            userGroupRoleService.deleteUserGroupRole(userGroupVO.getId(), null);
+            //用户组人员关联表删除关联关系
+            personGroupService.delAssociatePerGroup(null, Collections.singletonList(userGroupVO.getId()));
+
+            //用户组表删除数据
             UserGroup userGroup = new UserGroup();
             userGroup.setId(userGroupVO.getId());
             userGroup.deleteById();
-
-            userGroupRoleService.deleteUserGroupRole(userGroupVO.getId(), null);
-            personGroupService.delAssociatePerGroup(null, Collections.singletonList(userGroupVO.getId()));
         } catch (Exception e) {
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
             e.printStackTrace();
@@ -142,20 +145,24 @@ public class UserGroupService extends ServiceImpl<UserGroupMapper, UserGroup> {
             queryWrapper.eq(UserGroup::getTenantId, personnelVO.getTenantId());
         }
         SecurityUtils.startDataScope("/admin/group/check");
-        List<UserGroup> userGroupList = this.list();
+        List<UserGroup> userGroupList = this.list(queryWrapper);
         return Response.success(setUserGroupToVO(userGroupList));
     }
 
     public String queryPageList(UserGroupVO userGroupVO) {
+        //获取登陆人信息
         PersonnelVO personnelVO = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
+        //根据用户组名称或用户组描述模糊查询用户组列表
         LambdaQueryWrapper<UserGroup> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.and((wrapper) -> wrapper.like(UserGroup::getUserGroupName, userGroupVO.getName())
                 .or()
                 .like(UserGroup::getUserGroupDescription, userGroupVO.getName()));
+        //判断若登陆人不是超级管理员角色，则只能查看本租户的用户组列表
         if (personnelVO.getRoleType() == null || personnelVO.getRoleType() != 1) {
             //TODO 代码控制只能查看本租户内容
             queryWrapper.eq(UserGroup::getTenantId, personnelVO.getTenantId());
         }
+        //判断若租户id有值，则本次是查询指定租户下的用户组列表
         if (userGroupVO.getTenant() != null) {
             queryWrapper.eq(UserGroup::getTenantId, userGroupVO.getTenant());
         }

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

@@ -53,19 +53,24 @@ public class PersonRoleService extends ServiceImpl<AssoPersonRoleMapper, AssoPer
     @Transactional(rollbackFor = Exception.class)
     public void addAssociatePerRoleByRole(RoleVO roleVO) {
         try {
+            //创建人员角色关联表实体类集合
             List<AssoPersonRole> assoPersonRoles = new ArrayList<>();
             if (roleVO.getPersonnelIds() != null) {
+                //遍历人员ids
                 roleVO.getPersonnelIds().forEach(
                         item -> {
+                            //创建人员角色关联表实体类
                             AssoPersonRole assoPersonRole = new AssoPersonRole();
                             if (roleVO.getId() != null) {
                                 assoPersonRole.setRoleId(roleVO.getId());
                             }
                             assoPersonRole.setPersonnelId(item);
+                            //实体类添加进实体类集合
                             assoPersonRoles.add(assoPersonRole);
                         }
                 );
             }
+            //数据批量入人员角色关联表
             this.saveBatch(assoPersonRoles);
         } catch (Exception e) {
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();