Merge branch 'hongdongbao'

src/main/java/com/cmeeting/controller/SysUseSyncController.java

+package com.cmeeting.controller;
+
+import com.cmeeting.service.ISysUserSyncCategoryService;
+import com.cmeeting.service.SysUserSyncService;
+import com.cmeeting.util.R;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.annotation.Resource;
+
+@RestController
+@RequestMapping("/user/sync")
+public class SysUseSyncController {
+
+    @Value("${permission.tenantId}")
+    private String tenantId;
+    @Resource
+    private ISysUserSyncCategoryService iSysUserSyncCategoryService;
+    @Resource
+    private SysUserSyncService iSysUserSyncService;
+
+    @GetMapping("/category/tree")
+    public R tree() {
+        return R.ok(iSysUserSyncCategoryService.tree(tenantId));
+    }
+    @GetMapping("/list")
+    public R list(@RequestParam String categoryId, @RequestParam Integer current, @RequestParam Integer size, String search) {
+        return R.ok(iSysUserSyncService.selectPage(current, size, categoryId, tenantId, search));
+    }
+
+}

src/main/java/com/cmeeting/dto/SysUserSyncDTO.java

+package com.cmeeting.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Builder
+public class SysUserSyncDTO {
+    private String userId;
+    private String name;
+    private String email;
+    private String deptId;
+    private String department;
+    private Boolean enable = true;
+}

src/main/java/com/cmeeting/mapper/secondary/SysUserSysMapper.java

 package com.cmeeting.mapper.secondary;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.cmeeting.ad.entity.SysDept;
 import com.cmeeting.ad.entity.SysUserSync;
 import com.cmeeting.dto.PermissionCheckedDTO;
+import com.cmeeting.dto.SysUserSyncDTO;
 import com.cmeeting.dto.UserDTO;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
@@ -34,4 +36,7 @@ public interface SysUserSysMapper  extends BaseMapper<SysUserSync> {
 
     List<PermissionCheckedDTO.User> findByParam(@Param("userIds") List<String> userIds, @Param("notInCateIds") List<String> notInCateIds, @Param("cateIds") List<String> shareCateIds,
                                                 @Param("tenantId") String tenantId, @Param("search") String search, @Param("categoryId") String categoryId);
+
+    Page<SysUserSyncDTO> selectByDeptId(@Param("deptIds") List<String> deptIds, @Param("tenantId") String tenantId,
+                                        @Param("page") Page page, @Param("search") String search);
 }

src/main/java/com/cmeeting/service/ISysUserSyncCategoryService.java

@@ -16,4 +16,6 @@ import java.util.Map;
 public interface ISysUserSyncCategoryService extends IService<SysUserSyncCategory> {
 
     String getPath(String deptId, Map<String, String> map);
+
+    List<Tree<String>> tree(String tenantId);
 }

src/main/java/com/cmeeting/service/ModulePermissionService.java

@@ -25,4 +25,12 @@ public interface ModulePermissionService extends IService<ModulePermission> {
     List<PermissionCheckedDTO.User> personalCancelList();
 
     Boolean personalSwitch(String userId, boolean enable);
+
+    /**
+     * 校验权限
+     * return为List的时候需要判断relId为all的情况
+     */
+    List<ModulePermission> checkPermission(List<String> deptIds, String userId);
+    List<Long> checkPermission(List<String> deptIds, String userId, Integer purpose);
+    Boolean checkPermission(List<String> deptIds, String userId, Integer purpose, Long targetId);
 }

src/main/java/com/cmeeting/service/SysUserSyncService.java

 package com.cmeeting.service;
 
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.cmeeting.ad.entity.RobotSecurityUser;
 import com.cmeeting.ad.entity.SysUserSync;
 import com.cmeeting.dto.PermissionCheckedDTO;
+import com.cmeeting.dto.SysUserSyncDTO;
 
 import java.util.List;
 
