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

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

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
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.modules.admin.dao.*;
import com.ydtech.modules.admin.model.SysDept;
import com.ydtech.modules.admin.model.SysUser;
import com.ydtech.modules.admin.model.dto.*;
import com.ydtech.modules.admin.model.po.SysPcAddressHistory;
import com.ydtech.modules.admin.model.po.SysPcAddress;
import com.ydtech.modules.admin.model.vo.*;
import com.ydtech.modules.admin.service.*;
import com.ydtech.modules.base.controller.BaseController;
import com.ydtech.modules.order.entity.BasePageResult;
import com.ydtech.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author Administrator
 * @description 针对表【sys_pc_address(pc获取ip地址)】的数据库操作Service实现
 * @createDate 2024-09-02 09:40:08
 */
@Service
@RequiredArgsConstructor
public class SysPcAddressServiceImpl extends ServiceImpl<SysPcAddressMapper, SysPcAddress> implements SysPcAddressService {

    private final SysPcAddressHistoryService sysPcAddressHistoryService;

    private final SysPcAddressMapper sysPcAddressMapper;

    private final SysPcAddressHistoryMapper sysPcAddressHistoryMapper;

    private final GeoService geoService;
    private final SysUserService sysUserService;

    private static final String PC_GEO_KEY = "PCLocations";

    @Resource
    private SysDeptMapper sysDeptMapper;
    @Resource
    private SysDeptService sysDeptService;
    @Resource
    private SysUserMapper sysUserMapper;

    @Autowired
    private SysUserDeptRelationshipMapper sysUserDeptRelationshipMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveSysPcAddress(IpInfoDto ipInfoDto, SysUser user) {

        SysPcAddress sysPcAddress = getById(user.getId());
        if (sysPcAddress == null) {
            sysPcAddress = new SysPcAddress();
        }

        SysDept sysDept = sysDeptMapper.selectOne(new LambdaQueryWrapper<SysDept>()
                .eq(SysDept::getId, user.getDeptId()).eq(SysDept::getDelFlag, 0));
        sysPcAddress.setUserId(user.getId());
        sysPcAddress.setUserName(user.getName());
        sysPcAddress.setIp(ipInfoDto.getIp());
        sysPcAddress.setLatitude(ipInfoDto.getLat());
        sysPcAddress.setLongitude(ipInfoDto.getLng());
        sysPcAddress.setProvince(ipInfoDto.getProv());
        sysPcAddress.setCity(ipInfoDto.getCity());
        sysPcAddress.setDistrict(ipInfoDto.getDistrict());
        sysPcAddress.setSource(sysDept.getManagementSource());
        sysPcAddress.setAddress(ipInfoDto.getProv() + ipInfoDto.getCity() + ipInfoDto.getDistrict());
        sysPcAddress.setOperationTime(new Date());
        sysPcAddress.setLeaderName(user.getLeaderName());

        SysPcAddressHistory sysPcAddressHistory = new SysPcAddressHistory();
        BeanUtils.copyProperties(sysPcAddress, sysPcAddressHistory);
        this.saveOrUpdate(sysPcAddress);

        sysPcAddressHistoryService.save(sysPcAddressHistory);
    }

