java-insagent-pc/src/main/java/com/ydtech/modules/admin/service/impl/SysDeptServiceImpl.java

package com.ydtech.modules.admin.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ydtech.core.page.HttpResult;
import com.ydtech.core.page.PageRequest;
import com.ydtech.core.page.PageResult;
import com.ydtech.exception.SystemException;
import com.ydtech.modules.admin.dao.SysAreaMapper;
import com.ydtech.modules.admin.dao.SysDeptMapper;
import com.ydtech.modules.admin.dao.SysUserDeptRelationshipMapper;
import com.ydtech.modules.admin.dao.SysUserMapper;
import com.ydtech.modules.admin.model.SysArea;
import com.ydtech.modules.admin.model.SysDept;
import com.ydtech.modules.admin.model.po.SysUserDeptRelationship;
import com.ydtech.modules.admin.model.report.financialReceivables.FinancialReceivablesMonthVo;
import com.ydtech.modules.admin.model.vo.*;
import com.ydtech.modules.admin.model.SysUser;
import com.ydtech.modules.admin.model.po.SysUserTreeShowLevel;
import com.ydtech.modules.admin.service.SysAreaService;
import com.ydtech.modules.admin.service.SysDeptService;
import com.ydtech.modules.admin.service.SysUserTreeShowLevelService;
import com.ydtech.modules.base.controller.BaseController;
import com.ydtech.modules.protocol.utils.AssertionUtils;
import com.ydtech.utils.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;