@@ -16,4 +18,6 @@ public interface SysUserSyncService extends IService<SysUserSync> {
     List<PermissionCheckedDTO.User> findInUserIdsOrShareCateIds(List<String> userIds, List<String> shareCateIds, String tenantId, String search);
 
     List<PermissionCheckedDTO.User> findByParam(List<String> userIds, List<String> notInCateIds, List<String> shareCateIds, String tenantId, String search, String categoryId);
+
+    Page<SysUserSyncDTO> selectPage(Integer current, Integer size, String categoryId, String tenantId, String search);
 }

src/main/java/com/cmeeting/service/impl/ModulePermissionServiceImpl.java

@@ -2,6 +2,7 @@ package com.cmeeting.service.impl;
 
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.cmeeting.ad.entity.RobotSecurityUser;
@@ -11,6 +12,7 @@ import com.cmeeting.constant.PermissionPruposeType;
 import com.cmeeting.constant.RecordTemplateConstant;
 import com.cmeeting.constant.UserTypeConstant;
 import com.cmeeting.dto.PermissionCheckedDTO;
+import com.cmeeting.exception.RobotBaseException;
 import com.cmeeting.pojo.ModulePermission;
 import com.cmeeting.service.IShareUserService;
 import com.cmeeting.service.ModulePermissionService;
@@ -28,13 +30,13 @@ import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 /**
-* @author Administrator
-* @description 针对表【module_permission(权限表)】的数据库操作Service实现
-* @createDate 2025-07-17 10:55:32
-*/
+ * @author Administrator
+ * @description 针对表【module_permission(权限表)】的数据库操作Service实现
+ * @createDate 2025-07-17 10:55:32
+ */
 @Service
 public class ModulePermissionServiceImpl extends ServiceImpl<ModulePermissionMapper, ModulePermission>
-    implements ModulePermissionService{
+        implements ModulePermissionService {
 
     @Resource
     private SysUserSyncService iSysUserSyncService;
@@ -199,6 +201,43 @@ public class ModulePermissionServiceImpl extends ServiceImpl<ModulePermissionMap
         }
     }
 
+    @Override
+    public List<ModulePermission> checkPermission(List<String> deptIds, String userId) {
+        return this.list(new LambdaQueryWrapper<ModulePermission>()
+                .and(e -> e.eq(ModulePermission::getType, RecordTemplateConstant.REL_TYPE_DEPT).in(ModulePermission::getRelId, deptIds)
+                        .or().eq(ModulePermission::getType, RecordTemplateConstant.REL_TYPE_USER).eq(ModulePermission::getRelId, userId))
+                .select(ModulePermission::getTargetId)
+        );
+    }
+
+    @Override
+    public List<Long> checkPermission(List<String> deptIds, String userId, Integer purpose) {
+        List<ModulePermission> list = this.list(new LambdaQueryWrapper<ModulePermission>()
+                .eq(ModulePermission::getPurpose, purpose)
+                .and(e -> e.eq(ModulePermission::getType, RecordTemplateConstant.REL_TYPE_DEPT).in(ModulePermission::getRelId, deptIds)
+                        .or().eq(ModulePermission::getType, RecordTemplateConstant.REL_TYPE_USER).eq(ModulePermission::getRelId, userId)
+                        .or().eq(ModulePermission::getType, RecordTemplateConstant.REL_TYPE_USER).eq(ModulePermission::getRelId, CategoryConstant.ALL_EN)
+                ).select(ModulePermission::getTargetId)
+        );
+        return list.stream().map(ModulePermission::getTargetId).collect(Collectors.toList());
+    }
+
+    @Override
+    public Boolean checkPermission(List<String> deptIds, String userId, Integer purpose, Long targetId) {
+        boolean flag = purpose.equals(PermissionPruposeType.TEMPLATE_TYPE_PERMISSION) || purpose.equals(PermissionPruposeType.TEMPLATE_PERMISSION);
+        if (flag && targetId != null) {
+            throw new RobotBaseException("param error!");
+        }
+        return baseMapper.selectCount(new LambdaQueryWrapper<ModulePermission>()
+                .eq(ModulePermission::getPurpose, purpose)
+                .eq(targetId != null, ModulePermission::getTargetId, targetId)
+                .and(e -> e.eq(ModulePermission::getType, RecordTemplateConstant.REL_TYPE_DEPT).in(ModulePermission::getRelId, deptIds)
+                        .or().eq(ModulePermission::getType, RecordTemplateConstant.REL_TYPE_USER).eq(ModulePermission::getRelId, userId)
+                        .or().eq(ModulePermission::getType, RecordTemplateConstant.REL_TYPE_USER).eq(ModulePermission::getRelId, CategoryConstant.ALL_EN)
+                ).select(ModulePermission::getTargetId)) > 0;
+    }
+
+
 }
 
 