    @Override
    public List<SysPcAddress> getEveryone(SysPcAddressDto sysPcAddressDto) {
        List<SysPcAddress> sysPcAddresses = null;
        // 类型：1。机构 2.用户
        if (sysPcAddressDto.getType() == 1) {

            sysPcAddresses = sysPcAddressMapper.selectList(new LambdaQueryWrapper<SysPcAddress>()
                    .eq(StringUtils.isNotEmpty(sysPcAddressDto.getProvince()), SysPcAddress::getProvince, sysPcAddressDto.getProvince())
                    .eq(StringUtils.isNotEmpty(sysPcAddressDto.getCity()), SysPcAddress::getCity, sysPcAddressDto.getCity())
                    .eq(StringUtils.isNotEmpty(sysPcAddressDto.getDistrict()), SysPcAddress::getDistrict, sysPcAddressDto.getDistrict())
                    .in(SysPcAddress::getSource, Arrays.asList("1", "2"))
                    .likeRight(StringUtils.isNotEmpty(sysPcAddressDto.getQueryId()), SysPcAddress::getUserId, sysPcAddressDto.getQueryId())
                    .eq(StringUtils.isNotEmpty(sysPcAddressDto.getSource()), SysPcAddress::getSource, sysPcAddressDto.getSource())
                    .eq(sysPcAddressDto.getStatus() != null, SysPcAddress::getStatus, sysPcAddressDto.getStatus())
                    .orderByDesc(SysPcAddress::getOperationTime));

        } else if (sysPcAddressDto.getType() == 2) {
            List<SysUser> sysUsers = sysUserMapper.selectList(new LambdaQueryWrapper<SysUser>()
                    .eq(SysUser::getLeaderId, sysPcAddressDto.getQueryId()).ne(SysUser::getStatus, 0));
            List<String> collect = sysUsers.stream().map(SysUser::getId).collect(Collectors.toList());
            List<String> ids = new ArrayList<>();
            List<String> idList = queryList(collect, ids);
            collect.addAll(idList);
            if (collect.size() == 0) {
                return sysPcAddresses;
            }
            sysPcAddresses = sysPcAddressMapper.selectList(new LambdaQueryWrapper<SysPcAddress>()
                    .eq(StringUtils.isNotEmpty(sysPcAddressDto.getProvince()), SysPcAddress::getProvince, sysPcAddressDto.getProvince())
                    .eq(StringUtils.isNotEmpty(sysPcAddressDto.getCity()), SysPcAddress::getCity, sysPcAddressDto.getCity())
                    .eq(StringUtils.isNotEmpty(sysPcAddressDto.getDistrict()), SysPcAddress::getDistrict, sysPcAddressDto.getDistrict())
                    .in(SysPcAddress::getSource, Arrays.asList("1", "2"))
                    .in(CollectionUtil.isNotEmpty(collect), SysPcAddress::getUserId, collect)
                    .eq(StringUtils.isNotEmpty(sysPcAddressDto.getSource()), SysPcAddress::getSource, sysPcAddressDto.getSource())
                    .eq(sysPcAddressDto.getStatus() != null, SysPcAddress::getStatus, sysPcAddressDto.getStatus())
                    .orderByDesc(SysPcAddress::getOperationTime));

        } else {
            sysPcAddresses = sysPcAddressMapper.selectList(new LambdaQueryWrapper<SysPcAddress>()
                    .eq(StringUtils.isNotEmpty(sysPcAddressDto.getProvince()), SysPcAddress::getProvince, sysPcAddressDto.getProvince())
                    .eq(StringUtils.isNotEmpty(sysPcAddressDto.getCity()), SysPcAddress::getCity, sysPcAddressDto.getCity())
                    .eq(StringUtils.isNotEmpty(sysPcAddressDto.getDistrict()), SysPcAddress::getDistrict, sysPcAddressDto.getDistrict())
                    .in(SysPcAddress::getSource, Arrays.asList("1", "2"))
                    .eq(StringUtils.isNotEmpty(sysPcAddressDto.getSource()), SysPcAddress::getSource, sysPcAddressDto.getSource())
                    .eq(sysPcAddressDto.getStatus() != null, SysPcAddress::getStatus, sysPcAddressDto.getStatus())
                    .orderByDesc(SysPcAddress::getOperationTime));
        }

        for (SysPcAddress sysPcAddress : sysPcAddresses) {
            SysUser sysUser = sysUserService.getById(sysPcAddress.getUserId());
            if (sysUser == null) continue;
            sysPcAddress.setLeaderName(sysUser.getLeaderName());
        }

        return sysPcAddresses;
    }