@Service
public class SysDeptServiceImpl extends ServiceImpl<SysDeptMapper, SysDept>
        implements SysDeptService {

    @Autowired
    private SysDeptMapper sysDeptMapper;

    @Autowired
    private SysAreaService sysAreaService;

    @Autowired
    private SysAreaMapper sysAreaMapper;

    @Autowired
    private SysUserTreeShowLevelService sysUserTreeShowLevelService;
    @Autowired
    private SysUserMapper sysUserMapper;

    @Autowired
    private SysUserDeptRelationshipMapper sysUserDeptRelationshipMapper;





    /**
     * 根据用户权限和指定部门ID，查询并构建部门树。
     *
     * @param deptId           部门ID，用于查询特定部门及其子部门，如果为空或特定值，则查询用户所在部门及其子部门。
     * @param managementSource 管理范围来源标识，用于不同场景下的部门树构建。
     * @return 返回符合用户权限和管理范围的部门树列表。
     */
    @Override
    public List<SysDept> findTree(String deptId, String managementSource) {
        // 获取当前操作用户
        SysUser user = BaseController.getUser();
        String userId = user.getId();

        // 根据用户ID查询用户的部门树展示级别
        LambdaQueryWrapper<SysUserTreeShowLevel> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(SysUserTreeShowLevel::getUserId, userId);
        SysUserTreeShowLevel treeShowLevel = sysUserTreeShowLevelService.getOne(lambdaQueryWrapper);

        List<SysDept> treeByShowLevel = new ArrayList<>();
        //如果当前用户未配置树展示等级，则默认为查询全部
        if (Objects.isNull(treeShowLevel)) {
            treeShowLevel = new SysUserTreeShowLevel();
            treeShowLevel.setShowLevel("subordinate");
        }
        // 如果指定的部门ID为空或特定值，则使用当前用户所在部门ID
        if (null == deptId || "".equals(deptId) || "undefined".equals(deptId)) {
            if (!treeShowLevel.getShowLevel().equals("all")) {
                deptId = user.getDeptId();
            } else {
                deptId = "9";
            }
        }

        // 根据用户的部门树展示级别查询相应的部门树
        switch (treeShowLevel.getShowLevel()) {
            case "all":
                treeByShowLevel = findTreeByShowLevel(deptId, managementSource, "all");
                break;
            case "same":
                treeByShowLevel = findTreeByShowLevel(deptId, managementSource, "same");
                break;
            case "subordinate":
                treeByShowLevel = findTreeByShowLevel(deptId, managementSource, "subordinate");
                break;
        }
        return treeByShowLevel;
    }

    private List<SysDept> findTreeByShowLevel(String deptId, String managementSource, String showLevel) {
        SysDept sysDept = getById(deptId);
        LambdaQueryWrapper<SysDept> lqw = new LambdaQueryWrapper<>();
        lqw.eq(SysDept::getDelFlag, 0);
        lqw.likeRight(SysDept::getId, deptId);
        lqw.orderByAsc(SysDept::getOrderNum);
        List<SysDept> sysDeptList = list(lqw);
        //判断机构来源条件 进行遍历
        if (null != managementSource && !"undefined".equals(managementSource) && !"".equals(managementSource)) {
            lqw.eq(SysDept::getManagementSource, managementSource);
            //条件
            List<SysDept> conditionList = list(lqw);
            Map<String, List<SysDept>> conditionMap = conditionList.stream().collect(Collectors.groupingBy(SysDept::getParentId));
            Map<String, List<SysDept>> map = conditionList.stream().collect(Collectors.groupingBy(SysDept::getParentId));
            //先查第6层
            conditionList.forEach(i ->
                    i.setChildren(map.getOrDefault(i.getId(), new ArrayList<>()))
            );
            List<SysDept> result = new ArrayList<>();
            //再查前4层
            int level = 5;
            while (level > 0) {
                List<SysDept> resultTmp = recursion(sysDeptList, conditionMap);
                if (resultTmp.size() == 0) {
                    break;
                } else {
                    int finalLevel = level;
                    resultTmp = resultTmp.stream().filter(x -> x.getComlevel().equals(String.valueOf(finalLevel))).collect(Collectors.toList());
                    result.clear();
                    result.addAll(resultTmp);
                }
                conditionMap = result.stream().collect(Collectors.groupingBy(SysDept::getParentId));
                level--;
            }
            sysDeptList = result;
        } else {
            Map<String, List<SysDept>> map = sysDeptList.stream().collect(Collectors.groupingBy(SysDept::getParentId));
            sysDeptList.forEach(i -> {
                i.setChildren(map.getOrDefault(i.getId(), new ArrayList<>()));
                i.setDeptCount(i.getChildren().size());
            });
            sysDeptList = map.get(sysDept.getParentId());
        }

        if (showLevel.equals("same")) {
            if (null != managementSource && !"undefined".equals(managementSource) && !"".equals(managementSource)) {
                if (sysDept.getManagementSource().equals(managementSource)) {
                    sysDeptList.clear();
                    sysDeptList.add(sysDept);
                } else {
                    return new ArrayList<>();
                }
            } else {
                sysDeptList.clear();
                sysDeptList.add(sysDept);
            }
        }
        return sysDeptList;
    }


    private List<SysDept> recursion(List<SysDept> sysDeptList, Map<String, List<SysDept>> conditionMap) {
        List<SysDept> result = new ArrayList<>();
        sysDeptList.forEach(i ->
                conditionMap.forEach((key, value) -> {
                    if (i.getId().equals(key)) {
                        if (i.getChildren() == null) {
                            i.setChildren(new ArrayList<>());
                        }
                        i.getChildren().addAll(value);
                        //处理总部的排序为空造成的空指针报错处理  add by   hxl
                        i.setOrderNum(i.getOrderNum() == null ? 0 : i.getOrderNum());
                        result.add(i);
                    }
                })
        );
        result.sort(Comparator.comparing(SysDept::getOrderNum));
        return result;
    }

    @Override
    public List<SysDept> getUserList(String deptId) {
        SysDept sysDept = getById(deptId);
        LambdaQueryWrapper<SysDept> lqw = new LambdaQueryWrapper<>();
        lqw.eq(SysDept::getDelFlag, 0);
        lqw.likeRight(SysDept::getId, deptId);
        List<SysDept> sysDeptList = list(lqw);
        Map<String, List<SysDept>> map = sysDeptList.stream().collect(Collectors.groupingBy(SysDept::getParentId));
        return map.get(sysDept.getParentId());
    }

    @Override
    @Transactional
    public void addDept(SysDeptVo sysDeptVo) {
        SysDept sysDept = new SysDept();
        BeanUtils.copyProperties(sysDeptVo, sysDept);
        String comlevel = ObjectUtils.isEmpty(sysDept.getComlevel()) ? "" : sysDept.getComlevel();
        String parentId = sysDept.getParentId();

        String number;
        if (comlevel.equals("2")) {
            AssertionUtils.isStringEmpty(sysDept.getProvince(), "二级机构份必填");
            number = sysDept.getProvince().substring(0, 2);
        } else if (comlevel.equals("3")) {
            AssertionUtils.isStringEmpty(sysDept.getCity(), "三级机构市必填");
            number = sysDept.getCity().substring(0, 4);
        } else if (comlevel.equals("4")) {
            AssertionUtils.isStringEmpty(sysDept.getArea(), "四级机构区必填");
            number = sysDept.getArea().substring(0, 6);
        } else {
            String deptType = "";

            if ("C".equals(sysDept.getDeptType()) && comlevel.equals("5")) {
                sysDeptVo.setDeptType("M");
            } else if ("D".equals(sysDept.getDeptType())) {
                sysDeptVo.setDeptType("D");
                deptType = "M";
            }

            String maxId = baseMapper.getMaxId(sysDept.getParentId(), deptType);
            if (!maxId.equals("0")) {
                String substring = maxId.substring(sysDept.getParentId().length() + 1);
                int i = Integer.parseInt("1" + substring) + 1;
                number = String.valueOf(i);
            } else {
                number = "101";
            }
        }

        String substring = number.substring(number.length() - 2);
        String serialNumber;
        if ("M,D".contains(sysDeptVo.getDeptType())) {
            serialNumber = parentId + sysDeptVo.getDeptType() + substring;
        } else {
            serialNumber = parentId + substring;
        }

        sysDept.setId(serialNumber);

        SysDept dept = getById(sysDept.getId());
        if (!ObjectUtils.isEmpty(dept)) {
            throw new SystemException("机构编号为:" + dept.getId() + " " + dept.getName() + "已被占用");
        }
        SysDept parentDept = baseMapper.selectById(sysDept.getParentId());

        if (parentDept.getComlevel().equals("5")) {
            sysDept.setManagementSource(parentDept.getManagementSource());
        }

        // 查询当前部门序号是否存在
        LambdaQueryWrapper<SysDept> qw = new LambdaQueryWrapper<>();
        qw.eq(SysDept::getDelFlag, 0);  // 删除标志为未删除
        qw.eq(SysDept::getParentId, sysDept.getParentId()); // 父级部门ID相同
        qw.eq(SysDept::getOrderNum, sysDept.getOrderNum());  // 排序号相同
        boolean exists = baseMapper.exists(qw);

        if (exists) {
            // 如果存在，查询该父级部门下排序号大于当前部门的部门列表
            LambdaQueryWrapper<SysDept> lqw = new LambdaQueryWrapper<>();
            lqw.eq(SysDept::getDelFlag, 0); // 删除标志为未删除
            lqw.eq(SysDept::getParentId, sysDept.getParentId()); // 父级部门ID相同
            lqw.ge(SysDept::getOrderNum, sysDept.getOrderNum());  // 排序号大于等于当前部门
            List<SysDept> sysDeptList = list(lqw);
            // 更新这些部门的排序号
            sysDeptList.forEach(i -> {
                i.setOrderNum(i.getOrderNum() + 1);
                updateById(i);
            });
        }

        boolean b = save(sysDept);
        AssertionUtils.isSucceed(b, "删除失败");
    }

    @Override
    @Transactional
    public HttpResult updateDept(SysDept record) {
        // 查询修改的序号是否存在
        LambdaQueryWrapper<SysDept> qw = new LambdaQueryWrapper<>();
        qw.eq(SysDept::getDelFlag, 0);  // 删除标志为未删除
        qw.eq(SysDept::getParentId, record.getParentId()); // 父级部门ID相同
        qw.eq(SysDept::getOrderNum, record.getOrderNum());  // 排序号相同
        boolean exists = baseMapper.exists(qw);
        //不存在则直接修改
        if (!exists) {
            baseMapper.updateById(record);
            return HttpResult.ok();
        }

        //查询机构
        SysDept sysDept = getById(record.getId());
        //原本的序号
        Integer orderNum = sysDept.getOrderNum();
        //本次修改的序号
        Integer newOrderNum = record.getOrderNum();
        // 向上换位
        if (newOrderNum < orderNum) {
            // 查询该父级部门下排序号大于当前部门的部门列表
            LambdaQueryWrapper<SysDept> lqw = new LambdaQueryWrapper<>();
            lqw.eq(SysDept::getDelFlag, 0); // 删除标志为未删除
            lqw.eq(SysDept::getParentId, record.getParentId()); // 父级部门ID相同
            lqw.ge(SysDept::getOrderNum, record.getOrderNum());  // 排序号大于等于当前部门
            List<SysDept> sysDeptList = list(lqw);
            sysDeptList.sort(Comparator.comparing(SysDept::getOrderNum));
            for (SysDept dept : sysDeptList) {
                dept.setOrderNum(dept.getOrderNum() + 1);
                updateById(dept);
                if (dept.getOrderNum().equals(orderNum)) {
                    break;
                }
            }
            baseMapper.updateById(record);
        }
        //向下换位
        if (newOrderNum > orderNum) {
            // 查询该父级部门下排序号小于当前部门的部门列表
            LambdaQueryWrapper<SysDept> lqw = new LambdaQueryWrapper<>();
            lqw.eq(SysDept::getDelFlag, 0); // 删除标志为未删除
            lqw.eq(SysDept::getParentId, record.getParentId()); // 父级部门ID相同
            lqw.le(SysDept::getOrderNum, record.getOrderNum());  // 排序号大于等于当前部门
            List<SysDept> sysDeptList = list(lqw);
            sysDeptList.sort(Comparator.comparing(SysDept::getOrderNum).reversed());
            for (SysDept dept : sysDeptList) {
                dept.setOrderNum(dept.getOrderNum() - 1);
                updateById(dept);
                if (dept.getOrderNum().equals(orderNum)) {
                    break;
                }
            }
            baseMapper.updateById(record);
        }
        if (newOrderNum.equals(orderNum)) {
            baseMapper.updateById(record);
        }
        return HttpResult.ok();
    }


    @Override
    public void deleteDept(SysDeptRemoveVo sysDeptRemoveVo) {
        SysDept sysDept = getById(sysDeptRemoveVo.getDeptId());
        List<SysDept> list = lambdaQuery().eq(SysDept::getParentId, sysDept.getId()).list();
        if (list.isEmpty()) {
            boolean b = removeById(sysDeptRemoveVo.getDeptId());
            AssertionUtils.isSucceed(b, "删除失败");
        } else {
            throw new SystemException(sysDept.getName() + "下还有其他隶属机构");
        }
    }

    @Override
    public PageResult<SysDept> findSubDepts(PageRequest pageRequest) {
        String id = pageRequest.getColumnFilterValue(pageRequest, "id");
        String managementSource = pageRequest.getColumnFilterValue(pageRequest, "managementSource");
        Page<SysDept> p = PageRequest.buildPageRequest(pageRequest);
        LambdaQueryWrapper<SysDept> lqw = new LambdaQueryWrapper<>();
        lqw.eq(StringUtils.isNotEmpty(id), SysDept::getParentId, id);
        lqw.eq(StringUtils.isNotEmpty(managementSource), SysDept::getManagementSource, managementSource);
        IPage<SysDept> pResult = page(p, lqw);
        //传入查询条件
        return PageResult.buildPageResult(pResult);

    }


    public String findMaxDeptId(String deptId) {
        if (deptId == null) return "";
        String result = "00";
        QueryWrapper<SysDept> qw = new QueryWrapper<>();
        qw.likeRight(StringUtils.isNotEmpty(deptId), "id", deptId + "D%");

        qw.select("IFNULL(MAX(id),0) maxid");
        Map<String, Object> m = getMap(qw);
        String maxId = m.get("maxid").toString();
        if (!maxId.equalsIgnoreCase("0") && !maxId.equalsIgnoreCase(deptId)) {
            result = maxId.substring(deptId.length() + 1);
        }

        return result;
    }

    public String findMaxHouseId(String deptId) {

        if (deptId == null) {
            return "";
        }
        String result = "00";
        QueryWrapper<SysDept> qw = new QueryWrapper<>();
        qw.like(StringUtils.isNotEmpty(deptId), "id", deptId + "M%");
        qw.select("IFNULL(MAX(id),0) maxid");
        Map<String, Object> m = getMap(qw);
        String maxId = m.get("maxid").toString();
        if (!maxId.equalsIgnoreCase("0") && !maxId.equalsIgnoreCase(deptId)) {
            result = maxId.substring(deptId.length() + 1);
        }

        return result;

    }

    //
    @Override
    public List<TreeSysDeptVO> selectListWhere(String where, Object[] paramValues) {

        String sql = "select t1.id, t1.name, t1.parent_id, t1.dept_code, t1.province, t1.city, t1.area, t1.comlevel from  sys_dept t1 " +
                "where del_flag='0' " + where;
        QueryWrapper<SysDept> qw = new QueryWrapper<>();
        qw.select(sql);
        List<SysDept> sysDeptList = list(qw);

        List<TreeSysDeptVO> recordList = new ArrayList<TreeSysDeptVO>();

        sysDeptList.forEach(a -> {
            TreeSysDeptVO model = new TreeSysDeptVO();
            model.setId(a.getId());
            model.setName(a.getName());
            model.setParentId(a.getParentId());
            model.setDeptCode(a.getDeptCode());
            model.setProvince(a.getProvince());
            model.setCity(a.getCity());
            model.setArea(a.getArea());
            model.setComlevel(a.getComlevel());
            recordList.add(model);
        });

        return recordList;
    }


    /**
     * 获取机构树(不包含团队  dept_type=C)
     */
    @Override
    public List<SysDept> findCompanyTree(String deptId) {
        SysDept sysDept = getById(deptId);
        LambdaQueryWrapper<SysDept> lqw = new LambdaQueryWrapper<>();
        lqw.eq(SysDept::getDelFlag, 0);
        lqw.likeRight(SysDept::getId, deptId);
        lqw.and((wrapper) -> {
            wrapper.eq(SysDept::getDeptType, 'C').or().eq(SysDept::getId, '9');
        });
        List<SysDept> sysDeptList = list(lqw);
        Map<String, List<SysDept>> map = sysDeptList.stream().collect(Collectors.groupingBy(SysDept::getParentId));
        sysDeptList.forEach(i -> i.setChildren(map.getOrDefault(i.getId(), new ArrayList<>())));
        return map.get(sysDept.getParentId());
    }

    /**
     * 根据传入机构，查询归属所有团队
     */
    @Override
    public List<SysDept> findTeamList(String deptId) {
        SysDept sysDept = getById(deptId);
        LambdaQueryWrapper<SysDept> lqw = new LambdaQueryWrapper<>();
        lqw.eq(SysDept::getDelFlag, 0);
        lqw.likeRight(SysDept::getId, deptId);
        lqw.eq(SysDept::getDeptType, 'D');
        lqw.apply(" exists (SELECT 1 FROM  `sys_dept` b WHERE sys_dept.parent_id = b.`id` AND b.`comlevel`='5') ");
        List<SysDept> sysDeptList = list(lqw);
        return sysDeptList;
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/4/28 10:24
     * @Description: 查询省、市、县 、门店的列表
     */
    @Override
    public List<SysDept> queryListByParentId(String level, String parentId) {
        return sysDeptMapper.queryListByParentId(level, parentId);
    }

    @Override
    public String queryBelongArea(String deptId) {
        //长度大于8的话 进行切割
        StringBuilder result = new StringBuilder();
        if (deptId.length() >= 8) {
            String area = deptId.substring(2, 8);
            SysArea sysArea = sysAreaMapper.selectOne(new LambdaQueryWrapper<SysArea>().eq(SysArea::getAreaCode, area));
            if (sysArea == null) {
                return "";
            }
            List<SysArea> sysAreas = sysAreaService.queryAllParent(sysArea);
            result.append(sysAreas.get(2).getAreaCname());
            result.append(sysAreas.get(1).getAreaCname());
            result.append(sysAreas.get(0).getAreaCname());
        }
        return result.toString();
    }

    @Override
    public List<SysArea> getListQueryBelongArea(String deptId) {
        //长度大于8的话 进行切割
        List<SysArea> sysAreas = new ArrayList<>();
        if (deptId.length() >= 8) {
            String area = deptId.substring(2, 8);
            SysArea sysArea = sysAreaMapper.selectOne(new LambdaQueryWrapper<SysArea>().eq(SysArea::getAreaCode, area));
            if (sysArea == null) {
                return null;
            }
            sysAreas = sysAreaService.queryAllParent(sysArea);
        }
        return sysAreas;
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/6/28 8:43
     * @Description: 查询后线机构树
     */
    @Override
    public List<SysDept> queryHXDeptTree() {
        //所有的后线机构
        List<SysDept> sysDeptsHX = sysDeptMapper.queryHXDeptTree();
        //查询后线中顶级的数据
        List<SysDept> resultList = new ArrayList<SysDept>();
        List<SysDept> sysDeptTop = sysDeptsHX.stream().filter(item -> "99".equals(item.getId())).collect(Collectors.toList());
        for (SysDept dept : sysDeptTop) {
            resultList.add(buildDeptTree(dept, sysDeptsHX));
        }
        return resultList;
    }

    /**
     * 递归构建树形结构
     */
    private SysDept buildDeptTree(SysDept dept, List<SysDept> deptList) {
        for (SysDept d : deptList) {
            if (dept.getId().equals(d.getParentId())) {
                if (null == dept.getChildren()) {
                    dept.setChildren(new ArrayList<SysDept>());
                }
                //递归调用
                dept.getChildren().add(buildDeptTree(d, deptList));
            }
        }
        return dept;
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/6/28 8:42
     * @Description: 查询前线机构树
     */
    @Override
    public List<SysDept> queryQXDeptTree() {
        List<SysDept> sysDeptAll = sysDeptMapper.queryListByQXDept();
        //查询后线中顶级的数据
        List<SysDept> resultList = new ArrayList<SysDept>();
        List<SysDept> sysDeptTop = sysDeptAll.stream().filter(item -> "3".equals(item.getComlevel())).collect(Collectors.toList());
        for (SysDept dept : sysDeptTop) {
            resultList.add(buildDeptTree(dept, sysDeptAll));
        }
        return sysDeptMapper.queryListByQXDept();
    }

    @Override
    public List<SysDeptTreeVo> getSysDeptTree() {
        SysDept sysDept = getById("9");
        LambdaQueryWrapper<SysDept> lqw = new LambdaQueryWrapper<>();
        lqw.eq(SysDept::getDelFlag, 0);
        lqw.isNotNull(SysDept::getComlevel);
        lqw.likeRight(SysDept::getId, "9");
        lqw.orderByAsc(SysDept::getOrderNum);
        List<SysDept> sysDeptList = list(lqw);
        SysDeptTreeVo sysDeptTreeVo = BeanUtil.copyProperties(sysDept, SysDeptTreeVo.class);
        List<SysDeptTreeVo> sysDeptTreeVos = BeanUtil.copyToList(sysDeptList, SysDeptTreeVo.class);
        sysDeptTreeVos.add(sysDeptTreeVo);
        Map<String, List<SysDeptTreeVo>> map = sysDeptTreeVos.stream().sorted(Comparator.comparing(SysDeptTreeVo::getId)).collect(Collectors.groupingBy(SysDeptTreeVo::getParentId));
        sysDeptTreeVos.forEach(i -> {
            i.setChildren(map.getOrDefault(i.getId(), new ArrayList<>()));
            i.setDeptCount(i.getChildren().size());
        });
        sysDeptTreeVos = map.get(sysDept.getParentId());


        return sysDeptTreeVos;
    }

    @Override
    public List<SysDeptTreeVo> getPartnerDeptTree() {
        SysDept sysDept = getById("9");
        LambdaQueryWrapper<SysDept> lqw = new LambdaQueryWrapper<>();
        lqw.eq(SysDept::getDelFlag, 0);
        lqw.likeRight(SysDept::getId, "9");
        lqw.orderByAsc(SysDept::getOrderNum);
        List<SysDept> sysDeptList = list(lqw);

        List<SysDeptTreeVo> sysDeptTreeVos = BeanUtil.copyToList(sysDeptList, SysDeptTreeVo.class);

        Map<String, List<SysDeptTreeVo>> map = sysDeptTreeVos.stream().sorted(Comparator.comparing(SysDeptTreeVo::getId))
                .collect(Collectors.groupingBy(SysDeptTreeVo::getParentId));
        sysDeptTreeVos.forEach(i -> {
            i.setChildren(map.getOrDefault(i.getId(), new ArrayList<>()));
            i.setDeptCount(i.getChildren().size());
        });
        sysDeptTreeVos = map.get(sysDept.getParentId());
        //合伙人机构树
        for (SysDeptTreeVo deptTreeVo : sysDeptTreeVos) {//1
            List<SysDeptTreeVo> children2 = deptTreeVo.getChildren();
            for (SysDeptTreeVo children : children2) {//2
                List<SysDeptTreeVo> children3 = children.getChildren();
                if (children3.size()>0) {
                    children3=children3.stream().filter(SysDeptTreeVo -> SysDeptTreeVo.getComlevel() != null).collect(Collectors.toList());
                    children.setChildren(children3);
                    for (SysDeptTreeVo child4 : children3) {//3
                        List<SysDeptTreeVo> children4 = child4.getChildren();
                        if (children4.size()>0) {
                            children4=children4.stream().filter(SysDeptTreeVo -> SysDeptTreeVo.getComlevel() != null).collect(Collectors.toList());
                            child4.setChildren(children4);
                            for (SysDeptTreeVo child : children4) {//4
                                List<SysDeptTreeVo> children5 = child.getChildren();
                                children5 = children5.stream().filter(SysDeptTreeVo ->SysDeptTreeVo.getComlevel() != null).collect(Collectors.toList());
                                child.setChildren(children5);
                                if (children5.size()>0) {
                                    for (SysDeptTreeVo treeVo : children5) {
                                        List<SysDeptTreeVo> childrenEnd = treeVo.getChildren();
                                        if (childrenEnd.size()>0) {
                                            childrenEnd=childrenEnd.stream().filter(SysDeptTreeVo ->SysDeptTreeVo.getComlevel() == null).collect(Collectors.toList());
                                            treeVo.setChildren(childrenEnd);
                                        }

                                    }

                                }
                            }
                        }
                    }
                }

            }
        }


        return sysDeptTreeVos;
    }

    @Override
    public boolean contrastiveManagementSource(String orderNo, String managementSource) {
        String managementSourceDept = sysDeptMapper.getByOrderNoQueryManagementSource(orderNo);
        return managementSource.equals(managementSourceDept);
    }
    /**
     * 数据权限机构数
     * @return
     */
    @Override
    public List<SysDept> getDataDeptTree(List<String> deptIds) {
        String name = BaseController.getUser().getName();
        List<SysDept> result = new ArrayList<>();
        if(!deptIds.isEmpty()){
            List<SysDept> deptList = sysDeptMapper.getListByIds(deptIds);
            // 使用一个Map来快速查找部门节点
            Map<String, SysDept> deptMap = new HashMap<>();
            for (SysDept dept : deptList) {
                deptMap.put(dept.getId(), dept);
            }
            // 找出顶级部门（即没有父部门的部门）
            for (SysDept dept : deptList) {
                if (dept.getParentId() == null || deptMap.get(dept.getParentId()) == null) {
                    // 添加到结果列表并构建其子树
                    buildDeptTree(dept, deptMap);
                    result.add(dept);
                }
            }

        } else if ("admin".equals(name)) {
           String  deptId ="9";
            if(deptId==null || "".equals(deptId)){
                deptId="9";
            }else{
                //如果是平台下判断包含D的查询上级id
                if(deptId.contains("D")){
                    SysDept dept = baseMapper.selectById(deptId);
                    deptId =dept==null?"":dept.getParentId();
                }
            }
            LambdaQueryWrapper<SysDept> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(SysDept::getDelFlag, 0);
            // 获取当前操作用户
            SysUser user = BaseController.getUser();
            String userId = user.getId();

            // 根据用户ID查询用户的部门树展示级别
            LambdaQueryWrapper<SysUserTreeShowLevel> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(SysUserTreeShowLevel::getUserId, userId);
            SysUserTreeShowLevel treeShowLevel = sysUserTreeShowLevelService.getOne(lambdaQueryWrapper);

            List<SysDept> treeByShowLevel = new ArrayList<>();
            //如果当前用户未配置树展示等级，则默认为查询全部
            if (Objects.isNull(treeShowLevel)) {
                treeShowLevel = new SysUserTreeShowLevel();
                treeShowLevel.setShowLevel("subordinate");
            }
            // 如果指定的部门ID为空或特定值，则使用当前用户所在部门ID
            if (null == deptId || "".equals(deptId) || "undefined".equals(deptId)) {
                if (!treeShowLevel.getShowLevel().equals("all")) {
                    deptId = user.getDeptId();
                } else {
                    deptId = "9";
                }
            }
            // 根据用户的部门树展示级别查询相应的部门树
            switch (treeShowLevel.getShowLevel()) {
                case "all":
                    treeByShowLevel = findTreeByShowLevel(deptId, null, "all");
                    break;
                case "same":
                    treeByShowLevel = findTreeByShowLevel(deptId, null, "same");
                    break;
                case "subordinate":
                    treeByShowLevel = findTreeByShowLevel(deptId, null, "subordinate");
                    break;
            }
            return treeByShowLevel;
        }
        return result;
    }

    @Override
    public List<SysDeptTreeVo> getFiveLevelDept(SysDeptVo sysDeptVo) {
        SysDept sysDept = getById("9");
        List<SysDept> sysDeptList = baseMapper.getFiveLevelDept(sysDeptVo);
        sysDeptList.add(sysDept);//添加总部 总部没有等级机构
        List<SysDeptTreeVo> sysDeptTreeVos = BeanUtil.copyToList(sysDeptList, SysDeptTreeVo.class);
        Map<String, List<SysDeptTreeVo>> map = sysDeptTreeVos.stream().sorted(Comparator.comparing(SysDeptTreeVo::getId))
                .collect(Collectors.groupingBy(SysDeptTreeVo::getParentId));
        sysDeptTreeVos.forEach(i -> {
            i.setChildren(map.getOrDefault(i.getId(), new ArrayList<>()));
            i.setDeptCount(i.getChildren().size());
        });
        return map.get(sysDept.getParentId());
    }


    private void buildDeptTree(SysDept dept, Map<String, SysDept> deptMap) {
        List<SysDept> children = new ArrayList<>();
        dept.setChildren(children);

        // 查找并添加子部门
        for (SysDept potentialChild : deptMap.values()) {
            if (potentialChild.getParentId() != null && potentialChild.getParentId().equals(dept.getId())) {
                children.add(potentialChild);
                buildDeptTree(potentialChild, deptMap); // 递归构建子部门的子树
            }
        }
    }

    /**
     *  前线只要机构 后线人员（按照领导人）  机构
     * @param sysDeptVo
     * @return
     */
    @Override
    public KztUserDeptTreeDto  getUserDeptTree(SysDeptVo sysDeptVo) {
        KztUserDeptTreeDto kztUserDeptTreeDto = new KztUserDeptTreeDto();
        String userId = BaseController.getUserId();
        if (userId.contains("M")) {
            kztUserDeptTreeDto.setType("1"); //前线
        } else {
            kztUserDeptTreeDto.setType("2"); //代理
        }
            SysUser byUserId = sysUserMapper.getByUserId(userId);
            List<SysDeptTreeVo> resultDeptList = this.getFiveLevelDeptKzt(byUserId);
            kztUserDeptTreeDto.setDeptList(resultDeptList);
            if (!userId.contains("M")) {
              List<SysUser>  resultList =this.getUserTreeHx(byUserId);
                kztUserDeptTreeDto.setUserList(resultList);
            }

        return kztUserDeptTreeDto;
    }

    private List<SysUser> getUserTreeHx(SysUser sysUser) {
        //获取领导字段不为空的人的ID
        QueryWrapper<SysUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.isNotNull("leader_id");

        List<SysUser> users = sysUserMapper.selectList(queryWrapper);
        if (users == null || users.size() == 0) {
            return new ArrayList<>();
        }
        List<SysUser> topUsers = new ArrayList<>(); //存放1级用户,即没有直接上级的用户
        // 根据组织结构展示级别，筛选顶层节点并构建组织结构树
        if("admin".equals(sysUser.getName())){
            topUsers.add(sysUserMapper.selectById("99D1501"));
        }else {
            topUsers.add(sysUser);
        }
        // 递归构建用户树结构
        buildUserTree(topUsers, users);
        return topUsers;
    }

    private List<SysDeptTreeVo> getFiveLevelDeptKzt(SysUser byUserId) {
        SysDept sysDept = getById("9");
        SysDeptVo sysDeptVo = new SysDeptVo();
        String id = byUserId.getId();
        List<String> deptIds = new ArrayList<>();
        if("admin".equals(byUserId.getId())){
            List<SysDept> sysDeptList = baseMapper.getFiveLevelDept(sysDeptVo);
            deptIds.addAll(sysDeptList.stream().map(SysDept::getId).collect(Collectors.toList()));
        }else {
            List<SysUserDeptRelationship> relationships = sysUserDeptRelationshipMapper.selectList(new QueryWrapper<SysUserDeptRelationship>().eq("user_id", id));
            deptIds.addAll(relationships.stream().map(SysUserDeptRelationship::getDeptId).collect(Collectors.toList()));
        }
        List<SysDept> sysDeptList = baseMapper.getFiveLevelDept(sysDeptVo);
        sysDept.setComlevel("1");
        sysDeptList.add(sysDept);

        List<SysDeptTreeVo> sysDeptTreeVos = BeanUtil.copyToList(sysDeptList, SysDeptTreeVo.class);
        Map<String, List<SysDeptTreeVo>> map = sysDeptTreeVos.stream().sorted(Comparator.comparing(SysDeptTreeVo::getId))
                .collect(Collectors.groupingBy(SysDeptTreeVo::getParentId));
        sysDeptTreeVos.forEach(i -> {
            if(Integer.parseInt(i.getComlevel())<=5){
                i.setChildren(map.getOrDefault(i.getId(), new ArrayList<>()));
                i.setDeptCount(i.getChildren().size());
            }
        });
        return map.get(sysDept.getParentId());
    }
    private void buildUserTree(List<SysUser> topUsers, List<SysUser> users) {
        for (SysUser user : topUsers) {
            List<SysUser> children = new ArrayList<>();
            for (SysUser childUser : users) {
                if (user.getId().equals(childUser.getLeaderId())) {
                    children.add(childUser);
                    // 递归查找下一级
                    buildUserTree(children, users);
                }
            }
            user.setChildren(children);
        }
    }
}