src/main/java/com/cmeeting/service/impl/SysUserSyncCategoryServiceImpl.java

 package com.cmeeting.service.impl;
 
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.lang.tree.Tree;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.cmeeting.constant.CategoryConstant;
 import com.cmeeting.mapper.secondary.SysUserSyncCategoryMapper;
 import com.cmeeting.pojo.SysUserSyncCategory;
 import com.cmeeting.service.ISysUserSyncCategoryService;
+import com.cmeeting.util.CategoryTreeUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 @Slf4j
 @Service
@@ -25,4 +32,25 @@ public class SysUserSyncCategoryServiceImpl extends ServiceImpl<SysUserSyncCateg
         }
         return getPath(map.get(id), map) + CategoryConstant.ROOT_PATH + id;
     }
+
+    @Override
+    public List<Tree<String>> tree(String tenantId) {
+        List<SysUserSyncCategory> sysUserSyncCategories = baseMapper.selectList(new LambdaQueryWrapper<SysUserSyncCategory>().eq(SysUserSyncCategory::getTenantId, tenantId));
+        if(CollUtil.isNotEmpty(sysUserSyncCategories)){
+            Set<String> set = sysUserSyncCategories.stream().map(SysUserSyncCategory::getDeptId).collect(Collectors.toSet());
+            for (SysUserSyncCategory sysUserSyncCategory : sysUserSyncCategories) {
+                if(!set.contains(sysUserSyncCategory.getParentId())){
+                    sysUserSyncCategory.setParentId(CategoryTreeUtil.ALL);
+                }
+            }
+        }
+        SysUserSyncCategory top = SysUserSyncCategory.builder()
+                .id(CategoryTreeUtil.ALL)
+                .deptId(CategoryTreeUtil.ALL)
+                .name(CategoryTreeUtil.NAME)
+                .parentId(CategoryConstant.ROOT_ID).build();
+        sysUserSyncCategories.add(top);
+        CategoryTreeUtil<SysUserSyncCategory> util = new CategoryTreeUtil<>();
+        return util.build(sysUserSyncCategories);
+    }
 }

src/main/java/com/cmeeting/service/impl/SysUserSyncServiceImpl.java

@@ -3,16 +3,23 @@ package com.cmeeting.service.impl;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.StrUtil;
 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.cmeeting.ad.entity.RobotSecurityUser;
 import com.cmeeting.ad.entity.SysUserSync;
 import com.cmeeting.constant.CategoryConstant;
+import com.cmeeting.constant.PermissionPruposeType;
+import com.cmeeting.constant.RecordTemplateConstant;
 import com.cmeeting.constant.UserTypeConstant;
 import com.cmeeting.dto.PermissionCheckedDTO;
+import com.cmeeting.dto.SysUserSyncDTO;
 import com.cmeeting.mapper.secondary.SysUserSysMapper;
+import com.cmeeting.pojo.ModulePermission;
 import com.cmeeting.pojo.SysUserSyncCategory;
 import com.cmeeting.service.ISysUserSyncCategoryService;
+import com.cmeeting.service.ModulePermissionService;
 import com.cmeeting.service.SysUserSyncService;
+import com.cmeeting.util.CategoryTreeUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Value;
@@ -35,6 +42,8 @@ public class SysUserSyncServiceImpl extends ServiceImpl<SysUserSysMapper, SysUse
 
     @Resource
     private ISysUserSyncCategoryService iSysUserSyncCategoryService;