    private List<String> queryList(List<String> collect, List<String> ids) {
        if (collect.size() > 0) {
            for (String id : collect) {
                List<SysUser> sysUsers = sysUserMapper.selectList(new LambdaQueryWrapper<SysUser>()
                        .eq(SysUser::getLeaderId, id).ne(SysUser::getStatus, 0));
                if (sysUsers.size() > 0) {
                    List<String> list = sysUsers.stream().map(SysUser::getId).collect(Collectors.toList());
                    ids.addAll(list);
                    queryList(list, ids);

                }
            }

        }

        return ids;
    }


    @Override
    public List<SysPcAddress> findLocationsWithinRadius(AdressRangeDto adressRangeDto) {
        geoService.addLocations(list(), PC_GEO_KEY);
        List<String> nearbyIds = geoService.findNearbyIds(PC_GEO_KEY, adressRangeDto.getLongitude(), adressRangeDto.getLatitude(), adressRangeDto.getRadius());
        if (nearbyIds.size() == 0) return new ArrayList<>();
        geoService.move(nearbyIds, PC_GEO_KEY);
        return listByIds(nearbyIds);
    }

    @Override
    public SysPcAddressNumVo queryPcNum(SysPcAddressDto sysPcAddressDto) {
        SysPcAddressNumVo sysPcAddressNumVo = new SysPcAddressNumVo();

        //区域数量统计
        Long all = sysPcAddressMapper.selectCount(new LambdaQueryWrapper<SysPcAddress>()
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getProvince()), SysPcAddress::getProvince, sysPcAddressDto.getProvince())
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getCity()), SysPcAddress::getCity, sysPcAddressDto.getCity())
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getDistrict()), SysPcAddress::getDistrict, sysPcAddressDto.getDistrict())
                .in(SysPcAddress::getSource, Arrays.asList("1", "2"))
                .eq(sysPcAddressDto.getStatus() != null, SysPcAddress::getStatus, sysPcAddressDto.getStatus()));
        Long channelNum = sysPcAddressMapper.selectCount(new LambdaQueryWrapper<SysPcAddress>()
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getProvince()), SysPcAddress::getProvince, sysPcAddressDto.getProvince())
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getCity()), SysPcAddress::getCity, sysPcAddressDto.getCity())
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getDistrict()), SysPcAddress::getDistrict, sysPcAddressDto.getDistrict())
                .eq(SysPcAddress::getSource, 1)
                .eq(sysPcAddressDto.getStatus() != null, SysPcAddress::getStatus, sysPcAddressDto.getStatus()));
        Long proxyNum = sysPcAddressMapper.selectCount(new LambdaQueryWrapper<SysPcAddress>()
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getProvince()), SysPcAddress::getProvince, sysPcAddressDto.getProvince())
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getCity()), SysPcAddress::getCity, sysPcAddressDto.getCity())
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getDistrict()), SysPcAddress::getDistrict, sysPcAddressDto.getDistrict())
                .eq(SysPcAddress::getSource, 2)
                .eq(sysPcAddressDto.getStatus() != null, SysPcAddress::getStatus, sysPcAddressDto.getStatus()));

        Long onlineNum = sysPcAddressMapper.selectCount(new LambdaQueryWrapper<SysPcAddress>()
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getProvince()), SysPcAddress::getProvince, sysPcAddressDto.getProvince())
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getCity()), SysPcAddress::getCity, sysPcAddressDto.getCity())
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getDistrict()), SysPcAddress::getDistrict, sysPcAddressDto.getDistrict())
                .in(SysPcAddress::getSource, Arrays.asList("1", "2"))
                .eq(sysPcAddressDto.getStatus() == null, SysPcAddress::getStatus, 1)
                .eq(sysPcAddressDto.getStatus() != null, SysPcAddress::getStatus, sysPcAddressDto.getStatus()));


        sysPcAddressNumVo.setAllNum(all);
        sysPcAddressNumVo.setProxyNum(proxyNum);
        sysPcAddressNumVo.setChannelNum(channelNum);
        sysPcAddressNumVo.setOnlineNum(onlineNum);

        return sysPcAddressNumVo;
    }

    @Override
    public List<RegionInfoVo> queryRegionInfo(SysPcAddressDto sysPcAddressDto) {
        List<RegionInfoVo> regionInfoVos = new ArrayList<>();
        //全部：null   渠道：1 代理：2
        List<SysPcAddress> sysPcAddresses = sysPcAddressMapper.selectList(new LambdaQueryWrapper<SysPcAddress>()
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getProvince()), SysPcAddress::getProvince, sysPcAddressDto.getProvince())
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getCity()), SysPcAddress::getCity, sysPcAddressDto.getCity())
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getDistrict()), SysPcAddress::getDistrict, sysPcAddressDto.getDistrict())
                .in(SysPcAddress::getSource, Arrays.asList("1", "2"))
                .eq(StringUtils.isNotEmpty(sysPcAddressDto.getSource()), SysPcAddress::getSource, sysPcAddressDto.getSource())
                .eq(sysPcAddressDto.getStatus() != null, SysPcAddress::getStatus, sysPcAddressDto.getStatus()));

        if (CollectionUtil.isEmpty(sysPcAddresses)) return regionInfoVos;

        Map<String, List<SysPcAddress>> map;
        if (CollectionUtil.isEmpty(sysPcAddresses)) return regionInfoVos;
        if (StringUtils.isEmpty(sysPcAddressDto.getProvince())) {
            map = sysPcAddresses.stream().collect(Collectors.groupingBy(SysPcAddress::getProvince));
        } else {
            if (StringUtils.isNotEmpty(sysPcAddressDto.getCity())) {
                map = sysPcAddresses.stream().collect(Collectors.groupingBy(SysPcAddress::getDistrict));

            } else {
                map = sysPcAddresses.stream().collect(Collectors.groupingBy(SysPcAddress::getCity));

            }
        }

        for (Map.Entry<String, List<SysPcAddress>> entry : map.entrySet()) {
            RegionInfoVo regionInfoVo = new RegionInfoVo();
            regionInfoVo.setDistrictName(entry.getKey());
            regionInfoVo.setNumber(entry.getValue().size());
            regionInfoVos.add(regionInfoVo);
        }
        return regionInfoVos;

    }

    @Override
    public BasePageResult<SysPcAddress> queryPcAddressInfo(PcAddressInfoDto addressInfoDto) {
        Page<SysPcAddress> page = new Page<>(addressInfoDto.getPageNum(), addressInfoDto.getPageSize());
        Page<SysPcAddress> insOrdersPage = null;
        // 类型：1。机构 2.用户
        if (addressInfoDto.getType() == 1) {
            LambdaQueryWrapper<SysPcAddress> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(StringUtils.isNotEmpty(addressInfoDto.getLng()), SysPcAddress::getLongitude, addressInfoDto.getLng());
            wrapper.eq(StringUtils.isNotEmpty(addressInfoDto.getLat()), SysPcAddress::getLatitude, addressInfoDto.getLat());
            wrapper.in(SysPcAddress::getSource, Arrays.asList("1", "2"));
            wrapper.eq(StringUtils.isNotEmpty(addressInfoDto.getSource()), SysPcAddress::getSource, addressInfoDto.getSource());
            wrapper.likeRight(StringUtils.isNotEmpty(addressInfoDto.getQueryId()), SysPcAddress::getUserId, addressInfoDto.getQueryId());
            wrapper.eq(addressInfoDto.getStatus() != null, SysPcAddress::getStatus, addressInfoDto.getStatus());
            wrapper.orderByDesc(SysPcAddress::getOperationTime);

            insOrdersPage = page(page, wrapper);

        } else if (addressInfoDto.getType() == 2) {
            List<SysUser> sysUsers = sysUserMapper.selectList(new LambdaQueryWrapper<SysUser>()
                    .eq(SysUser::getLeaderId, addressInfoDto.getQueryId()).ne(SysUser::getStatus, 0));
            List<String> collect = sysUsers.stream().map(SysUser::getId).collect(Collectors.toList());
            List<String> ids = new ArrayList<>();
            List<String> idList = queryList(collect, ids);
            collect.addAll(idList);
            if (collect.size() == 0) {
                return new BasePageResult<>(addressInfoDto.getPageNum(), page.getSize(), insOrdersPage.getTotal(), page.getPages(),
                        insOrdersPage.getRecords());
            }

            LambdaQueryWrapper<SysPcAddress> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(StringUtils.isNotEmpty(addressInfoDto.getLng()), SysPcAddress::getLongitude, addressInfoDto.getLng());
            wrapper.eq(StringUtils.isNotEmpty(addressInfoDto.getLat()), SysPcAddress::getLatitude, addressInfoDto.getLat());
            wrapper.in(SysPcAddress::getSource, Arrays.asList("1", "2"));
            wrapper.eq(StringUtils.isNotEmpty(addressInfoDto.getSource()), SysPcAddress::getSource, addressInfoDto.getSource());
            wrapper.eq(addressInfoDto.getStatus() != null, SysPcAddress::getStatus, addressInfoDto.getStatus());
            wrapper.orderByDesc(SysPcAddress::getOperationTime);

            insOrdersPage = page(page, wrapper);
        } else {

            LambdaQueryWrapper<SysPcAddress> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(StringUtils.isNotEmpty(addressInfoDto.getLng()), SysPcAddress::getLongitude, addressInfoDto.getLng());
            wrapper.eq(StringUtils.isNotEmpty(addressInfoDto.getLat()), SysPcAddress::getLatitude, addressInfoDto.getLat());
            wrapper.in(SysPcAddress::getSource, Arrays.asList("1", "2"));
            wrapper.eq(StringUtils.isNotEmpty(addressInfoDto.getSource()), SysPcAddress::getSource, addressInfoDto.getSource());
            wrapper.eq(addressInfoDto.getStatus() != null, SysPcAddress::getStatus, addressInfoDto.getStatus());
            wrapper.orderByDesc(SysPcAddress::getOperationTime);

            insOrdersPage = page(page, wrapper);
        }

        return new BasePageResult<>(addressInfoDto.getPageNum(), page.getSize(), insOrdersPage.getTotal(), page.getPages(),
                insOrdersPage.getRecords());
    }

    @Override
    public PcAddressHistoryInfoVo getPcAddress(String startTime, String endTime, String source) {
        PcAddressHistoryInfoVo pcAddressHistoryInfoVo = new PcAddressHistoryInfoVo();
        if (StringUtils.isEmpty(startTime) || startTime.equals(endTime)) {
            if (StringUtils.isNullOrEmpty(startTime)) {
                Date date = new Date();
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
                startTime = simpleDateFormat.format(date);
            }
            QueryWrapper<SysPcAddressHistory> queryWrapper = new QueryWrapper<>();
            // 指定 COUNT(DISTINCT user_id) 查询
            queryWrapper.select("COUNT(DISTINCT user_id) AS total")
                    .likeRight(StringUtils.isNotEmpty(startTime), "operation_time", startTime)
                    .in("source", Arrays.asList(1, 2))
                    .eq(StringUtils.isNotEmpty(source), "source", source);
            Map<String, Object> result = sysPcAddressHistoryService.getMap(queryWrapper);
            Long total = (Long) result.get("total");
            pcAddressHistoryInfoVo.setOnlineNum(total);

            List<PcAddressHistoryTimeVo> pcAddress = sysPcAddressHistoryMapper.getPcAddress(startTime, source);
            pcAddressHistoryInfoVo.setList(pcAddress);

            List<SysPcAddressHistory> sysPcAddressHistories = sysPcAddressHistoryMapper.getPcAddressInfo(startTime, source);
            extracted(sysPcAddressHistories);
            System.out.println("********************" + sysPcAddressHistories.size());
            pcAddressHistoryInfoVo.setPcAddressList(sysPcAddressHistories);


        } else {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            startTime = startTime + " 00:00:01";
            endTime = endTime + " 23:59:59";
            try {
                Date parse = simpleDateFormat.parse(startTime);
                Date parse1 = simpleDateFormat.parse(endTime);
                startTime = simpleDateFormat.format(parse);
                endTime = simpleDateFormat.format(parse1);

            } catch (ParseException e) {
                throw new RuntimeException(e);
            }
            QueryWrapper<SysPcAddressHistory> queryWrapper = new QueryWrapper<>();
            // 指定 COUNT(DISTINCT user_id) 查询
            queryWrapper.select("COUNT(DISTINCT user_id) AS total").between("operation_time", startTime, endTime)
                    .in("source", Arrays.asList(1, 2)).eq(StringUtils.isNotEmpty(source), "source", source);
            Map<String, Object> result = sysPcAddressHistoryService.getMap(queryWrapper);
            Long total = (Long) result.get("total");
            pcAddressHistoryInfoVo.setOnlineNum(total);

            List<PcAddressHistoryTimeVo> pcAddress = sysPcAddressHistoryMapper.getPcAddressSection(startTime, endTime, source);

            pcAddressHistoryInfoVo.setList(pcAddress);

            List<SysPcAddressHistory> sysPcAddressHistories = sysPcAddressHistoryMapper.getPcAddressHistory(startTime, endTime, source);
            extracted(sysPcAddressHistories);
            System.out.println("********************" + sysPcAddressHistories.size());
            pcAddressHistoryInfoVo.setPcAddressList(sysPcAddressHistories);
        }

        return pcAddressHistoryInfoVo;
    }

    private void extracted(List<SysPcAddressHistory> sysPcAddressHistories) {
        for (SysPcAddressHistory sysPcAddressHistory : sysPcAddressHistories) {

            SysUser sysUser = sysUserService.getById(sysPcAddressHistory.getUserId());
            if (sysUser == null) continue;
            sysPcAddressHistory.setLeaderName(sysUser.getLeaderName());
            SysDept sysDept = sysDeptMapper.selectById(sysUser.getDeptId());
            if (sysDept == null) continue;
            sysPcAddressHistory.setDeptName(sysDept.getName());


        }
    }

    @Override
    public List<SysPcAddress> getOnlinePeople() {
        return sysPcAddressMapper.selectList(new LambdaQueryWrapper<SysPcAddress>().eq(SysPcAddress::getStatus, 1));
    }

    @Override
    public BasePageResult<SysPcAddressHistory> queryPcAddressHistoryInfo(PcAddressInfoDto addressInfoDto) {
        Page page = new Page(addressInfoDto.getPageNum(), addressInfoDto.getPageSize());

        IPage<SysPcAddressHistory> sysPcAddressHistoryIPage = sysPcAddressHistoryMapper.queryAddressHistory(page, addressInfoDto);

        return new BasePageResult<>(addressInfoDto.getPageNum(), addressInfoDto.getPageSize(), sysPcAddressHistoryIPage.getTotal(), sysPcAddressHistoryIPage.getPages(),
                sysPcAddressHistoryIPage.getRecords());
    }

    /**
     * 前线只要机构 后线人员（按照领导人）  机构
     *
     * @return
     */
    @Override
    public KztUserDeptTreeDto getUserDeptTree() {
        KztUserDeptTreeDto kztUserDeptTreeDto = new KztUserDeptTreeDto();
        String userId = BaseController.getUserId();
        List<SysDept> sysDeptList1 = sysDeptMapper.selectList(new LambdaQueryWrapper<SysDept>().eq(SysDept::getLeaderId, userId));
        if (sysDeptList1.size() > 0) {
            //展示机构
            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")) {
            if (sysDeptList1.size()==0) {
                List<SysUser> resultList = this.getUserTreeHx(byUserId);
                kztUserDeptTreeDto.setUserList(resultList);
            }

        }

        return kztUserDeptTreeDto;
    }

    private List<SysDeptTreeVo> getFiveLevelDeptKzt(SysUser byUserId) {
        SysDept sysDept = sysDeptService.getById("9");
        SysDept dept = sysDeptMapper.selectById(BaseController.getDeptId());
        SysDept sysDept1 = new SysDept();

        SysDeptVo sysDeptVo = new SysDeptVo();
        String id = byUserId.getId();
        List<String> deptIds = new ArrayList<>();
        if ("admin".equals(byUserId.getId())) {
            List<SysDept> sysDeptList = sysDeptMapper.queryFiveLevelDept(sysDeptVo);
            deptIds.addAll(sysDeptList.stream().map(SysDept::getId).collect(Collectors.toList()));
        } else {

            List<SysDept> sysDeptList1 = sysDeptMapper.selectList(new LambdaQueryWrapper<SysDept>().eq(SysDept::getLeaderId, id));
            if (sysDeptList1.size() > 0) {
                if (sysDeptList1.size() == 1) {
                    SysDept sysDept2 = sysDeptList1.get(0);
                    BeanUtil.copyProperties(sysDept2, sysDept1);
                    deptIds = getDeptIds(sysDept2.getId(), deptIds, deptIds);
                } else {

                    Optional<SysDept> max = sysDeptList1.stream().min((o1, o2) -> o1.getComlevel().compareTo(o2.getComlevel()));
                    SysDept sysDept2 = max.get();
                    BeanUtil.copyProperties(sysDept2, sysDept1);
                    deptIds = getDeptIds(sysDept2.getId(), deptIds, deptIds);
                }
            } else {
                List<SysDept> sysDeptList = sysDeptMapper.queryFiveLevelDept(sysDeptVo);
                deptIds.addAll(sysDeptList.stream().map(SysDept::getId).collect(Collectors.toList()));
            }
        }
        sysDeptVo.setDeptIds(deptIds);
        List<SysDept> sysDeptList = sysDeptMapper.queryFiveLevelDept(sysDeptVo);
        if ("admin".equals(byUserId.getId())) {
            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());
            }
        });
        if ("admin".equals(byUserId.getId())) {
            return map.get(BaseController.getDeptId());
        }
        List<SysDept> sysDeptList1 = sysDeptMapper.selectList(new LambdaQueryWrapper<SysDept>().eq(SysDept::getLeaderId, id));
        if (sysDeptList1.size() == 0) {
            return map.get(sysDept.getId());
        }
        String parentId = sysDept1.getParentId();
        if (parentId.equals("0")) {
            sysDept1.setParentId(sysDept1.getId());
        }
        return map.get(sysDept1.getParentId());
    }

    private List<String> getDeptIds(String deptId, List<String> ids, List<String> deptIds) {
        if (ids.size() > 0) {
            List<String> list = new ArrayList<>();
            for (String id : ids) {
                List<SysDept> sysDeptList = sysDeptMapper.selectList(new LambdaQueryWrapper<SysDept>().eq(SysDept::getParentId, id).isNotNull(SysDept::getComlevel));
                if (sysDeptList.size() > 0) {
                    List<String> collect = sysDeptList.stream().map(SysDept::getId).collect(Collectors.toList());
                    deptIds.addAll(sysDeptList.stream().map(SysDept::getId).collect(Collectors.toList()));
                    list.addAll(collect);
                }
            }
            if (list.size() == 0) {
                return deptIds;
            } else {
                getDeptIds(deptId, list, deptIds);
            }
        } else {
            List<SysDept> sysDeptList = sysDeptMapper.selectList(new LambdaQueryWrapper<SysDept>().eq(SysDept::getParentId, deptId).isNotNull(SysDept::getComlevel));
            if (sysDeptList.size() > 0) {
                List<String> collect = sysDeptList.stream().map(SysDept::getId).collect(Collectors.toList());
                deptIds.add(deptId);
                deptIds.addAll(collect);
                getDeptIds(deptId, collect, deptIds);

            }
        }

        return deptIds;
    }


    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级用户,即没有直接上级的用户
        // 根据组织结构展示级别，筛选顶层节点并构建组织结构树
        //topUsers.add(sysUserMapper.selectById("99D1501"));
        if ("admin".equals(sysUser.getName())) {
            topUsers.add(sysUserMapper.selectById("99D1501"));
        } else {
            topUsers.add(sysUser);
        }
        // 递归构建用户树结构
        buildUserTree(topUsers, users);
        return topUsers;
    }

    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);
        }
    }


}