+    @Resource
+    private ModulePermissionService modulePermissionService;
 
     @Override
     public String getDeptPathByUserId(String userId) {
@@ -46,17 +55,17 @@ public class SysUserSyncServiceImpl extends ServiceImpl<SysUserSysMapper, SysUse
 
     /**
      * 向上获取某个部门的路径
+     *
      * @param deptId
      */
-    private String getDeptPath(String deptPath,String deptId) {
-        String parentDeptId = baseMapper.getParentDeptId(deptId,perTenantId);
-        if(StringUtils.isEmpty(parentDeptId)) return deptPath;
+    private String getDeptPath(String deptPath, String deptId) {
+        String parentDeptId = baseMapper.getParentDeptId(deptId, perTenantId);
+        if (StringUtils.isEmpty(parentDeptId)) return deptPath;
 
         return "/" + parentDeptId + deptPath;
     }
 
 
-
     @Override
     public PermissionCheckedDTO listByCategoryId(String categoryId, String search, String tenantId, List<String> categoryList, List<String> userList) {
         PermissionCheckedDTO dto = new PermissionCheckedDTO();
@@ -116,7 +125,7 @@ public class SysUserSyncServiceImpl extends ServiceImpl<SysUserSysMapper, SysUse
                     List<String> sysUserSyncIdList = sysUserSyncList.stream().map(SysUserSync::getUserId).collect(Collectors.toList());
                     userList.addAll(sysUserSyncIdList);
                 }
-                if(CollUtil.isNotEmpty(userList)){
+                if (CollUtil.isNotEmpty(userList)) {
                     users = baseMapper.findName(null, null, search, tenantId, userList);
                 } else {
                     users = new ArrayList<>();
@@ -144,6 +153,39 @@ public class SysUserSyncServiceImpl extends ServiceImpl<SysUserSysMapper, SysUse
         return baseMapper.findByParam(userIds, notInCateIds, shareCateIds, tenantId, search, categoryId);
     }
 
+    @Override
+    public Page<SysUserSyncDTO> selectPage(Integer current, Integer size, String deptId, String tenantId, String search) {
+        Page page = new Page(current, size);
+        List<String> deptIds = new ArrayList<>();
+        if (StrUtil.isNotBlank(deptId) && !deptId.equals(CategoryTreeUtil.ALL)) {
+            deptIds.add(deptId);
+            List<SysUserSyncCategory> categoryList = iSysUserSyncCategoryService.list(new LambdaQueryWrapper<SysUserSyncCategory>()
+                    .eq(SysUserSyncCategory::getTenantId, tenantId)
+                    .select(SysUserSyncCategory::getDeptId, SysUserSyncCategory::getParentId));
+            Map<String, List<String>> collect = categoryList.stream()
+                    .collect(Collectors.groupingBy(SysUserSyncCategory::getParentId, Collectors.mapping(SysUserSyncCategory::getDeptId, Collectors.toCollection(ArrayList::new))));
+            deptIds.addAll(getChildren(collect, deptId));
+        }
+        Page<SysUserSyncDTO> retPage = baseMapper.selectByDeptId(deptIds, tenantId, page, search);
+        List<SysUserSyncDTO> records = retPage.getRecords();
+        if (CollUtil.isNotEmpty(records)) {
+            List<ModulePermission> list = modulePermissionService.list(new LambdaQueryWrapper<ModulePermission>()
+                    .eq(ModulePermission::getType, RecordTemplateConstant.REL_TYPE_USER)
+                    .eq(ModulePermission::getUserType, UserTypeConstant.SYNC)
+                    .eq(ModulePermission::getPurpose, PermissionPruposeType.PERSONAL_CLOSE)
+                    .in(ModulePermission::getRelId, records.stream().map(SysUserSyncDTO::getUserId).collect(Collectors.toList()))
+                    .select(ModulePermission::getRelId)
+            );
+            Set<String> set = list.stream().map(ModulePermission::getRelId).collect(Collectors.toSet());
+            for (SysUserSyncDTO record : records) {
+                if (set.contains(record.getUserId())) {
+                    record.setEnable(false);
+                }
+            }
+        }
+        return retPage;
+    }
+
     private List<String> getChildren(Map<String, List<String>> collect, String deptId) {
         List<String> ids = new ArrayList<>();
         if (collect.containsKey(deptId)) {

src/main/java/com/cmeeting/util/CategoryTreeUtil.java

+package com.cmeeting.util;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.lang.tree.Tree;
+import cn.hutool.core.lang.tree.TreeNode;
+import cn.hutool.core.lang.tree.TreeUtil;
+import cn.hutool.core.map.MapUtil;
+import com.cmeeting.constant.CategoryConstant;
+import com.cmeeting.pojo.SysUserSyncCategory;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author hongdongbao
+ */
+public class CategoryTreeUtil<T> {
+
+    public static final String ALL = "all";
+    public static final String ROOT = "ROOT";
+    public static final String NAME = "全部";
+
+
+    public List<Tree<String>> build(List<T> qaCategory) {
+        List<TreeNode<String>> nodeList = new ArrayList<>();
+        for (T t : qaCategory) {
+            nodeList.add(getTreeNode(t));
+        }
+        return TreeUtil.build(nodeList, CategoryConstant.ROOT_ID);
+    }
+
+    private TreeNode<String> getTreeNode(T data) {
+        TreeNode<String> treeNode = new TreeNode<>();
+        BeanUtil.copyProperties(data, treeNode);
+        HashMap<String, Object> extra = MapUtil.newHashMap();
+        if (data instanceof SysUserSyncCategory) {
+            SysUserSyncCategory category = (SysUserSyncCategory) data;
+            treeNode.setId(category.getDeptId());
+            extra.put("path", category.getPath());
+            extra.put("categoryId", category.getId());
+            extra.put("parentId", category.getParentId());
+            extra.put("sortNo", category.getSortNo());
+            extra.put("tenantId", category.getTenantId());
+        } else {
+            // TODO 新的分类
+        }
+        treeNode.setExtra(extra);
+        return treeNode;
+    }
+
+    /**
+     * 根据分类id和parentId的map集合获取分类id和path的map集合
+     *
+     * @param deptIdAndPatentIdMap 分类id和parentId的map集合
+     * @return 分类id和path的map集合
+     */
+    public static Map<String, String> getPathMap(Map<String, String> deptIdAndPatentIdMap) {
+        Map<String, String> pathMap = new HashMap<>();
+        for (String deptId : deptIdAndPatentIdMap.keySet()) {
+            String path = getPath(deptIdAndPatentIdMap, deptId);
+            pathMap.put(deptId, path);
+        }
+        return pathMap;
+    }
+
+    /**
+     * 获取 分类的path
+     * @param deptIdAndPatentIdMap
+     * @param deptId
+     * @return path
+     */
+    public static String getPath(Map<String, String> deptIdAndPatentIdMap, String deptId) {
+        if (deptIdAndPatentIdMap.containsKey(deptId)) {
+            return getPath(deptIdAndPatentIdMap, deptIdAndPatentIdMap.get(deptId)) + CategoryConstant.ROOT_PATH + deptId;
+        } else {
+            return "";
+        }
+    }
+}

src/main/resources/mapper/secondary/SysUserSysMapper.xml

@@ -129,4 +129,20 @@
             </foreach>
         </if>
     </select>
+    <select id="selectByDeptId" resultType="com.cmeeting.dto.SysUserSyncDTO">
+        select DISTINCT t1.*
+        from sys_user_sync t1
+        <if test="deptIds!=null and deptIds.size > 0">
+            inner join sys_user_sync_category t2
+            on t1.dept_id = t2.dept_id
+            and t2.dept_id in
+            <foreach collection="deptIds" open="(" close=")" item="id" separator=",">
+                #{id}
+            </foreach>
+        </if>
+        where t1.tenant_id = #{tenantId}
+        <if test="search!=null and search!=''">
+            and (t1.user_id like concat('%',#{search},'%') or t1.name like concat('%',#{search},'%') or t1.nick_name like concat('%',#{search},'%'))
+        </if>
+    </select>
 </mapper>
\ No newline at end of file