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

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

import cn.dev33.satoken.session.SaSession;
import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
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.google.gson.Gson;
import com.ydtech.constants.InsuranceImageEnum;
import com.ydtech.constants.SysConstants;
import com.ydtech.constants.sys.SysPasswordEnum;
import com.ydtech.core.page.HttpResult;
import com.ydtech.core.page.PageResult;
import com.ydtech.exception.SystemException;
import com.ydtech.handler.CreateAndUpdateMetaObjectHandler;
import com.ydtech.modules.admin.components.UnionPayRequestApiComponent;
import com.ydtech.modules.admin.components.request.UnionPayRequest;
import com.ydtech.modules.admin.components.response.UnionPayResponse;
import com.ydtech.modules.admin.constants.*;
import com.ydtech.modules.admin.dao.SysDeptMapper;
import com.ydtech.modules.admin.dao.SysPartnerMapper;
import com.ydtech.modules.admin.dao.SysUserLinkAreaMapper;
import com.ydtech.modules.admin.dao.SysUserMapper;
import com.ydtech.modules.admin.model.*;
import com.ydtech.modules.admin.model.dto.*;
import com.ydtech.modules.admin.model.po.SysUserAgentTrack;
import com.ydtech.modules.admin.model.po.SysUserIsDial;
import com.ydtech.modules.admin.model.po.SysUserTreeShowLevel;
import com.ydtech.modules.admin.model.vo.*;
import com.ydtech.modules.admin.service.*;
import com.ydtech.modules.admin.utils.RecordUserUtils;
import com.ydtech.modules.admin.utils.UserAgentTrackUtils;
import com.ydtech.modules.base.controller.BaseController;
import com.ydtech.modules.base.model.dto.PageDto;
import com.ydtech.modules.base.model.vo.PageVo;
import com.ydtech.modules.esm.model.EsmUserImage;
import com.ydtech.modules.esm.model.EsmUserReferrer;
import com.ydtech.modules.esm.model.vo.EsmUserImageQueryVo;
import com.ydtech.modules.esm.model.vo.EsmUserImageVo;
import com.ydtech.modules.esm.service.EsmUserImageService;
import com.ydtech.modules.esm.service.EsmUserReferrerService;
import com.ydtech.modules.message.constants.MessageTypeConstants;
import com.ydtech.modules.message.service.MessageSecretaryService;
import com.ydtech.modules.protocol.utils.AssertionUtils;
import com.ydtech.security.utils.PasswordUtils;
import com.ydtech.utils.IDCardUtils;
import com.ydtech.utils.StringUtils;
import com.ydtech.utils.idgen.IdGenerate;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.RequestParam;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.math.BigDecimal;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import static com.ydtech.constants.RedisConstant.PHONE_VERIFICATION_CODE_KEY;
import static com.ydtech.constants.RedisConstant.PHONE_VERIFICATION_CODE_KEY_TIME;


@Service
@Slf4j
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements SysUserService {

    @Autowired
    private SysMenuService sysMenuService;

    @Autowired
    private SysRoleMenuService sysRoleMenuService;

    @Autowired
    private SysDeptService sysDeptService;

    @Autowired
    private SysUserMapper sysUserMapper;

    @Autowired
    private SysUserRoleService sysUserRoleService;

    @Autowired
    private EsmUserReferrerService esmUserReferrerService;

    @Autowired
    private SysUserInfoService sysUserInfoService;

    @Autowired
    private EsmUserImageService esmUserImageService;

    @Autowired
    private SysAreaService sysAreaService;

    @Autowired
    private SysUserTreeShowLevelService sysUserTreeShowLevelService;

    @Autowired
    private SysUserIsDialService sysUserIsDialService;

    @Autowired
    private SysUserTrackService sysUserTrackService;

    @Autowired
    private SysPcAddressService sysPcAddressService;

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Autowired
    private SysUserLinkAreaMapper sysUserLinkAreaMapper;
    @Autowired
    private SysDeptMapper sysDeptMapper;
    @Resource
    private SysPartnerService sysPartnerService;
    @Resource
    private SysAgencyLeaderService sysAgencyLeaderService;

    @Resource
    private SysPartnerMapper sysPartnerMapper;

    @Autowired
    private MessageSecretaryService messageSecretaryService;

    @Autowired
    private UnionPayRequestApiComponent unionPayRequestApiComponent;

    @Autowired
    private SysUserAgentTrackService sysUserAgentTrackService;

    @Autowired
    private SysUserBankCardService bankCardService;

    @Value("${httpUrl}")
    private String httpUrl;

    @Override
    public IPage<SysUserBaseVO> findUserList(PageDto<SysUserDto> pageDto) {
        PageVo<SysUserBaseVO> pageVo = new PageVo();
        Page page = new Page(pageDto.getPageNum(), pageDto.getPageSize());
        pageVo.setPageNum(pageDto.getPageNum());
        pageVo.setPageSize(pageDto.getPageSize());

        SysUserDto sysUserVO = JSONObject.parseObject(JSONObject.toJSONString(pageDto.getDto()), SysUserDto.class);
        if (sysUserVO.getAgentFlag() == null) {
            throw new SystemException("必传标识未传递");
        }
        IPage<SysUserBaseVO> userList = sysUserMapper.findUserList(page, sysUserVO);
        return userList;
    }

    @Override
    public IPage<SysUserBaseVO> findAllUserList(PageDto<SysUserDto> pageDto) {
        PageVo<SysUserBaseVO> pageVo = new PageVo();
        Page page = new Page(pageDto.getPageNum(), pageDto.getPageSize());
        pageVo.setPageNum(pageDto.getPageNum());
        pageVo.setPageSize(pageDto.getPageSize());

        SysUserDto sysUserVO = JSONObject.parseObject(JSONObject.toJSONString(pageDto.getDto()), SysUserDto.class);

        IPage<SysUserBaseVO> userList = sysUserMapper.findAllUserList(page, sysUserVO);
        return userList;
    }

    @Override
    public IPage<SysUserBaseVO> findBackUserList(SysUserDto sysUserDto) {
        PageVo<SysUserBaseVO> pageVo = new PageVo<>();
        Page<SysUserBaseVO> page = new Page<>(sysUserDto.getPageNum(), sysUserDto.getPageSize());

        pageVo.setPageNum(sysUserDto.getPageNum());
        pageVo.setPageSize(sysUserDto.getPageSize());
        if (sysUserDto.getAgentFlag() == null) {
            throw new SystemException("必传标识未传递");
        }

        return sysUserMapper.findBackUserList(page, sysUserDto);
    }

    @Override
    public List<SysUserBaseVO> findBackUserList1(SysUserDto sysUserDto) {
        if (sysUserDto.getAgentFlag() == null) {
            throw new SystemException("必传标识未传递");
        }
        return sysUserMapper.findBackUserList1(sysUserDto);
    }


    @Override
    public IPage<QuTeamNum> quTeamNum(QuTeamNumDto quTeamNumDto) {

        if (StringUtils.isNotEmpty(quTeamNumDto.getCreateTimeStart()) && StringUtils.isNotEmpty(quTeamNumDto.getCreateTimeEnd())) {
            quTeamNumDto.setCreateTimeStart(quTeamNumDto.getCreateTimeStart() + " 00:00:00");
            quTeamNumDto.setCreateTimeEnd(quTeamNumDto.getCreateTimeEnd() + " 23:59:59");
        }

        //判断必传标识是否为空
        if (quTeamNumDto.getTeamOrUserFlag() == null) {
            throw new SystemException("必传参数未传");
        }
        //判断是要查询用户还是团队
        if ("1".equals(quTeamNumDto.getTeamOrUserFlag())) {
            List<QuTeamNum> dept = sysUserMapper.getDept(quTeamNumDto);

            return getQuTeamNumIPage(quTeamNumDto, dept);

        } else if ("2".equals(quTeamNumDto.getTeamOrUserFlag())) {
            List<QuTeamNum> dept = sysUserMapper.getUser(quTeamNumDto);


            return getQuTeamNumIPage(quTeamNumDto, dept);
        }
        throw new SystemException("参数错误");
    }

    @Override
    public IPage<QuTeamNum> getQuTeamByCompany(QuTeamNumDto quTeamNumDto) {
        List<QuTeamNum> deptByCompany = sysUserMapper.getDeptByCompany(quTeamNumDto);
        IPage<QuTeamNum> page = new Page<>(quTeamNumDto.getPageNo(), quTeamNumDto.getPageSize());
        page.setRecords(deptByCompany);
        page.setTotal(deptByCompany.size());
        return page;
    }


    private IPage<QuTeamNum> getQuTeamNumIPage(QuTeamNumDto quTeamNumDto, List<QuTeamNum> dept) {
        Map<String, List<QuTeamNum>> collect = new HashMap<>();
        int flag;
        if (quTeamNumDto.getTeamOrUserFlag().equals("1")) {
            collect = dept.stream()
                    .collect(Collectors.groupingBy(QuTeamNum::getDeptId));
            flag = 1;
        } else if ("2".equals(quTeamNumDto.getTeamOrUserFlag())) {
            collect = dept.stream()
                    .collect(Collectors.groupingBy(QuTeamNum::getUserId));
            flag = 2;
        } else {
            flag = 0;
        }

        List<QuTeamNum> quTeamNums = new ArrayList<>();
        collect.forEach((k, v) -> {
            QuTeamNum teamNum = new QuTeamNum();
            teamNum.setHasInsuredNum("0");
            teamNum.setSubmitNum("0");
            teamNum.setSyPremiumSum("0");
            teamNum.setJqPremiumSum("0");
            teamNum.setTaxaMountSum("0");
            teamNum.setTotalSumpremium("0");
            teamNum.setQuoteNum("0");

            if (!v.isEmpty()) {
                v.forEach(quTeamNum -> {
                    if (quTeamNum.getOrderStatus() != null) {
                        if (quTeamNum.getOrderStatus().equals("3")) {
                            if (quTeamNum.getJqPremiumSum() == null) {
                                quTeamNum.setJqPremiumSum("0");
                            }
                            if (quTeamNum.getSyPremiumSum() == null) {
                                quTeamNum.setSyPremiumSum("0");
                            }
                            //添加总额
                            teamNum.setTotalSumpremium(String.valueOf(new BigDecimal(teamNum.getTotalSumpremium())
                                    .add(new BigDecimal(quTeamNum.getSyPremiumSum())).add(new BigDecimal(quTeamNum.getJqPremiumSum()))));
                            teamNum.setSyPremiumSum(String.valueOf(new BigDecimal(teamNum.getSyPremiumSum()).add(new BigDecimal(quTeamNum.getSyPremiumSum()))));
                            teamNum.setJqPremiumSum(String.valueOf(new BigDecimal(teamNum.getJqPremiumSum()).add(new BigDecimal(quTeamNum.getJqPremiumSum()))));
                            teamNum.setQuoteNum(String.valueOf(new BigDecimal(teamNum.getQuoteNum()).add(new BigDecimal(quTeamNum.getCount()))));
                            teamNum.setHasInsuredNum(String.valueOf(new BigDecimal(teamNum.getHasInsuredNum()).add(new BigDecimal(quTeamNum.getCount()))));
                            teamNum.setTaxaMountSum(String.valueOf(new BigDecimal(quTeamNum.getTaxaMountSum())));
                        }
                        if (quTeamNum.getOrderStatus().equals("2")) {
                            teamNum.setSubmitNum(String.valueOf(new BigDecimal(teamNum.getSubmitNum()).add(new BigDecimal(quTeamNum.getCount()))));
                            teamNum.setQuoteNum(String.valueOf(new BigDecimal(teamNum.getQuoteNum()).add(new BigDecimal(quTeamNum.getCount()))));
                        }
                        if (quTeamNum.getOrderStatus().equals("1")) {
                            teamNum.setQuoteNum(String.valueOf(new BigDecimal(teamNum.getQuoteNum()).add(new BigDecimal(quTeamNum.getCount()))));
                            teamNum.setSubmitNum(String.valueOf(new BigDecimal(teamNum.getSubmitNum()).add(new BigDecimal(quTeamNum.getCount()))));
                        }
                    }
                });
            }

            if (flag == 1) {
                teamNum.setDeptId(v.get(0).getDeptId());
                teamNum.setDeptName(v.get(0).getDeptName());
            } else if (flag == 2) {
                teamNum.setUserId(v.get(0).getUserId());
                teamNum.setUserName(v.get(0).getUserName());
            }

            quTeamNums.add(teamNum);
        });

        List<QuTeamNum> collect1 =
                quTeamNums.stream().skip((quTeamNumDto.getPageNo() - 1) * quTeamNumDto.getPageSize()).limit(quTeamNumDto.getPageSize()).
                        collect(Collectors.toList());
        IPage<QuTeamNum> page = new Page<>(quTeamNumDto.getPageNo(), quTeamNumDto.getPageSize());
        page.setRecords(collect1);
        page.setTotal(quTeamNums.size());
        return page;
    }


    @Override
    public HttpResult sendMsgPantner(String phone) {
        if (org.apache.commons.lang3.StringUtils.isEmpty(phone)) {
            return HttpResult.error("手机号不能为空");
        }
//            if ("0".equals(type)) {  // 0 登录 1 注册
        SysUser sysUser = this.findByPhone(phone);
        if (sysUser == null) {
            return HttpResult.error("手机号不存在！");
        }
//            }
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String timeCreate = simpleDateFormat.format(sysUser.getCreateTime());
        String userId = sysUser.getId();
        List<SysUserTrack> sysUserTracks = sysUserTrackService.list(new LambdaQueryWrapper<SysUserTrack>().eq(SysUserTrack::getUserId, userId).orderByDesc(SysUserTrack::getApproveTime));
        SysUserTrack sysUserTrack = sysUserTracks.get(0);

        Integer type = sysUser.getType();
        String type1 = "";
        if (type == 1) {
            type1 = "合伙人申请";
        } else if (type == 2) {
            type1 = "工作室申请";
        } else if (type == 3) {
            type1 = "团队长申请";
        }
//        Random rand = new Random();
//        // randNumber 将被赋值为一个 MIN 和 MAX 范围内的随机数
//        int randNumber = rand.nextInt(9999 - 1000 + 1) + 1000;
//        // 保存验证码到redis
//        redisTemplate.opsForValue().set(PHONE_VERIFICATION_CODE_KEY + phone, String.valueOf(randNumber), PHONE_VERIFICATION_CODE_KEY_TIME
//                , TimeUnit.MINUTES);

        // 构建 vars
        Map<String, String> varsMap = new HashMap<>();
        varsMap.put("timeCreate", timeCreate);
        varsMap.put("type", type1);
        varsMap.put("url", httpUrl + "id=" + userId + "&remark=" + sysUserTrack.getApproveMess() + "&type=" + type);
        // 将 vars 转换为 JSON 字符串
        Gson gson = new Gson();
        String varsJson = gson.toJson(varsMap);
        String result = null;
        String urlNet = "http://v.juhe.cn/sms/send";//请求接口地址
        Map params = new HashMap();//请求参数
        params.put("mobile", phone);//接收短信的手机号码
        params.put("tpl_id", "265910");//短信模板ID，请参考个人中心短信模板设置
        params.put("vars", varsJson);
        params.put("key", "fbe7b165e9e13e52f3b1f2654eab9c0e");//应用APPKEY(应用详细页查询)
        params.put("dtype", "json");//返回数据的格式,xml或json，默认json

        try {
            result = net(urlNet, params, "POST");
            JSONObject object = JSONObject.parseObject(result);
            if (object.getInteger("error_code") == 0) {
//				System.out.println(object.get("result"));
                return HttpResult.ok("发送成功");
            } else {
                System.out.println(object.get("error_code") + ":" + object.get("reason"));
                return HttpResult.error("发送失败," + object.get("error_code") + ":" + object.get("reason"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return HttpResult.ok("发送失败");
    }

    public String net(String strUrl, Map params, String method) throws Exception {
        String DEF_CHATSET = "UTF-8";
        int DEF_CONN_TIMEOUT = 30000;
        int DEF_READ_TIMEOUT = 30000;
        String userAgent = "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.66 Safari/537.36";

        HttpURLConnection conn = null;
        BufferedReader reader = null;
        String rs = null;
        try {
            StringBuffer sb = new StringBuffer();
            if (method == null || method.equals("GET")) {
                strUrl = strUrl + "?" + urlencode(params);
            }
            URL url = new URL(strUrl);
            conn = (HttpURLConnection) url.openConnection();
            if (method == null || method.equals("GET")) {
                conn.setRequestMethod("GET");
            } else {
                conn.setRequestMethod("POST");
                conn.setDoOutput(true);
            }
            conn.setRequestProperty("User-agent", userAgent);
            conn.setUseCaches(false);
            conn.setConnectTimeout(DEF_CONN_TIMEOUT);
            conn.setReadTimeout(DEF_READ_TIMEOUT);
            conn.setInstanceFollowRedirects(false);
            conn.connect();
            if (params != null && Objects.equals(method, "POST")) {
                try {
                    DataOutputStream out = new DataOutputStream(conn.getOutputStream());
                    out.writeBytes(urlencode(params));
                } catch (Exception e) {
                    // TODO: handle exception
                }
            }
            InputStream is = conn.getInputStream();
            reader = new BufferedReader(new InputStreamReader(is, DEF_CHATSET));
            String strRead = null;
            while ((strRead = reader.readLine()) != null) {
                sb.append(strRead);
            }
            rs = sb.toString();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                reader.close();
            }
            if (conn != null) {
                conn.disconnect();
            }
        }
        return rs;
    }

    public String urlencode(Map<String, Object> data) {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry i : data.entrySet()) {
            try {
                sb.append(i.getKey()).append("=").append(URLEncoder.encode(i.getValue() + "", "UTF-8")).append("&");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        return sb.toString();
    }

    @Override
    public SysUser findByUsername(String username) {
        SysUser sysUser = null;
        if (StringUtils.isNotEmpty(username)) {

            sysUser = getById(username);
        }

        return sysUser;
    }

    @Override
    public SysUser findByPhone(String phone) {
        SysUser sysUser = null;

        LambdaQueryWrapper<SysUser> lqw = new LambdaQueryWrapper<>();
        lqw.eq(StringUtils.isNotEmpty(phone), SysUser::getMobile, phone);
        List<SysUser> lst = list(lqw);
        if (lst.size() > 0) {
            sysUser = lst.get(0);
        }

        return sysUser;
    }

    @Override
    public Set<String> findPermissions(SysUser sysUser) {
        Set<String> perms = new HashSet<>();
        String sql = "";
        List<String> lsPerms = null;

        if (sysUser.getId().equalsIgnoreCase("admin")) {

            LambdaQueryWrapper<SysMenu> lqw = new LambdaQueryWrapper<>();
            lqw.isNotNull(SysMenu::getPerms);
            lqw.select(SysMenu::getPerms);
            lsPerms = sysMenuService.listObjs(lqw, id -> id.toString());

        } else {

            List<SysMenu> sysMenuList = sysRoleMenuService.gainMenuIds(sysUser.getId());

            lsPerms =
                    sysMenuList.stream().filter(a -> StringUtils.isNotEmpty(a.getPerms())).map(SysMenu::getPerms).collect(Collectors.toList());

        }

        if (lsPerms != null && lsPerms.size() > 0) {
            for (String perm : lsPerms) {
                if (!StringUtils.isNullOrEmpty(perm)) {
                    perms.add(perm);
                }
            }
        }

        return perms;
    }
//    @Override
//    public Set<String> findPermissions(SysUser sysUser) {
//        Set<String> perms = new HashSet<>();
//        String sql = "";
//        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
//        List<String> lsPerms = null;
//
//        if (sysUser.getId().equalsIgnoreCase("admin")) {
//            sql = "SELECT perms FROM sys_menu WHERE perms IS NOT NULL AND perms <> ''";
//
//            lsPerms = jdbcTemplate.queryForList(sql, String.class);
//        } else {
//            sql = "SELECT perms FROM sys_menu sm WHERE sm.id IN ( " +
//                    "SELECT menu_id FROM sys_role_menu srm, sys_user_role sur ,sys_user su " +
//                    "WHERE srm.role_id=sur.role_id " +
//                    "AND sur.user_id=su.id AND su.id=?) " +
//                    "AND perms IS NOT NULL AND perms <> ''"
//            ;
//
//            lsPerms = jdbcTemplate.queryForList(sql, String.class, sysUser.getId());
//        }
//
//        if (lsPerms != null && lsPerms.size() > 0) {
//            for (String perm : lsPerms) {
//                if (!StringUtils.isNullOrEmpty(perm)) {
//                    perms.add(perm);
//                }
//            }
//        }
//
//        return perms;
//    }

    @Override
    public List<SysUserRole> findUserRoles(Long userId) {
        return null;
    }

    @Override
    public PageResult selectPagingCustom(int pageNumber, int pageSize, String name, String deptCode) {
        return null;
    }

    /**
     * 获取用户列表
     *
     * @param page            分页信息
     * @param sysUser         查询条件
     * @param containsSubDept 是否汉堡下级机构
     * @return
     */
    @Override
    public IPage<SysUser> selectUserPage(Page page, SysUser sysUser, String containsSubDept) {
        IPage<SysUser> sysUserIPage = baseMapper.selectUserPage(page, sysUser, containsSubDept);
        List<SysUser> records = sysUserIPage.getRecords();
        if (records != null && records.size() > 0) {
            List<String> ids = records.stream().map(SysUser::getId).collect(Collectors.toList());
            LambdaQueryWrapper<SysUserTreeShowLevel> wrapper = new LambdaQueryWrapper<>();
            wrapper.in(SysUserTreeShowLevel::getUserId, ids);
            List<SysUserTreeShowLevel> list = sysUserTreeShowLevelService.list(wrapper);
            for (SysUser record : records) {
                for (SysUserTreeShowLevel showLevel : list) {
                    if (record.getId().equals(showLevel.getUserId())) {
                        record.setShowLevel(showLevel.getShowLevel());
                    }
                }
            }
            LambdaQueryWrapper<SysUserIsDial> isWrapper = new LambdaQueryWrapper<>();
            isWrapper.in(SysUserIsDial::getUserId, ids);
            List<SysUserIsDial> isDialList = sysUserIsDialService.list(isWrapper);
            for (SysUser record : records) {
                for (SysUserIsDial isDial : isDialList) {
                    if (record.getId().equals(isDial.getUserId())) {
                        record.setIsDial(isDial.getIsDial());
                        record.setDialUserName(isDial.getDialUserName());
                        record.setDialPassWord(isDial.getDialPassWord());
                    }
                }
            }
        }
        return sysUserIPage;
    }

    @Override
    public void findSysUseresmUserInternalVORoles(PageResult pageResult) {

    }

    @Override
    public Integer deleteFlag(List<SysUser> lsSysUser) {

        List<String> ids = lsSysUser.stream().map(SysUser::getId).collect(Collectors.toList());

        LambdaUpdateWrapper<SysUser> lqw = new LambdaUpdateWrapper<>();
        lqw.set(SysUser::getStatus, "0");
        lqw.in(SysUser::getId, ids);
        return update(lqw) == true ? ids.size() : 0;


    }

    @Override
    public SysUser findById(String id) {
        if (!StringUtils.isNullOrEmpty(id)) {
            return getById(id);
        }
        return null;
    }

    @Override
    public SysUser findByUserId(String userId) {
        SysUser sysUser = null;
        if (!StringUtils.isNullOrEmpty(userId)) {
            sysUser = getById(userId);
        }

        return sysUser;
    }

    @Override
    public SysUserVO gainUserInternal(String userId) {
        return super.baseMapper.gainInternalUser(userId);
    }

    @Override
    public SysUserVO gainUserInternalByDeptId(String deptId) {
        return super.baseMapper.gainInternalUserByDeptId(deptId);
    }

    @Override
    public List<SysUserVO> findByReferrerId(String deptId) {
        return super.baseMapper.findByReferrerId(deptId);
    }

    @Override
    public List<SysUserVO> findListByDeptId(SysUser sysUser) {
        return super.baseMapper.findListByDeptId(sysUser);
    }

    @Override
    public List<SysUserVO> findListByDeptIdNew(SysUser sysUser) {
        return super.baseMapper.findListByDeptIdNew(sysUser);
    }

    @Override
    public PageVo<SysUserBaseVO> gainUserPage(PageDto<SysUserDto> pageDto) {

        PageVo<SysUserBaseVO> pageVo = new PageVo<>();
        Page<SysUserBaseVO> page = new Page<>(pageDto.getPageNum(), pageDto.getPageSize());
        pageVo.setPageNum(pageDto.getPageNum());
        pageVo.setPageSize(pageDto.getPageSize());

        SysUserDto sysUserVO = JSONObject.parseObject(JSONObject.toJSONString(pageDto.getDto()), SysUserDto.class);
        Page<SysUserBaseVO> sysUserBaseVOIPage = super.baseMapper.gainUserBaseInfo(page, sysUserVO);
        pageVo.setContent(sysUserBaseVOIPage.getRecords());
        pageVo.setTotalPages((int) sysUserBaseVOIPage.getPages());
        pageVo.setTotalSize((int) sysUserBaseVOIPage.getTotal());
        return pageVo;
    }

    @Override
    public String gainNextUserId(String deptId) {
        int noCount = 3;//顺序号是几位的
        String nextPK;
        QueryWrapper<SysUser> lq = new QueryWrapper<>();
        lq.select(" MAX(id) as id ");
        lq.eq("dept_id", deptId);
//        lq.likeRight("id", deptId);

        SysUser userMaxId = getOne(lq);


        String maxId = "";
        if (null != userMaxId) maxId = userMaxId.getId();

        if (StringUtils.isNullOrEmpty(maxId)) {
            nextPK = deptId + "001";
        } else {
            nextPK = IdGenerate.nextCode(maxId, noCount);
        }


        return nextPK;
    }

    @Override
    public SysUserInternalVO gainUserSynthesisInfo(String userId) {
        SysUserInternalVO vo = new SysUserInternalVO();

        SysUser sysUser = getById(userId);
//        EsmUserInternal sysUserInternal = esmUserInternalService.selectByPk(userId);

        String pDeptId = sysUser.getDeptId();
        if (pDeptId.indexOf("D") > 1) {
            pDeptId = sysUser.getDeptId().substring(0, pDeptId.indexOf("D"));
        }
        SysDept sysDept = sysDeptService.getById(pDeptId);

        vo.setSysUser(sysUser);
        vo.setSysDept(sysDept);
//        vo.setSysUserInternal(sysUserInternal);

        return vo;
    }


    @Override
    public String findMaxId(String deptId) {
        QueryWrapper<SysUser> qw = new QueryWrapper<>();
        qw.select("IFNULL(MAX(id),0) maxId");
        qw.eq("dept_id", deptId);
        Map<String, Object> m = getMap(qw);
        String maxId = m.get("maxId").toString();
        return maxId;

    }

    @Override
    public boolean check(String userId, Integer approvalStatus, String approvalOpinion) {

        SysUser user = getById(userId);
//        user.setApprovalStatus(approvalStatus);
        user.setApprovalOpinion(approvalOpinion);

        return updateById(user);


    }

    @Override
    public SysUserBaseVO selectUserById(String userId) {
        return sysUserMapper.selectUserById(userId);
    }

    @Override
    @Transactional
    public boolean saveUser(SysUser sysUser) {
        // 判断用户id是否存在
        if (StringUtils.isNullOrEmpty(sysUser.getId())) {
            sysUser.setId(gainNextUserId(sysUser.getDeptId()));
            sysUser.setMobile(sysUser.getMobile());
        }

        // 角色信息
        SysUserRole sur = new SysUserRole();
        sur.setUserId(sysUser.getId());
        sur.setRoleId(StringUtils.toLong(sysUser.getRoleId()));

        // 删除角色
        sysUserRoleService.deleteByUserId(sysUser.getId());
        // 删除推荐人
        esmUserReferrerService.deldeleteByReferrerId(sysUser.getId());

        // 构建推荐人信息
        EsmUserReferrer eur = new EsmUserReferrer();
        eur.setId(sysUser.getId());
        eur.setReferrerId(sysUser.getReferrerId());//推荐人
        eur.setReferrerName(sysUser.getReferrerName());

        // 新增或跟新用户表
        save(sysUser);
        // 保存推荐人
        esmUserReferrerService.save(eur);
        // 保存角色
        sysUserRoleService.save(sur);
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public HttpResult saveUserInfo(SysUser2Vo sysUserVo) {
        SysUser sysUser = sysUserVo.getSysUser();
        // 手机号
        List<SysUser> mobileList = lambdaQuery().eq(SysUser::getMobile, sysUser.getMobile()).list();
        if (!mobileList.isEmpty()) {
            throw new SystemException("手机号已经注册请更换手机号。");
        }
        // 身份证号
        List<SysUser> identityList = lambdaQuery().eq(SysUser::getIdentity, sysUser.getIdentity()).list();
        if (!identityList.isEmpty()) {
            throw new SystemException("身份证号已经注册请更换身份证号。");
        }

        //处理密码
        if (StringUtils.isNotEmpty(sysUser.getPassword())) {
            String salt = PasswordUtils.getSalt();
            String pwd = PasswordUtils.encode(sysUser.getPassword(), salt);
            sysUser.setPassword(pwd);
            sysUser.setSalt(salt);
        } else {
            return HttpResult.error("密码不能为空");
        }
        String userId = "";
        if ("19".equals(sysUser.getRoleId())) {//19 出单员 校验机构和业务员机构是否一致
            // add by  hxl  2024-08-20
            // return checkChuDanUser(sysUser);
            if (StringUtils.isEmpty(sysUser.getReferrerId())) {
                return HttpResult.error("业务员工号不能为空");
            }
            //归属业务员和出单员部门必须一致
            SysUser user = getById(sysUser.getReferrerId());
            if (user == null || !user.getDeptId().equals(sysUser.getDeptId())) {
                return HttpResult.error("出单员机构必须和归属业务员机构一致");
            }
            sysUser.setOperatorCode(sysUser.getReferrerId());
            if (StringUtils.isEmpty(sysUser.getId())) {
                userId = gainNextUserId(sysUser.getDeptId());
                sysUser.setId(userId);
                save(sysUser);
                //角色配置
                SysUserRole userRole = new SysUserRole();
                userRole.setUserId(sysUser.getId());
                userRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
                sysUserRoleService.save(userRole);
            } else {
                userId = sysUser.getId();
                updateById(sysUser);
            }
            SysUserInfo userInfo = sysUserVo.getSysUserInfo();
            userInfo.setId(sysUser.getId());
            sysUserInfoService.save(userInfo);
        } else {
            userId = gainNextUserId(sysUser.getDeptId());

            if (RoleConstants.R22.getCode().equals(sysUser.getRoleId())) {//22	后线人员
                if (!SysConstants.isAdministration(userId)) {
                    throw new SystemException("后线人员只能公司部门中");
                }
            }

            sysUser.setId(userId);
            save(sysUser);

            //角色配置
            SysUserRole userRole = new SysUserRole();
            userRole.setUserId(sysUser.getId());
            userRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
            sysUserRoleService.save(userRole);
            if (StringUtils.isNotEmpty(sysUser.getReferrerId())) {
                //推荐人
                esmUserReferrerService.addReferrer(sysUser.getReferrerId(), userId);
            } else if ("20".equals(sysUser.getRoleId()) || "21".equals(sysUser.getRoleId())) {
                //如果是 团队长或代码人 并且没有推荐人 则默认推荐人为自己
                esmUserReferrerService.addReferrer(sysUser.getId(), userId);
            }
            SysUserInfo userInfo = sysUserVo.getSysUserInfo();
            if (userInfo != null) {
                if (null != userInfo.getLiveAddressString() && userInfo.getLiveAddressString().length > 0) {
                    sysUserVo.getSysUserInfo().setLiveAddress(Arrays.stream(userInfo.getLiveAddressString()).map(item -> item.toString()).collect(Collectors.joining(",")));
                }
                userInfo.setId(sysUser.getId());
            }
//        userInfo.setId(sysUser.getId());
            sysUserInfoService.save(userInfo);
        }
        List<EsmUserImageVo> esmUserImageVo = sysUserVo.getEsmUserImageVo();
        String finalUserId = userId;
        List<EsmUserImage> esmUserImages = esmUserImageVo.stream().map(x -> new EsmUserImage(x, finalUserId)).collect(Collectors.toList());
        esmUserImageService.saveBatch(esmUserImages);
        SpringUtil.getBean(RecordUserUtils.class).addRecord(userId, BaseController.getUserName());
        return HttpResult.ok("新增成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public HttpResult saveUserInfoByPartner(SysUser2Vo sysUserVo) {
        SysUser sysUser = sysUserVo.getSysUser();
        // 手机号
        List<SysUser> mobileList = lambdaQuery().eq(SysUser::getMobile, sysUser.getMobile()).list();
        if (!mobileList.isEmpty()) {
            throw new SystemException("手机号已经注册请更换手机号。");
        }
        // 身份证号
        List<SysUser> identityList = lambdaQuery().eq(SysUser::getIdentity, sysUser.getIdentity()).list();
        if (!identityList.isEmpty()) {
            throw new SystemException("身份证号已经注册请更换身份证号。");
        }

        //处理密码
        if (StringUtils.isNotEmpty(sysUser.getPassword())) {
            String salt = PasswordUtils.getSalt();
            String pwd = PasswordUtils.encode(sysUser.getPassword(), salt);
            sysUser.setPassword(pwd);
            sysUser.setSalt(salt);
        } else {
            return HttpResult.error("密码不能为空");
        }
        String userId = "";
        if ("19".equals(sysUser.getRoleId())) {//19 出单员 校验机构和业务员机构是否一致
            // add by  hxl  2024-08-20
            // return checkChuDanUser(sysUser);
            if (StringUtils.isEmpty(sysUser.getReferrerId())) {
                return HttpResult.error("业务员工号不能为空");
            }
            //归属业务员和出单员部门必须一致
            SysUser user = getById(sysUser.getReferrerId());
            if (user == null || !user.getDeptId().equals(sysUser.getDeptId())) {
                return HttpResult.error("出单员机构必须和归属业务员机构一致");
            }
            sysUser.setOperatorCode(sysUser.getReferrerId());
            if (StringUtils.isEmpty(sysUser.getId())) {
                userId = gainNextUserId(sysUser.getDeptId());
                sysUser.setId(userId);
                save(sysUser);
                //角色配置
                SysUserRole userRole = new SysUserRole();
                userRole.setUserId(sysUser.getId());
                userRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
                sysUserRoleService.save(userRole);
            } else {
                userId = sysUser.getId();
                updateById(sysUser);
            }
            SysUserInfo userInfo = sysUserVo.getSysUserInfo();
            userInfo.setId(sysUser.getId());
            sysUserInfoService.save(userInfo);
        } else {
            userId = gainNextUserId(sysUser.getDeptId());

            if (RoleConstants.R22.getCode().equals(sysUser.getRoleId())) {//22	后线人员
                if (!SysConstants.isAdministration(userId)) {
                    throw new SystemException("后线人员只能公司部门中");
                }
            }

            sysUser.setId(userId);
            save(sysUser);

            //角色配置
            SysUserRole userRole = new SysUserRole();
            userRole.setUserId(sysUser.getId());
            userRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
            sysUserRoleService.save(userRole);
            if (StringUtils.isNotEmpty(sysUser.getReferrerId())) {
                //推荐人
                esmUserReferrerService.addReferrer(sysUser.getReferrerId(), userId);
            } else if ("20".equals(sysUser.getRoleId()) || "21".equals(sysUser.getRoleId())) {
                //如果是 团队长或代码人 并且没有推荐人 则默认推荐人为自己
                esmUserReferrerService.addReferrer(sysUser.getId(), userId);
            }
            SysUserInfo userInfo = sysUserVo.getSysUserInfo();
            if (userInfo != null) {
                if (null != userInfo.getLiveAddressString() && userInfo.getLiveAddressString().length > 0) {
                    sysUserVo.getSysUserInfo().setLiveAddress(Arrays.stream(userInfo.getLiveAddressString()).map(item -> item.toString()).collect(Collectors.joining(",")));
                }
                userInfo.setId(sysUser.getId());
            }else {
                userInfo=new SysUserInfo();
                userInfo.setId(sysUser.getId());
            }
            sysUserInfoService.save(userInfo);
        }
        List<EsmUserImageVo> esmUserImageVo = sysUserVo.getEsmUserImageVo();
        String finalUserId = userId;
        if (!CollectionUtils.isEmpty(esmUserImageVo)) {
            List<EsmUserImage> esmUserImages = esmUserImageVo.stream().map(x -> new EsmUserImage(x, finalUserId)).collect(Collectors.toList());
            esmUserImageService.saveBatch(esmUserImages);
        }
        SpringUtil.getBean(RecordUserUtils.class).addRecord(userId, Optional.ofNullable(sysUserVo.getSysUser().getReferrerId()).orElse("admin") );
        return HttpResult.ok("新增成功", sysUserMapper.selectById(userId));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public HttpResult saveUserInfo1(SysUser2Vo sysUserVo) {

        log.info("添加团队入参：{}", sysUserVo);
        SysUser sysUser = sysUserVo.getSysUser();
        sysUser.setType(3);
        sysUser.setCreateTime(new Date());
        SysUserInfo sysUserInfo = new SysUserInfo();
        LocalDate birthday = LocalDate.parse(sysUser.getIdentity().substring(6, 10) + "-" + sysUser.getIdentity().substring(10, 12) + "-" + sysUser.getIdentity().substring(12, 14));
        sysUserInfo.setBirthday(birthday);
        sysUserVo.setSysUserInfo(sysUserInfo);
        // 先创建工作室下的团队
        SysAgencyLeader sysAgencyLeader = sysAgencyLeaderService.getOne(new LambdaQueryWrapper<SysAgencyLeader>()
                .eq(SysAgencyLeader::getUserId, sysUser.getReferrerId()));
        SysDept sysDept = sysDeptService.getOne(new LambdaQueryWrapper<SysDept>().eq(SysDept::getId, sysAgencyLeader.getDeptId()));
//        SysDept sysDept = sysDeptList.get(0);
        SysDeptVo sysDeptVo = new SysDeptVo();
        sysDeptVo.setName(sysUser.getName() + "团队"); // 以人名设置工作室名称
        sysDeptVo.setDeptType("D"); // 默认为子公司
        sysDeptVo.setParentId(sysDept.getId());
        sysDeptVo.setManagementSource(sysDept.getManagementSource()); //机构来源
        sysDeptVo.setOrderNum(0);
        sysDeptVo.setCreateTime(new Date());
        log.info("------------------团队长添加先调添加部门-----------------------");
        sysDeptService.addDept(sysDeptVo);


        if (StringUtils.isNullOrEmpty(sysUser)) {
            return HttpResult.error("用户信息不能为空");
        }
        if (StringUtils.isNullOrEmpty(sysDeptVo.getId())) {
            return HttpResult.error("机构ID不能为空");
        }
        if (StringUtils.isNullOrEmpty(sysUser.getRoleId())) {
            throw new SystemException("角色id不能为空");
        }
        //获取机构层级
        int deptLevel = this.getDeptLevel1(sysDeptVo.getId());
        if (!StringUtils.isNullOrEmpty(sysUser.getRoleId())) {
            if (RoleConstants.R21.getCode().equals(sysUser.getRoleId())
                    || RoleConstants.R20.getCode().equals(sysUser.getRoleId())
                    || RoleConstants.R19.getCode().equals(sysUser.getRoleId())) {//19 出单员 21	团队长 20	代理人

                if (deptLevel != 6) {
                    throw new SystemException("团队长、代理人、出单员只能归属团队中");
                }
                //如果为团队长，判断是否已经存在团队长，存在不允许添加   add by  hxl  2024-05-07  ============begin
                if (RoleConstants.R21.getCode().equals(sysUser.getRoleId())) {
                    int count = this.getCountByDeptAndRoleId(sysUser);
                    if (count > 0) {
                        throw new SystemException("该机构已存在团队长，不允许再添加！！");
                    }
                }
                // =========================add by hxl   end ====================
            } else if (RoleConstants.R18.getCode().equals(sysUser.getRoleId())) { // 42 门店长
                if (deptLevel != 5) {
                    throw new SystemException("机构管理员只能归属机构中");
                }
            } else if (RoleConstants.R17.getCode().equals(sysUser.getRoleId())) {
                if (deptLevel != 4) {
                    throw new SystemException("部长只能归属于4级");
                }
            }

        }

//        SysUser sysUser = sysUserVo.getSysUser();
        // 手机号
        List<SysUser> mobileList = lambdaQuery().eq(SysUser::getMobile, sysUser.getMobile()).list();
        if (!mobileList.isEmpty()) {
            throw new SystemException("手机号已经注册请更换手机号。");
        }
        // 身份证号
        List<SysUser> identityList = lambdaQuery().eq(SysUser::getIdentity, sysUser.getIdentity()).list();
        if (!identityList.isEmpty()) {
            throw new SystemException("身份证号已经注册请更换身份证号。");
        }

        //处理密码
        if (StringUtils.isNotEmpty(sysUser.getPassword())) {
            String salt = PasswordUtils.getSalt();
            String pwd = PasswordUtils.encode(sysUser.getPassword(), salt);
            sysUser.setPassword(pwd);
            sysUser.setSalt(salt);
        } else {
            return HttpResult.error("密码不能为空");
        }
        String userId = "";
        if ("19".equals(sysUser.getRoleId())) {//19 出单员 校验机构和业务员机构是否一致
            // add by  hxl  2024-08-20
            // return checkChuDanUser(sysUser);
            if (StringUtils.isEmpty(sysUser.getReferrerId())) {
                return HttpResult.error("业务员工号不能为空");
            }
            //归属业务员和出单员部门必须一致
            SysUser user = getById(sysUser.getReferrerId());
            if (user == null || !user.getDeptId().equals(sysUser.getDeptId())) {
                return HttpResult.error("出单员机构必须和归属业务员机构一致");
            }
            sysUser.setOperatorCode(sysUser.getReferrerId());
            if (StringUtils.isEmpty(sysUser.getId())) {
                userId = gainNextUserId(sysUser.getDeptId());
                sysUser.setId(userId);
                save(sysUser);
                //角色配置
                SysUserRole userRole = new SysUserRole();
                userRole.setUserId(sysUser.getId());
                userRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
                sysUserRoleService.save(userRole);
            } else {
                userId = sysUser.getId();
                updateById(sysUser);
            }
            SysUserInfo userInfo = sysUserVo.getSysUserInfo();
            userInfo.setId(sysUser.getId());
            sysUserInfoService.save(userInfo);
        } else {
            userId = gainNextUserId(sysDeptVo.getId());

            if (RoleConstants.R22.getCode().equals(sysUser.getRoleId())) {//22	后线人员
                if (!SysConstants.isAdministration(userId)) {
                    throw new SystemException("后线人员只能公司部门中");
                }
            }

            sysUser.setId(userId);
            sysUser.setDeptId(sysDeptVo.getId());
            sysUser.setStatus(2);
            save(sysUser);

            //角色配置
            SysUserRole userRole = new SysUserRole();
            userRole.setUserId(sysUser.getId());
            userRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
            sysUserRoleService.save(userRole);
            if (StringUtils.isNotEmpty(sysUser.getReferrerId())) {
                //推荐人
                esmUserReferrerService.addReferrer(sysUser.getReferrerId(), userId);
            } else if ("20".equals(sysUser.getRoleId()) || "21".equals(sysUser.getRoleId())) {
                //如果是 团队长或代码人 并且没有推荐人 则默认推荐人为自己
                esmUserReferrerService.addReferrer(sysUser.getId(), userId);
            }
            SysUserInfo userInfo = sysUserVo.getSysUserInfo();
            if (userInfo != null) {
                if (null != userInfo.getLiveAddressString() && userInfo.getLiveAddressString().length > 0) {
                    sysUserVo.getSysUserInfo().setLiveAddress(Arrays.stream(userInfo.getLiveAddressString()).map(item -> item.toString()).collect(Collectors.joining(",")));
                }
                userInfo.setId(sysUser.getId());
            }
//        userInfo.setId(sysUser.getId());
            sysUserInfoService.save(userInfo);
        }
        List<EsmUserImageVo> esmUserImageVo = sysUserVo.getEsmUserImageVo();
        String finalUserId = userId;
        if (!CollectionUtils.isEmpty(esmUserImageVo)) {
            List<EsmUserImage> esmUserImages = esmUserImageVo.stream().map(x -> new EsmUserImage(x, finalUserId)).collect(Collectors.toList());
            esmUserImageService.saveBatch(esmUserImages);
        }
        SpringUtil.getBean(RecordUserUtils.class).addRecord(userId, Optional.ofNullable(sysUserVo.getSysUser().getReferrerId()).orElse("admin"));
        return HttpResult.ok("新增成功", sysUserMapper.selectById(userId));
    }

    /**
     * 新增修改出单员
     *
     * @param sysUser
     * @return
     */
    HttpResult checkChuDanUser(SysUser sysUser) {
        if (StringUtils.isEmpty(sysUser.getReferrerId())) {
            return HttpResult.error("业务员工号不能为空");
        }
        //归属业务员和出单员部门必须一致
        SysUser user = getById(sysUser.getReferrerId());
        if (user == null || !user.getDeptId().equals(sysUser.getDeptId())) {
            return HttpResult.error("出单员机构必须和归属业务员机构一致");
        }
        sysUser.setOperatorCode(sysUser.getReferrerId());
        if (StringUtils.isEmpty(sysUser.getId())) {
            String userId = gainNextUserId(sysUser.getDeptId());
            sysUser.setId(userId);
            save(sysUser);
            //角色配置
            SysUserRole userRole = new SysUserRole();
            userRole.setUserId(sysUser.getId());
            userRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
            sysUserRoleService.save(userRole);
        } else {
            updateById(sysUser);
        }

        return HttpResult.ok("操作成功");
    }

    @Override
    @Transactional
    public HttpResult updateUserInfo(String userId, SysUser2Vo sysUserVo) {
        SysUser sysUser = sysUserVo.getSysUser();
        int beStatus = sysUser.getStatus();
        //如果审核驳回则 重新修改为 审核状态
        if (sysUserVo.getSysUser().getStatus().equals(UserWorkStatus.UWS_3.getCode())) {
            sysUserVo.getSysUser().setStatus(UserWorkStatus.UWS_2.getCode());
        }

        if (Objects.equals(sysUserVo.getSysUser().getStatus(), UserWorkStatus.UWS_5.getCode())) {
            sysUserVo.getSysUser().setStatus(UserWorkStatus.UWS_4.getCode());
        }

        if (Objects.equals(sysUserVo.getSysUser().getStatus(), UserWorkStatus.UWS_7.getCode())
                || Objects.equals(sysUserVo.getSysUser().getStatus(), UserWorkStatus.UWS_1.getCode())) {
            sysUserVo.getSysUser().setStatus(UserWorkStatus.UWS_6.getCode());
        }

        //修改用户不能修改密码
        if (StringUtils.isEmpty(sysUser.getPassword())) {
            return HttpResult.error("密码不能为空");
        }

        //删除状态必须有离司时间
        if (StringUtils.isNotEmpty(sysUser.getStatus().toString())) {
            if (sysUser.getStatus() == 0 && sysUser.getLogoutTime() == null && !sysUser.getRoleId().equals("19")) {
                return HttpResult.error("删除状态，离职时间必填");
            }
        } else {
            return HttpResult.error("状态不能为空");
        }
        SysUser sysUser_org = findByUserId(sysUser.getId());

        // 修改密码数据库相同不做修改
        if (!sysUser_org.getPassword().equals(sysUser.getPassword())) {
            String salt = PasswordUtils.getSalt();
            String pwd = PasswordUtils.encode(sysUser.getPassword(), salt);
            sysUser.setPassword(pwd);
            sysUser.setSalt(salt);
        } else {
            sysUser.setPassword(sysUser_org.getPassword());
            sysUser.setSalt(sysUser_org.getSalt());
        }
        if ("19".equals(sysUser.getRoleId())) {//19 出单员 校验机构和业务员机构是否一致
            // add by  hxl  2024-08-20
            // return checkChuDanUser(sysUser);
            if (StringUtils.isEmpty(sysUser.getReferrerId())) {
                return HttpResult.error("业务员工号不能为空");
            }
            //归属业务员和出单员部门必须一致
            SysUser user = getById(sysUser.getReferrerId());
            if (user == null || !user.getDeptId().equals(sysUser.getDeptId())) {
                return HttpResult.error("出单员机构必须和归属业务员机构一致");
            }
            sysUser.setOperatorCode(sysUser.getReferrerId());
            if (StringUtils.isEmpty(sysUser.getId())) {
                userId = gainNextUserId(sysUser.getDeptId());
                sysUser.setId(userId);
                save(sysUser);
                //角色配置
                SysUserRole userRole = new SysUserRole();
                userRole.setUserId(sysUser.getId());
                userRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
                sysUserRoleService.save(userRole);
            } else {
                userId = sysUser.getId();
                updateById(sysUser);
            }

            if(StringUtils.isEmpty(sysUser.getLeaderId())){
                SysUser leaderUser = baseMapper.getByRoleIdAndDeptId("21", sysUser.getDeptId());
                sysUser.setLeaderId(leaderUser.getLeaderId());
                sysUser.setLeaderName(leaderUser.getLeaderName());
            }


            SysUserInfo sysUserInfo = sysUserVo.getSysUserInfo();
            sysUserInfo.setId(userId);
            sysUserInfoService.saveOrUpdate(sysUserInfo);
        } else {
            sysUser.setStatus(sysUserVo.getSysUser().getStatus());
            updateById(sysUser);

            SysDept sysDept = sysDeptService.getById(sysUser.getDeptId());
            // 渠道负责人更新数据
            if (ManagementSource.MS_01.getCode().equals(sysDept.getManagementSource()) && "21".equals(sysUser.getRoleId())) {
                boolean update = lambdaUpdate()
                        .set(SysUser::getLeaderId, sysUser.getLeaderId())
                        .set(SysUser::getLeaderName, sysUser.getLeaderName())
                        .eq(SysUser::getDeptId, sysDept.getId())
                        .update();
                AssertionUtils.isSucceed(update, "出单员数据更新失败");
            }

            //角色配置
            SysUserRole sysUserRole = sysUserRoleService.selectByUserId(userId);
            sysUserRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
            sysUserRole.setLastUpdateBy(sysUser.getCreateBy());
            sysUserRole.setLastUpdateTime(new Date());
            sysUserRoleService.updateById(sysUserRole);

            if (StringUtils.isNotEmpty(sysUser.getReferrerId())) {
                //推荐人
                esmUserReferrerService.addReferrer(sysUser.getReferrerId(), userId);
            }

            //用户详情信息
            SysUserInfo sysUserInfo = sysUserVo.getSysUserInfo();
            if (null != sysUserInfo.getLiveAddressString() && sysUserInfo.getLiveAddressString().length > 0) {
                sysUserVo.getSysUserInfo().setLiveAddress(Arrays.stream(sysUserInfo.getLiveAddressString()).map(item -> item.toString()).collect(Collectors.joining(",")));
            }
            sysUserInfo.setId(userId);
            if (null == sysUserInfo.getRemark()) {
                sysUserInfo.setRemark("");
            }
            sysUserInfoService.saveOrUpdate(sysUserInfo);
        }
        // 影像资料
        LambdaQueryWrapper<EsmUserImage> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EsmUserImage::getUserId, userId);
        esmUserImageService.remove(wrapper);

        List<EsmUserImageVo> esmUserImageVo = sysUserVo.getEsmUserImageVo();
        String finalUserId = userId;
        List<EsmUserImage> esmUserImages = esmUserImageVo.stream().map(x -> new EsmUserImage(x, finalUserId)).collect(Collectors.toList());
        esmUserImageService.saveBatch(esmUserImages);

        if (UserWorkStatus.UWS_5.getCode() == beStatus ||
                UserWorkStatus.UWS_3.getCode() == beStatus ||
                UserWorkStatus.UWS_7.getCode() == beStatus) {
            //添加轨迹
            SysUserTrack sysUserTrack = new SysUserTrack();
            sysUserTrack.setUserId(sysUser.getId());
            SysUser user = BaseController.getUser();
            sysUserTrack.setApproveBy(user.getName());
            sysUserTrack.setApproveById(user.getId());
            sysUserTrack.setStatus(sysUserVo.getSysUser().getStatus());
            sysUserTrack.setApproveTime(new Date());
            sysUserTrackService.save(sysUserTrack);
        }
        SpringUtil.getBean(RecordUserUtils.class).recordUser(sysUserVo, BaseController.getUserName());

        return HttpResult.ok("修改成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public HttpResult updateUserInfo1(String userId, SysUser2Vo sysUserVo) {
        SysUser sysUser = sysUserVo.getSysUser();
        int beStatus = sysUser.getStatus();
        //如果审核驳回则 重新修改为 审核状态
        if (sysUserVo.getSysUser().getStatus().equals(UserWorkStatus.UWS_3.getCode())) {
            sysUserVo.getSysUser().setStatus(UserWorkStatus.UWS_2.getCode());
        }

        if (Objects.equals(sysUserVo.getSysUser().getStatus(), UserWorkStatus.UWS_5.getCode())) {
            sysUserVo.getSysUser().setStatus(UserWorkStatus.UWS_4.getCode());
        }

        if (Objects.equals(sysUserVo.getSysUser().getStatus(), UserWorkStatus.UWS_7.getCode())
                || Objects.equals(sysUserVo.getSysUser().getStatus(), UserWorkStatus.UWS_1.getCode())) {
            sysUserVo.getSysUser().setStatus(UserWorkStatus.UWS_6.getCode());
        }

        //修改用户不能修改密码
        if (StringUtils.isEmpty(sysUser.getPassword())) {
            return HttpResult.error("密码不能为空");
        }

        //删除状态必须有离司时间
        if (StringUtils.isNotEmpty(sysUser.getStatus().toString())) {
            if (sysUser.getStatus() == 0 && sysUser.getLogoutTime() == null && !sysUser.getRoleId().equals("19")) {
                return HttpResult.error("删除状态，离职时间必填");
            }
        } else {
            return HttpResult.error("状态不能为空");
        }
        SysUser sysUser_org = findByUserId(sysUser.getId());

        // 修改密码数据库相同不做修改
        if (!sysUser_org.getPassword().equals(sysUser.getPassword())) {
            String salt = PasswordUtils.getSalt();
            String pwd = PasswordUtils.encode(sysUser.getPassword(), salt);
            sysUser.setPassword(pwd);
            sysUser.setSalt(salt);
        } else {
            sysUser.setPassword(sysUser_org.getPassword());
            sysUser.setSalt(sysUser_org.getSalt());
        }
        if ("19".equals(sysUser.getRoleId())) {//19 出单员 校验机构和业务员机构是否一致
            // add by  hxl  2024-08-20
            // return checkChuDanUser(sysUser);
            if (StringUtils.isEmpty(sysUser.getReferrerId())) {
                return HttpResult.error("业务员工号不能为空");
            }
            //归属业务员和出单员部门必须一致
            SysUser user = getById(sysUser.getReferrerId());
            if (user == null || !user.getDeptId().equals(sysUser.getDeptId())) {
                return HttpResult.error("出单员机构必须和归属业务员机构一致");
            }
            sysUser.setOperatorCode(sysUser.getReferrerId());
            if (StringUtils.isEmpty(sysUser.getId())) {
                userId = gainNextUserId(sysUser.getDeptId());
                sysUser.setId(userId);
                save(sysUser);
                //角色配置
                SysUserRole userRole = new SysUserRole();
                userRole.setUserId(sysUser.getId());
                userRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
                sysUserRoleService.save(userRole);
            } else {
                userId = sysUser.getId();
                updateById(sysUser);
            }

            if(StringUtils.isEmpty(sysUser.getLeaderId())){
                SysUser leaderUser = baseMapper.getByRoleIdAndDeptId("21", sysUser.getDeptId());
                sysUser.setLeaderId(leaderUser.getLeaderId());
                sysUser.setLeaderName(leaderUser.getLeaderName());
            }

            SysUserInfo sysUserInfo = sysUserVo.getSysUserInfo();
            sysUserInfo.setId(userId);
            sysUserInfoService.saveOrUpdate(sysUserInfo);
        } else {

            SysDept sysDept = sysDeptService.getById(sysUser.getDeptId());
            // 渠道负责人更新数据
            if (ManagementSource.MS_01.getCode().equals(sysDept.getManagementSource()) && "21".equals(sysUser.getRoleId())) {
                boolean update = lambdaUpdate()
                        .set(SysUser::getLeaderId, sysUser.getLeaderId())
                        .set(SysUser::getLeaderName, sysUser.getLeaderName())
                        .eq(SysUser::getDeptId, sysDept.getId())
                        .update();
                AssertionUtils.isSucceed(update, "出单员数据更新失败");
            }

            sysUser.setStatus(sysUserVo.getSysUser().getStatus());
            // 设置跳过填充
            CreateAndUpdateMetaObjectHandler.setSkipFill(true);
            updateById(sysUser);
            // 清理跳过标志
            CreateAndUpdateMetaObjectHandler.clearSkipFlag();

            //角色配置
            SysUserRole sysUserRole = sysUserRoleService.selectByUserId(userId);
            sysUserRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
            sysUserRole.setLastUpdateBy(sysUser.getCreateBy());
            sysUserRole.setLastUpdateTime(new Date());
            sysUserRoleService.updateById(sysUserRole);

            if (StringUtils.isNotEmpty(sysUser.getReferrerId())) {
                //推荐人
                esmUserReferrerService.addReferrer(sysUser.getReferrerId(), userId);
            }

            //用户详情信息
            SysUserInfo sysUserInfo = sysUserVo.getSysUserInfo();
            if (null != sysUserInfo.getLiveAddressString() && sysUserInfo.getLiveAddressString().length > 0) {
                sysUserVo.getSysUserInfo().setLiveAddress(Arrays.stream(sysUserInfo.getLiveAddressString()).map(item -> item.toString()).collect(Collectors.joining(",")));
            }
            sysUserInfo.setId(userId);
            if (null == sysUserInfo.getRemark()) {
                sysUserInfo.setRemark("");
            }
            sysUserInfoService.saveOrUpdate(sysUserInfo);
        }
        // 影像资料
        LambdaQueryWrapper<EsmUserImage> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EsmUserImage::getUserId, userId);
        esmUserImageService.remove(wrapper);

        List<EsmUserImageVo> esmUserImageVo = sysUserVo.getEsmUserImageVo();
        String finalUserId = userId;
        List<EsmUserImage> esmUserImages = esmUserImageVo.stream().map(x -> new EsmUserImage(x, finalUserId)).collect(Collectors.toList());
        esmUserImageService.saveBatch(esmUserImages);

        if (UserWorkStatus.UWS_5.getCode() == beStatus ||
                UserWorkStatus.UWS_3.getCode() == beStatus ||
                UserWorkStatus.UWS_7.getCode() == beStatus) {
            //添加轨迹
            SysUserTrack sysUserTrack = new SysUserTrack();
            sysUserTrack.setUserId(sysUser.getId());
            sysUserTrack.setApproveBy(null);
            sysUserTrack.setApproveById(null);
            sysUserTrack.setStatus(sysUserVo.getSysUser().getStatus());
            sysUserTrack.setApproveTime(new Date());
            sysUserTrackService.save(sysUserTrack);
        }
        SpringUtil.getBean(RecordUserUtils.class).recordUser(sysUserVo, userId);

        return HttpResult.ok("修改成功");
    }

    @Override
    public List<SysUser> findAllAgentRoleUser(String userId, String roleId) {
        return super.baseMapper.findAllAgentRoleUser(userId, roleId);
    }

    @Override
    public int getDeptLevel(SysUser2Vo sysUser2Vo) {
        //获取机构层级
        SysUser sysUser = sysUser2Vo.getSysUser();
        String deptId = sysUser.getDeptId();
        int level = 0;
        //1 2 3 4 5级 M 6级 D
        if (deptId.length() > 8) {
            String substring = deptId.substring(8);
            return substring.length() / 3 + 4;
        } else {
            level = deptId.length() / 2;
        }
        return level;
    }

    @Override
    public int getDeptLevel1(String deptId) {
        int level = 0;
        //1 2 3 4 5级 M 6级 D
        if (deptId.length() > 8) {
            String substring = deptId.substring(8);
            return substring.length() / 3 + 4;
        } else {
            level = deptId.length() / 2;
        }
        return level;
    }

    /**
     * 根据机构代码，查询所有人员
     *
     * @param deptId
     * @return
     */
    @Override
    public List<SysUser> findUserList(String deptId) {
        LambdaQueryWrapper<SysUser> lqw = new LambdaQueryWrapper<>();
        lqw.eq(SysUser::getStatus, "1");
        lqw.eq(SysUser::getDeptId, deptId);
        return list(lqw);
    }


    /**
     * 查找组织结构树，返回所有层级的用户列表，其中每个用户包含其直接下级用户。
     * 该方法首先根据当前用户获取其在组织结构展示中的级别，然后根据这个级别查询或构建相应的组织结构树。
     *
     * @return 返回组织结构树形式的用户列表，每个用户对象可能包含一个子用户列表。
     */
    @Override
    public List<SysUser> findTree() {
        // 获取当前登录用户
        SysUser user = BaseController.getUser();
        String userId = user.getId();

        // 根据当前用户ID查询其在组织结构展示中的级别
        LambdaQueryWrapper<SysUserTreeShowLevel> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(SysUserTreeShowLevel::getUserId, userId);
        SysUserTreeShowLevel treeShowLevel = sysUserTreeShowLevelService.getOne(lambdaQueryWrapper);

        //如果当前用户未配置树展示等级，则默认为查询本级及以下
        if (Objects.isNull(treeShowLevel)) {
            treeShowLevel = new SysUserTreeShowLevel();
            treeShowLevel.setShowLevel("subordinate");
        }
        //获取领导字段不为空的人的ID
        List<SysUser> users = lambdaQuery()
                .isNotNull(SysUser::getLeaderId)
                .ne(SysUser::getStatus, 0)
                .list();
        System.out.println(JSONObject.toJSONString(users));

        if (users == null || users.size() == 0) {
            return new ArrayList<>();
        }
        List<SysUser> topUsers = new ArrayList<>(); //存放1级用户,即没有直接上级的用户

        // 获取可能作为顶层节点的用户ID列表
        List<String> topUserId = users.stream().map(SysUser::getLeaderId).collect(Collectors.toList());

        List<SysUser> list2 = lambdaQuery().in(SysUser::getId, topUserId).list();

        List<String> strings = list2.stream().map(SysUser::getId).collect(Collectors.toList());
        // 根据组织结构展示级别，筛选顶层节点并构建组织结构树
        switch (treeShowLevel.getShowLevel()) {
            case "all": // 展示所有级别的用户
                // 从查询结果中筛选出没有上级的人员，作为组织结构树的顶层节点
                for (SysUser sysUser : list2) {
                    if (Objects.isNull(sysUser.getLeaderId())) {
                        topUsers.add(sysUser);
                    }
                }
                // 递归构建用户树结构
                buildUserTree(topUsers, users);
                break;
            case "same": // 只展示当前用户
//                for (String ids : strings) {
//                    if (ids.equals(userId)) {
                topUsers.add(user);
//                    }
//                }
                break;
            case "subordinate": // 只展示当前用户及下属
//                for (String ids : strings) {
//                    if (ids.equals(userId)) {
                topUsers.add(user);
//                    }
//                }
                // 递归构建用户树结构
                buildUserTree(topUsers, users);
                break;
        }
        return topUsers;
    }


    /**
     * 根据部门ID查询后台用户列表。
     *
     * @param deptId 部门ID，用于筛选指定部门的用户。
     * @return 返回一个SysUser类型的列表，包含指定部门的所有后台用户。
     */
    @Override
    public List<SysUser> findBackListByDeptId(String deptId) {
        return baseMapper.findBackListByDeptId(deptId);
    }


    /**
     * 查询用户订单数量进行区域统计信息
     *
     * @param quUserNumDto 包含查询条件和分页信息的数据传输对象
     * @return IPage<QuUserNum> 返回用户数量统计信息的分页对象
     */
    @Override
    public IPage<QuUserNum> quUserNum(QuUserNumDto quUserNumDto) {

        if (StringUtils.isNotEmpty(quUserNumDto.getCreateTimeStart()) && StringUtils.isNotEmpty(quUserNumDto.getCreateTimeEnd())) {
            quUserNumDto.setCreateTimeStart(quUserNumDto.getCreateTimeStart() + " 00:00:00");
            quUserNumDto.setCreateTimeEnd(quUserNumDto.getCreateTimeEnd() + " 23:59:59");
        }

        //获取所有用户
        List<SysUser> users = list();

        // 根据用户ID查询一级下屬
        LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SysUser::getId, quUserNumDto.getUserId());
        List<SysUser> usersLevel1 = list(queryWrapper);

        //递归获取1级下属下所有的下属ID
        List<String> strIds = new ArrayList<>();
        findChildren(usersLevel1, users, strIds);

        // 根据区域编码和级别查询符合条件的区域
        LambdaQueryWrapper<SysArea> wrapper = new LambdaQueryWrapper<>();
        if (quUserNumDto.getAreaCode() != null && !"".equals(quUserNumDto.getAreaCode())) {
            String area = quUserNumDto.getAreaCode();
            switch (quUserNumDto.getLevel()) {
                case "1": { // 省级查询逻辑
                    quUserNumDto.setGrouping(4);
                    String prefix = area.substring(0, 2);
                    strIds.removeIf(id -> !id.contains("99" + prefix));
                    quUserNumDto.setLevel("2");
                    wrapper.eq(SysArea::getLevel, "2");
                    wrapper.likeRight(SysArea::getAreaCode, prefix);
                    break;
                }
                case "2": {  // 市级查询逻辑
                    quUserNumDto.setGrouping(6);
                    String prefix = area.substring(0, 4);
                    strIds.removeIf(id -> !id.contains("99" + prefix));
                    quUserNumDto.setLevel("3");
                    wrapper.eq(SysArea::getLevel, "3");
                    wrapper.likeRight(SysArea::getAreaCode, prefix);
                    break;
                }
                case "3": {  // 区县级查询逻辑
                    quUserNumDto.setGrouping(6);
                    String prefix = area.substring(0, 6);
                    strIds.removeIf(id -> !id.contains("99" + prefix));
                    quUserNumDto.setLevel("3");
                    wrapper.eq(SysArea::getLevel, "3");
                    wrapper.likeRight(SysArea::getAreaCode, prefix);
                    break;
                }
            }
        } else { // 默认查询省级区域
            quUserNumDto.setGrouping(2);
            quUserNumDto.setLevel("1");
            wrapper.eq(SysArea::getLevel, "1");
        }
        //遍历匹配区域名称
        List<SysArea> areaList = sysAreaService.list(wrapper);

        List<QuUserNum> quUserNums = new ArrayList<>();

        // 如果没有查询到用户ID，则直接返回空的分页对象
        if (strIds.size() != 0) {
            // 根据查询条件获取用户数量统计信息
            quUserNumDto.setUserIds(strIds);
            List<QuUserNum> userNums = sysUserMapper.getUserNum(quUserNumDto);
            // 获取地区主订单待核保订单数量
            List<QuUserNum> mainWaitAuditSums = sysUserMapper.getMainWaitAuditSum(quUserNumDto);
            // 获取地区主订单已核保待缴费订单数量
            List<QuUserNum> mainWaitPaySums = sysUserMapper.getMainWaitPaySum(quUserNumDto);
            // 获取地区主订单已承包订单数量
            List<QuUserNum> mainAcceptInsuranceSums = sysUserMapper.getMainAcceptInsuranceSum(quUserNumDto);
            // 根据区域名称匹配用户数量统计信息，并构造最终返回的结果列表
            for (QuUserNum quUserNum : userNums) {
                for (SysArea sysArea : areaList) {
                    if (!Objects.isNull(sysArea.getAreaCode())) {
                        // 匹配区域名称
                        String substring = sysArea.getAreaCode().substring(0, quUserNumDto.getGrouping());
                        if (quUserNum.getAreaCode().equals(substring)) {
                            quUserNum.setAreaName(sysArea.getAreaCname());
                        }
                    }
                }

                for (QuUserNum mainWaitAuditSum : mainWaitAuditSums) {
                    if (quUserNum.getAreaCode().equals(mainWaitAuditSum.getAreaCode())) {
                        quUserNum.setMainWaitAuditSum(mainWaitAuditSum.getMainWaitAuditSum());
                    }
                }
                for (QuUserNum mainWaitPaySum : mainWaitPaySums) {
                    if (quUserNum.getAreaCode().equals(mainWaitPaySum.getAreaCode())) {
                        quUserNum.setMainWaitPaySum(mainWaitPaySum.getMainWaitPaySum());
                    }
                }
                for (QuUserNum mainAcceptInsuranceSum : mainAcceptInsuranceSums) {
                    if (quUserNum.getAreaCode().equals(mainAcceptInsuranceSum.getAreaCode())) {
                        quUserNum.setMainAcceptInsuranceSum(mainAcceptInsuranceSum.getMainAcceptInsuranceSum());
                    }
                }
                if (quUserNum.getAreaName() != null) {
                    quUserNums.add(quUserNum);
                }
//                quUserNums.add(quUserNum);
            }
        }

        // 为每个区域生成未匹配到的统计信息
        for (SysArea sysArea : areaList) {
            if (exists(quUserNums, sysArea)) {
                QuUserNum userNum = new QuUserNum();
                // 设置未匹配到的区域的默认统计信
                userNum.setAreaName(sysArea.getAreaCname());
                quUserNums.add(userNum);
            }
        }
        List<QuUserNum> paginate = paginate(quUserNums, quUserNumDto.getPageNum(), quUserNumDto.getPageSize());

        // 构造返回的分页对象
        IPage<QuUserNum> recordsPage = new Page<>(quUserNumDto.getPageNum(), quUserNumDto.getPageSize());
        recordsPage.setRecords(paginate);
        recordsPage.setTotal(quUserNums.size());
        return recordsPage;
    }


    /**
     * 查询用户订单数量进行区域统计详细信息
     *
     * @param quUserNumDto 包含查询条件和分页信息的数据传输对象
     * @return IPage<QuUserNum> 返回用户数量统计信息的分页对象
     */
    @Override
    public IPage<QuUserNum> getQuUserByCompany(QuUserNumDto quUserNumDto) {
        if (StringUtils.isNotEmpty(quUserNumDto.getCreateTimeStart()) && StringUtils.isNotEmpty(quUserNumDto.getCreateTimeEnd())) {
            quUserNumDto.setCreateTimeStart(quUserNumDto.getCreateTimeStart() + " 00:00:00");
            quUserNumDto.setCreateTimeEnd(quUserNumDto.getCreateTimeEnd() + " 23:59:59");
        }

        //查询单个用户的详情时不需要区域code
        if (!quUserNumDto.getQuMarks().equals(QuMarks.USER_COMPANY_MARK.getCode())) {
            // 获取系统中的所有用户
            List<SysUser> users = list();

            // 创建查询包装器，用于查询指定用户ID的用
            LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(SysUser::getId, quUserNumDto.getUserId());
            // 查询指定用户ID的用户，即第一级下属
            List<SysUser> usersLevel1 = list(queryWrapper);

            // 用于存储所有下属的ID
            List<String> strIds = new ArrayList<>();
            // 递归获取第一级下属及其所有下属的ID
            findChildren(usersLevel1, users, strIds);
            // 如果未指定区域码，返回空分页对
            if (Objects.isNull(quUserNumDto.getAreaCode())) {
                return new Page<>();
            }
            // 根据区域码筛选有效的下属ID
            strIds.removeIf(id -> !id.contains("99" + quUserNumDto.getAreaCode()));
            // 如果筛选后没有有效的下属ID，返回空分页对象
            if (strIds.size() == 0) {
                return new Page<>();
            }
            // 设置查询条件中的用户ID列表
            quUserNumDto.setUserIds(strIds);
        } else {
            // 设置查询条件中的用户ID列表
            quUserNumDto.setUserIds(Collections.singletonList(quUserNumDto.getUserId()));
        }

        List<QuUserNum> deptByCompany = agentOrChannelByMark(quUserNumDto);

        List<QuUserNum> paginate = paginate(deptByCompany, quUserNumDto.getPageNum(), quUserNumDto.getPageSize());

        // 创建并设置分页信息
        IPage<QuUserNum> page = new Page<>(quUserNumDto.getPageNum(), quUserNumDto.getPageSize());
        page.setRecords(paginate);
        page.setTotal(deptByCompany.size());
        return page;
    }


    /**
     * 手动对 QuUserNum 列表进行分页
     *
     * @param quUserNums 原始 QuUserNum 数据列表
     * @param pageNum    期望获取的页码（从 1 开始）
     * @param pageSize   每页包含的 QuUserNum 数量
     * @return 对应页码的 QuUserNum 子列表，若输入参数无效则返回空列表
     */
    public List<QuUserNum> paginate(List<QuUserNum> quUserNums, int pageNum, int pageSize) {
        if (quUserNums == null || quUserNums.isEmpty() || pageNum < 1 || pageSize < 1) {
            return Collections.emptyList();
        }

        int startIndex = (pageNum - 1) * pageSize;
        int endIndex = Math.min(startIndex + pageSize, quUserNums.size());

        return quUserNums.subList(startIndex, endIndex);
    }


    private void findChildren(List<SysUser> SysUsers, List<SysUser> users, List<String> strIds) {
        for (SysUser sysUser : SysUsers) {
            List<SysUser> children = new ArrayList<>();
            for (SysUser user : users) {
                if (sysUser.getId() != null && sysUser.getId().equals(user.getLeaderId())) {
                    if (!exists(children, user)) {
                        children.add(user);
                        strIds.add(user.getId());
                    }
                }
            }
            sysUser.setChildren(children);
//            children.sort((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()));
            findChildren(children, users, strIds);
        }
    }


    private boolean exists(List<QuUserNum> quUserNums, SysArea sysArea) {
        boolean exist = true;
        for (QuUserNum quUserNum1 : quUserNums) {
            if (sysArea.getAreaCname().equals(quUserNum1.getAreaName())) {
                exist = false;
                break;
            }
        }
        return exist;
    }

    private boolean exists(List<SysUser> sysUsers, SysUser sysUser) {
        boolean exist = false;
        for (SysUser user : sysUsers) {
            if (user.getId().equals(sysUser.getId())) {
                exist = true;
            }
        }
        return exist;
    }

    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()) && !childUser.getId().contains("M")) {
                    children.add(childUser);
                    // 递归查找下一级
                    buildUserTree(children, users);
                }
            }
            user.setChildren(children);
        }
    }


    /**
     * @version
     * @author: hxl
     * @Date: 2024/4/16 15:51
     * @Description: 获取待客录入的可选业务员
     * 查询
     */
    @Override
    public List<SysUserBaseVO> getAllUsersByHospitality(SysUserVOExt sysUserVOExt) {
        if (StringUtils.isNotEmpty(sysUserVOExt.getUserId()) || StringUtils.isNotEmpty(sysUserVOExt.getIdentity()) ||
                StringUtils.isNotEmpty(sysUserVOExt.getMobile()) || StringUtils.isNotEmpty(sysUserVOExt.getName())) {
            List<SysUserBaseVO> allUsersByHospitality = super.baseMapper.getAllUsersByHospitality(sysUserVOExt);
            //数据隔离操作
            List<SysUserBaseVO> divideUserInfo = this.dataDivide(allUsersByHospitality);
            return divideUserInfo;
        }
        return new ArrayList<SysUserBaseVO>();
    }

    private List<SysUserBaseVO> dataDivide(List<SysUserBaseVO> allUsersByHospitality) {
        List<SysUser> userList = new ArrayList<>();
        SysUser landerInfo = BaseController.getUser();
        //超级管理员不做处理
        if ("admin".equals(landerInfo.getId()) || "99D1501".equals(landerInfo.getId())) {
            return allUsersByHospitality;
        }

        //获取查询结果id
        List<String> userIds = new ArrayList<>();
        //如果登陆者部门所属总裁办,则进行是否是运营中心领导人逻辑的判断
        if ("99D15".equals(landerInfo.getDeptId())) {
            //判断登陆者下属是否所属运营中心
            LambdaQueryWrapper<SysUser> getLanderBranch = new LambdaQueryWrapper<>();
            getLanderBranch.notLike(SysUser::getId, "M")
                    .eq(SysUser::getDeptId, "9914D18")
                    .eq(SysUser::getLeaderId, landerInfo.getId());
            List<SysUser> sysUserList = list(getLanderBranch);

            if (StringUtils.isNullOrEmpty(sysUserList) || sysUserList.isEmpty()) {
                //如果不属于运营中心则不展示数据
                return new ArrayList<>();
            }
            userIds.add(landerInfo.getId());
            //获取运营中心全部员工
            LambdaQueryWrapper<SysUser> getOperationUser = new LambdaQueryWrapper<>();
            getOperationUser.notLike(SysUser::getId, "M")
                    .eq(SysUser::getDeptId, "9914D18")
                    .isNotNull(SysUser::getLeaderId);
            userList.addAll(list(getOperationUser));
        } else if ("9914D18".equals(landerInfo.getDeptId())) {
            //查询登陆者组长信息
            List<SysUser> sysUsers = super.baseMapper.selectLeaderBylanderInfo(landerInfo.getDeptId(), null, landerInfo.getLeaderId());
            if (StringUtils.isNullOrEmpty(sysUsers) || sysUsers.size() < 1) {
                userIds.add(landerInfo.getId());
                //为空则登陆者为组长,id当做leaderID查询
                sysUsers = super.baseMapper.selectLeaderBylanderInfo(landerInfo.getDeptId(), landerInfo.getId(), null);
                userList.addAll(sysUsers);
            } else {
                SysUser sysUser = sysUsers.get(0);
                userList.add(sysUser);
                List<SysUser> sysUserList = super.baseMapper.selectLeaderBylanderInfo(landerInfo.getDeptId(), landerInfo.getLeaderId(), null);
                userList.addAll(sysUserList);
            }
        } else {
            //如果不属于运营中心则不展示数据
            return new ArrayList<>();
        }

        //获取查询结果id
         userIds.addAll(userList.stream()
                .filter(user -> !StringUtils.isNullOrEmpty(user) && StringUtils.isNotEmpty(user.getId()))
                .map(SysUser::getId)
                .collect(Collectors.toList()));

        List<SysUserBaseVO> divideUserInfo = allUsersByHospitality.stream()
                .filter(allUser -> !StringUtils.isNullOrEmpty(allUser) && StringUtils.isNotEmpty(allUser.getLeaderId())
                        && userIds.contains(allUser.getLeaderId()))
                .collect(Collectors.toList());

        return divideUserInfo;
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/4/18 16:14
     * @Description: 获取客服人员列表数据
     */
    @Override
    public List<SysUserBaseVO> getCustomerUsers() {
        return super.baseMapper.getCustomerUsers(new SysUserVOExt());
    }

    @Override
    public IPage<QuUserNum> quAgentAreaAdmin(QuUserNumDto quUserNumDto) {

        if (StringUtils.isNotEmpty(quUserNumDto.getCreateTimeStart()) && StringUtils.isNotEmpty(quUserNumDto.getCreateTimeEnd())) {
            quUserNumDto.setCreateTimeStart(quUserNumDto.getCreateTimeStart() + " 00:00:00");
            quUserNumDto.setCreateTimeEnd(quUserNumDto.getCreateTimeEnd() + " 23:59:59");
        }


        //获取所有代理人用户
        List<SysUserBaseVO> agentUsers = baseMapper.getAgentUserIdsByAreaIds();

        List<String> strIds = agentUsers.stream().map(SysUserBaseVO::getUserId).collect(Collectors.toList());

        // 根据区域编码和级别查询符合条件的区域
        LambdaQueryWrapper<SysArea> wrapper = new LambdaQueryWrapper<>();
        if (strIds.size() != 0) {
            if (quUserNumDto.getAreaCode() != null && !"".equals(quUserNumDto.getAreaCode())) {
                String area = quUserNumDto.getAreaCode();
                switch (quUserNumDto.getLevel()) {
                    case "1": { // 省级查询逻辑
                        quUserNumDto.setGrouping(4);
                        String prefix = area.substring(0, 2);
                        strIds.removeIf(id -> !id.contains("99" + prefix));
                        quUserNumDto.setLevel("2");
                        wrapper.eq(SysArea::getLevel, "2");
                        wrapper.likeRight(SysArea::getAreaCode, prefix);
                        break;
                    }
                    case "2": {  // 市级查询逻辑
                        quUserNumDto.setGrouping(6);
                        String prefix = area.substring(0, 4);
                        strIds.removeIf(id -> !id.contains("99" + prefix));
                        quUserNumDto.setLevel("3");
                        wrapper.eq(SysArea::getLevel, "3");
                        wrapper.likeRight(SysArea::getAreaCode, prefix);
                        break;
                    }
                    case "3": {  // 区县级查询逻辑
                        quUserNumDto.setGrouping(6);
                        String prefix = area.substring(0, 6);
                        strIds.removeIf(id -> !id.contains("99" + prefix));
                        quUserNumDto.setLevel("3");
                        wrapper.eq(SysArea::getLevel, "3");
                        wrapper.likeRight(SysArea::getAreaCode, prefix);
                        break;
                    }
                }
            } else { // 默认查询省级区域
                quUserNumDto.setGrouping(2);
                quUserNumDto.setLevel("1");
                wrapper.eq(SysArea::getLevel, "1");
            }
        }

        //遍历匹配区域名称
        List<SysArea> areaList = sysAreaService.list(wrapper);

        List<QuUserNum> quUserNums = new ArrayList<>();
        // 如果没有查询到用户ID，则直接返回空的分页对象
        if (strIds.size() != 0) {
            // 根据查询条件获取用户数量统计信息
            quUserNumDto.setUserIds(strIds);
            List<QuUserNum> userNums = sysUserMapper.getUserNum(quUserNumDto);

            // 获取地区主订单待核保订单数量
            List<QuUserNum> mainWaitAuditSums = sysUserMapper.getMainWaitAuditSum(quUserNumDto);
            // 获取地区主订单已核保待缴费订单数量
            List<QuUserNum> mainWaitPaySums = sysUserMapper.getMainWaitPaySum(quUserNumDto);
            // 获取地区主订单已承包订单数量
            List<QuUserNum> mainAcceptInsuranceSums = sysUserMapper.getMainAcceptInsuranceSum(quUserNumDto);
            // 根据区域名称匹配用户数量统计信息，并构造最终返回的结果列表
            for (QuUserNum quUserNum : userNums) {
                for (SysArea sysArea : areaList) {
                    if (!Objects.isNull(sysArea.getAreaCode())) {
                        // 匹配区域名称
                        String substring = sysArea.getAreaCode().substring(0, quUserNumDto.getGrouping());
                        if (quUserNum.getAreaCode().equals(substring)) {
                            quUserNum.setAreaName(sysArea.getAreaCname());
                        }
                    }
                }
                for (QuUserNum mainWaitAuditSum : mainWaitAuditSums) {
                    if (quUserNum.getAreaCode().equals(mainWaitAuditSum.getAreaCode())) {
                        quUserNum.setMainWaitAuditSum(mainWaitAuditSum.getMainWaitAuditSum());
                    }
                }
                for (QuUserNum mainWaitPaySum : mainWaitPaySums) {
                    if (quUserNum.getAreaCode().equals(mainWaitPaySum.getAreaCode())) {
                        quUserNum.setMainWaitPaySum(mainWaitPaySum.getMainWaitPaySum());
                    }
                }
                for (QuUserNum mainAcceptInsuranceSum : mainAcceptInsuranceSums) {
                    if (quUserNum.getAreaCode().equals(mainAcceptInsuranceSum.getAreaCode())) {
                        quUserNum.setMainAcceptInsuranceSum(mainAcceptInsuranceSum.getMainAcceptInsuranceSum());
                    }
                }
                quUserNums.add(quUserNum);
            }
        }
        // 为每个区域生成未匹配到的统计信息
        for (SysArea sysArea : areaList) {
            if (exists(quUserNums, sysArea)) {
                QuUserNum userNum = new QuUserNum();
                // 设置未匹配到的区域的默认统计信
                userNum.setAreaName(sysArea.getAreaCname());
                quUserNums.add(userNum);
            }
        }
        List<QuUserNum> paginate = paginate(quUserNums, quUserNumDto.getPageNum(), quUserNumDto.getPageSize());

        // 构造返回的分页对象
        IPage<QuUserNum> recordsPage = new Page<>(quUserNumDto.getPageNum(), quUserNumDto.getPageSize());
        recordsPage.setRecords(paginate);
        recordsPage.setTotal(quUserNums.size());
        return recordsPage;

    }

    @Override
    public IPage<QuUserNum> quAgentAreaAdminDetail(QuUserNumDto quUserNumDto) {

        if (StringUtils.isNotEmpty(quUserNumDto.getCreateTimeStart()) && StringUtils.isNotEmpty(quUserNumDto.getCreateTimeEnd())) {
            quUserNumDto.setCreateTimeStart(quUserNumDto.getCreateTimeStart() + " 00:00:00");
            quUserNumDto.setCreateTimeEnd(quUserNumDto.getCreateTimeEnd() + " 23:59:59");
        }

        //查询单个用户的详情时不需要区域code
        if (!quUserNumDto.getQuMarks().equals(QuMarks.USER_COMPANY_MARK.getCode())) {
            //获取所有代理人用户
            List<SysUserBaseVO> agentUsers = baseMapper.getAgentUserIdsByAreaIds();

            List<String> strIds = agentUsers.stream().map(SysUserBaseVO::getUserId).collect(Collectors.toList());

            // 如果未指定区域码，返回空分页对
            if (Objects.isNull(quUserNumDto.getAreaCode())) {
                return new Page<>();
            }

            // 根据区域码筛选有效的下属ID
            strIds.removeIf(id -> !id.contains("99" + quUserNumDto.getAreaCode()));

            // 如果筛选后没有有效的下属ID，返回空分页对象
            if (strIds.isEmpty()) {
                return new Page<>();
            }
            // 设置查询条件中的用户ID列表
            quUserNumDto.setUserIds(strIds);
        } else {
            // 设置查询条件中的用户ID列表
            quUserNumDto.setUserIds(Collections.singletonList(quUserNumDto.getUserId()));
        }

        List<QuUserNum> deptByCompany = agentOrChannelByMark(quUserNumDto);

        List<QuUserNum> paginate = paginate(deptByCompany, quUserNumDto.getPageNum(), quUserNumDto.getPageSize());

        // 创建并设置分页信息
        IPage<QuUserNum> page = new Page<>(quUserNumDto.getPageNum(), quUserNumDto.getPageSize());
        page.setRecords(paginate);
        page.setTotal(deptByCompany.size());
        return page;
    }


    public List<QuUserNum> agentOrChannelByMark(QuUserNumDto quUserNumDto) {

        List<QuUserNum> deptByCompany = new ArrayList<>();
        if (quUserNumDto.getQuMarks().equals(QuMarks.COMPANY_MARK.getCode())) {
            // 根据公司和用户ID列表查询用户数量统计信息
            deptByCompany = sysUserMapper.getUserByCompany(quUserNumDto);
            // 获取公司主订单待核保订单数量
            List<QuUserNum> mainWaitAuditSums = sysUserMapper.getComMainWaitAuditSum(quUserNumDto);
            // 获取公司主订单已核保待缴费订单数量
            List<QuUserNum> mainWaitPaySums = sysUserMapper.getComMainWaitPaySum(quUserNumDto);
            // 获取公司主订单已承包订单数量
            List<QuUserNum> mainAcceptInsuranceSums = sysUserMapper.getComMainAcceptInsuranceSum(quUserNumDto);

            for (QuUserNum quUserNum : deptByCompany) {
                for (QuUserNum mainWaitAuditSum : mainWaitAuditSums) {
                    if (quUserNum.getCompanyId().equals(mainWaitAuditSum.getCompanyId())) {
                        quUserNum.setMainWaitAuditSum(mainWaitAuditSum.getMainWaitAuditSum());
                    }
                }
                for (QuUserNum mainWaitPaySum : mainWaitPaySums) {
                    if (quUserNum.getCompanyId().equals(mainWaitPaySum.getCompanyId())) {
                        quUserNum.setMainWaitPaySum(mainWaitPaySum.getMainWaitPaySum());
                    }
                }
                for (QuUserNum mainAcceptInsuranceSum : mainAcceptInsuranceSums) {
                    if (quUserNum.getCompanyId().equals(mainAcceptInsuranceSum.getCompanyId())) {
                        quUserNum.setMainAcceptInsuranceSum(mainAcceptInsuranceSum.getMainAcceptInsuranceSum());
                    }
                }
            }

        } else if (quUserNumDto.getQuMarks().equals(QuMarks.USER_MARK.getCode())) {
            // 根据公司和用户ID列表查询用户数量统计信息
            deptByCompany = sysUserMapper.getUserDetail(quUserNumDto);

            // 获取用户主订单待核保订单数量
            List<QuUserNum> mainWaitAuditSums = sysUserMapper.getUserMainWaitAuditSum(quUserNumDto);
            // 获取用户主订单已核保待缴费订单数量
            List<QuUserNum> mainWaitPaySums = sysUserMapper.getUserMainWaitPaySum(quUserNumDto);
            // 获取用户主订单已承包订单数量
            List<QuUserNum> mainAcceptInsuranceSums = sysUserMapper.getUserMainAcceptInsuranceSum(quUserNumDto);

            for (QuUserNum quUserNum : deptByCompany) {
                for (QuUserNum mainWaitAuditSum : mainWaitAuditSums) {
                    if (quUserNum.getUserId().equals(mainWaitAuditSum.getUserId())) {
                        quUserNum.setMainWaitAuditSum(mainWaitAuditSum.getMainWaitAuditSum());
                    }
                }
                for (QuUserNum mainWaitPaySum : mainWaitPaySums) {
                    if (quUserNum.getUserId().equals(mainWaitPaySum.getUserId())) {
                        quUserNum.setMainWaitPaySum(mainWaitPaySum.getMainWaitPaySum());
                    }
                }
                for (QuUserNum mainAcceptInsuranceSum : mainAcceptInsuranceSums) {
                    if (quUserNum.getUserId().equals(mainAcceptInsuranceSum.getUserId())) {
                        quUserNum.setMainAcceptInsuranceSum(mainAcceptInsuranceSum.getMainAcceptInsuranceSum());
                    }
                }
            }
        } else if (quUserNumDto.getQuMarks().equals(QuMarks.USER_COMPANY_MARK.getCode())) {
            // 根据公司和用户ID列表查询用户数量统计信息
            deptByCompany = sysUserMapper.getUserByCompany(quUserNumDto);
            // 获取公司主订单待核保订单数量
            List<QuUserNum> mainWaitAuditSums = sysUserMapper.getComMainWaitAuditSum(quUserNumDto);
            // 获取公司主订单已核保待缴费订单数量
            List<QuUserNum> mainWaitPaySums = sysUserMapper.getComMainWaitPaySum(quUserNumDto);
            // 获取公司主订单已承包订单数量
            List<QuUserNum> mainAcceptInsuranceSums = sysUserMapper.getComMainAcceptInsuranceSum(quUserNumDto);

            for (QuUserNum quUserNum : deptByCompany) {
                for (QuUserNum mainWaitAuditSum : mainWaitAuditSums) {
                    if (quUserNum.getCompanyId().equals(mainWaitAuditSum.getCompanyId())) {
                        quUserNum.setMainWaitAuditSum(mainWaitAuditSum.getMainWaitAuditSum());
                    }
                }
                for (QuUserNum mainWaitPaySum : mainWaitPaySums) {
                    if (quUserNum.getCompanyId().equals(mainWaitPaySum.getCompanyId())) {
                        quUserNum.setMainWaitPaySum(mainWaitPaySum.getMainWaitPaySum());
                    }
                }
                for (QuUserNum mainAcceptInsuranceSum : mainAcceptInsuranceSums) {
                    if (quUserNum.getCompanyId().equals(mainAcceptInsuranceSum.getCompanyId())) {
                        quUserNum.setMainAcceptInsuranceSum(mainAcceptInsuranceSum.getMainAcceptInsuranceSum());
                    }
                }
            }
        }
        return deptByCompany;
    }


    /**
     * @version
     * @author: hxl
     * @Date: 2024/4/29 16:01
     * @Description: 查询当前登陆人管理的渠道人 即领导人为当前登陆人的用户需要递归查询
     */
    public List<String> getUserIdsByLeaderId(String userId) {
        // 获取系统中的所有用户
        LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SysUser::getStatus, 1);
        List<SysUser> allUsers = this.getBaseMapper().selectList(queryWrapper);
        // 查询指定用户ID管理的用户，即第一级下属
        queryWrapper.eq(SysUser::getId, userId);
        List<SysUser> leadUsers = this.getBaseMapper().selectList(queryWrapper);
        // 用于存储所有下属的ID
        List<String> strIds = new ArrayList<>();
        // 递归获取第一级下属及其所有下属的ID
        findChildren(leadUsers, allUsers, strIds);
        return strIds;
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/5/7 10:45
     * @Description: 通过部门id和角色id查询是否存在团队长
     */
    @Override
    public int getCountByDeptAndRoleId(SysUser sysUserVo) {
        return sysUserMapper.getCountByDeptAndRoleId(sysUserVo);
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/5/7 11:44
     * @Description: 查询该部门的团队长
     */
    @Override
    public String findTDZUserIdByDeptId(String deptId) {
        return sysUserMapper.findTDZUserIdByDeptId(deptId);
    }

    /**
     * 获取多条用户数据
     *
     * @param userIds 用户idList
     * @return
     */
    @Override
    public List<SysUser> getByIds(List<String> userIds) {
        LambdaQueryWrapper<SysUser> sysUserLambdaQueryWrapper = new LambdaQueryWrapper<>();
        sysUserLambdaQueryWrapper.in(SysUser::getId, userIds);
        return sysUserMapper.selectList(sysUserLambdaQueryWrapper);
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/7/11 16:08
     * @Description: 查询所有的后线人员
     */
    @Override
    public List<SysUser> findHxUserList() {
        return sysUserMapper.findHxUserList();
    }

    /**
     * 离职申请
     *
     * @param sysUserVO
     * @return
     */
    @Override
    @Transactional
    public boolean departApply(SysUser2Vo sysUserVO) {
        if (Objects.isNull(sysUserVO.getSysUser().getLogoutTime())) {
            throw new SystemException("请填写离职时间");
        }
        if (Objects.isNull(sysUserVO.getEsmUserImageVo()) && sysUserVO.getEsmUserImageVo().isEmpty()) {
            throw new SystemException("请上传离职证明");
        }
        SysUser byId = this.getById(sysUserVO.getSysUser().getId());
        byId.setLogoutTime(sysUserVO.getSysUser().getLogoutTime());
        byId.setStatus(UserWorkStatus.UWS_4.getCode());
        this.updateById(byId);

        //添加离职证明
        //判斷是否存在先刪除   add by hxl
        LambdaQueryWrapper<EsmUserImage> lqw = new LambdaQueryWrapper<>();
        lqw.eq(EsmUserImage::getUserId, sysUserVO.getSysUser().getId());
        lqw.eq(EsmUserImage::getType, InsuranceImageEnum.LZ_01.getCode());
        esmUserImageService.getBaseMapper().delete(lqw);

        EsmUserImageVo esmUserImageVo = sysUserVO.getEsmUserImageVo().get(0);
        esmUserImageVo.setType(InsuranceImageEnum.LZ_01.getCode());
        EsmUserImage esmUserImage = new EsmUserImage(esmUserImageVo, sysUserVO.getSysUser().getId());
        esmUserImageService.save(esmUserImage);

        //添加轨迹
        SysUserTrack sysUserTrack = new SysUserTrack(byId);
        sysUserTrackService.save(sysUserTrack);
        return true;
    }

    @Override
    public List<String> getUserIds() {
        return baseMapper.getUserIds();
    }

    @Override
    @Transactional
    public void separationReinstatement(String userid) {
        SysUser sysUser = getByIdExist(userid, "离职用户未查询到");
        sysUser.setStatus(UserWorkStatus.UWS_2.getCode());
        this.updateById(sysUser);
    }

    @Override
    public SysUser getByUserId(String userid) {
        return baseMapper.getByUserId(userid);
    }

    @Override
    public List<String> getTelemarketingPersonnelData() {
        return baseMapper.getTelemarketingPersonnelUserId();
    }

    @Override
    public List<SysUser> findNextTree() {
//        findTree
        // 获取当前登录用户
        SysUser user = BaseController.getUser();
        if ("admin".equals(user.getName())) {
            return this.findTree();
        } else {
            //获取领导字段不为空的人的ID
            QueryWrapper<SysUser> queryWrapper = new QueryWrapper<>();
            queryWrapper.isNotNull("leader_id")
                    .eq("status", "1");
            List<SysUser> users = sysUserMapper.selectList(queryWrapper);
            if (users == null || users.size() == 0) {
                return new ArrayList<>();
            }
            List<SysUser> topUsers = new ArrayList<>(); //存放1级用户,即没有直接上级的用户
            // 根据组织结构展示级别，筛选顶层节点并构建组织结构树
            topUsers.add(user);
            // 递归构建用户树结构
            buildUserTree(topUsers, users);
            return topUsers;
        }
    }

    @Override
    public List<SysUser> findNextAgentTree(String pid) {
        //查询所有的代理人
        //查询绑定的区域的代理人信息
        String userId = BaseController.getUser().getId();

        if ("admin".equals(userId)) {
            return sysUserMapper.getAllAgent(pid, null);
        }

        List<String> agentUserIds = new ArrayList<>();
        List<String> areaCodes = sysUserLinkAreaMapper.findAreaCodeByUserId(userId);
        if (areaCodes != null && !areaCodes.isEmpty()) {
            agentUserIds = sysUserLinkAreaMapper.findAreaIdsByAgentUserId(userId, areaCodes);
            return sysUserMapper.getAllAgent(pid, agentUserIds);
        } else {
            return new ArrayList<>();
        }
    }

    @Override
    public List<Map<String, String>> selectHxUserList(SysUserDto sysUserDto) {
        return sysUserMapper.selectHxUserList(sysUserDto);
    }

    @Override
    public HttpResult cancelManagementPersonnel(UpdateManagementDto managementDto) {
        try {
            if (CollectionUtils.isEmpty(managementDto.getUserIds())) {
                return HttpResult.error("用户数据不能为空");
            }
            return HttpResult.ok(baseMapper.cancelManagementPersonnel(managementDto));
        } catch (Exception e) {
            log.error("取消管理人员出错{}" + e.getMessage());
            return HttpResult.error("取消失败");
        }
    }


    @Override
    public HttpResult updateManagementPersonnel(UpdateManagementDto managementDto) {
        try {
            if (StringUtils.isEmpty(managementDto.getLeaderId()) && CollectionUtils.isEmpty(managementDto.getUserIds())) {
                return HttpResult.error("保存数据不能为空");
            }
            return HttpResult.ok(baseMapper.updateManagementPersonnel(managementDto));
        } catch (Exception e) {
            log.error("批量更新管理人员出错{}" + e.getMessage());
            return HttpResult.error("更新失败");
        }
    }

    @Override
    public IPage<SysUserBaseVO> selectForAgentsAndChannelsPage(PageDto<SysUserDto> pageDto) {
        SysUserDto sysUserVO = JSONObject.parseObject(JSONObject.toJSONString(pageDto.getDto()), SysUserDto.class);
        if (StringUtils.isNotEmpty(sysUserVO.getNotSelected())) {
            sysUserVO.setLeaderId(null);
        }
        return sysUserMapper.selectForAgentsAndChannelsPage(new Page(pageDto.getPageNum(), pageDto.getPageSize()), sysUserVO);
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/9/24 17:36
     * @Description: 电销管理人数据
     */
    @Override
    public List<SysUser> findDxUserList() {
        return sysUserMapper.findDxUserList();
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/9/25 19:23
     * @Description: 查询用户管理的电销组员
     */
    @Override
    public List<String> getGroupByUserId(String userId) {
        return sysUserMapper.getGroupByUserId(userId);
    }


    @Override
    public List<SysDeptTreeVo> getTreeDeptUser() {
        List<SysUser> hxUserList = sysUserMapper.findHxUserListNew();
        Map<String, List<SysUser>> groupedByDeptId = hxUserList.stream()
                .collect(Collectors.groupingBy(SysUser::getDeptId, Collectors.toList()));


        SysDept sysDept = this.sysDeptService.getById("9");
        LambdaQueryWrapper<SysDept> lqw = new LambdaQueryWrapper<>();
        lqw.eq(SysDept::getDelFlag, 0);
//        lqw.isNull(SysDept::getComlevel);
        lqw.likeRight(SysDept::getId, "9");
        lqw.orderByAsc(SysDept::getOrderNum);
        List<SysDept> sysDeptList = sysDeptMapper.selectList(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 -> {
            if (map.get(i.getId()) == null) {
                List<SysUser> orDefault = groupedByDeptId.getOrDefault(i.getId(), new ArrayList<>());
                List<SysDeptTreeVo> sysDeptTreeVos1 = BeanUtil.copyToList(orDefault, SysDeptTreeVo.class);
                i.setChildren(sysDeptTreeVos1);
            } else {
                i.setChildren(map.getOrDefault(i.getId(), new ArrayList<>()));
                i.setDeptCount(i.getChildren().size());
            }
        });
        sysDeptTreeVos = map.get(sysDept.getParentId());

        return sysDeptTreeVos;
    }

    /**
     * 获取人员数
     *
     * @return
     */
    @Override
    public List<SysUser> getTreeUser() {
        HashMap<String, Object> params = new HashMap<>();
        List<SysUser> users = sysUserMapper.selectByParamsTreeUser(params);
        if (users == null || users.isEmpty()) {
            return new ArrayList<>();
        }
        List<SysUser> topUsers = new ArrayList<>(); //存放1级用户,即没有直接上级的用户
        // 根据组织结构展示级别，筛选顶层节点并构建组织结构树
        topUsers.add(sysUserMapper.selectById("99D1501"));
        // 递归构建用户树结构
        buildUserTree(topUsers, users);
        return topUsers;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void addInfo(SysUser sysUser) {

        Integer type = sysUser.getType();
        if (type == 1) {
            SysPartner sysPartner = sysPartnerMapper.selectOne(new LambdaQueryWrapper<SysPartner>().eq(SysPartner::getUserId, sysUser.getId()));
            if (sysPartner == null) {
                //保存合伙人信息
                SysPartnerDto sysPartnerDto = new SysPartnerDto();
                sysPartnerDto.setUserId(sysUser.getId());
                sysPartnerDto.setUserName(sysUser.getName());
                if (sysUser.getLevel() != 1) {
                    sysPartnerDto.setSuggestId(sysUser.getReferrerId());
                }
                sysPartnerDto.setLevel(sysUser.getLevel());
                sysPartnerService.insert(sysPartnerDto);
            }
        } else if (type == 2) {
            SysDept sysDept = sysDeptService.getById(sysUser.getDeptId());
            SysDept sysDeptParent = sysDeptService.getById(sysDept.getParentId());
            SysUser sysUserReferrerId = this.getById(sysUser.getReferrerId());
            SysDeptVo sysDeptVo = new SysDeptVo();
            sysDeptVo.setComlevel("5"); // 默认机构等级为5级
            sysDeptVo.setComtype(sysUser.getDeptType());
            sysDeptVo.setName(sysUser.getName() + "工作室"); // 以人名设置工作室名称
            sysDeptVo.setDeptType("C"); // 默认为子公司
            sysDeptVo.setParentId(sysDept.getParentId());
            sysDeptVo.setManagementSource(sysUser.getDeptSource()); //机构来源默认为加盟
            sysDeptVo.setWorkerId(sysUser.getId()); // 工作室命名人id
            sysDeptVo.setOrderNum(0);
            sysDeptVo.setComattribute("procar"); //机构性质 车险
            sysDeptVo.setProvince(sysDeptParent.getProvince()); // 默认省与负责人所在机构一样
            sysDeptVo.setCity(sysDeptParent.getCity()); // 默认市与负责人所在机构一样
            sysDeptVo.setArea(sysDeptParent.getArea()); // 默认区县与负责人所在机构一样
            sysDeptVo.setCreateTime(new Date());
            sysDeptVo.setAddress(""); // 工作室地址
            sysDeptService.addDept(sysDeptVo);
            SysAgencyLeaderDto sysAgencyLeaderDto = new SysAgencyLeaderDto();
            sysAgencyLeaderDto.setUserId(sysUser.getId());
            sysAgencyLeaderDto.setUserName(sysUser.getName());
            sysAgencyLeaderDto.setDeptId(sysDeptVo.getId());
            sysAgencyLeaderDto.setDeptName(sysDeptVo.getName());
            sysAgencyLeaderDto.setSource(sysUser.getDeptSource());
            sysAgencyLeaderDto.setComlevel(sysDeptVo.getComlevel());
            sysAgencyLeaderDto.setSuggestId(sysUser.getReferrerId());
            SysUser sysUser1 = sysUserMapper.selectById(sysUser.getReferrerId());
            if (sysUser1 != null) {
                sysAgencyLeaderDto.setSuggestName(sysUser1.getName());
            }
            sysAgencyLeaderDto.setSuggestLevel(sysUserReferrerId.getLevel());

            sysAgencyLeaderService.insert(sysAgencyLeaderDto);
        }

    }


    @Override
    @Transactional
    public String agentRegist(AgentUserNewDto dto, SysUser recommender) {
        int noCount = 3;
        //根据机构号获取userid最大值，不需要加人员类型判断  从sys_user获取
        String maxId = this.findMaxId(recommender.getDeptId());
        String nextPK = StringUtils.isNullOrEmpty(maxId) ? recommender.getDeptId() + "001"
                : IdGenerate.nextCode(maxId, noCount);
        SysUser sysUser = new SysUser();
        sysUser.setId(nextPK);
        sysUser.setName(dto.getName());
        sysUser.setMobile(dto.getMobile());
        sysUser.setDeptId(recommender.getDeptId());
        //密码加密
        String salt = PasswordUtils.getSalt();
        sysUser.setSalt(salt);
        String password = PasswordUtils.encode(dto.getPassword(), salt);
        sysUser.setPassword(password);
        sysUser.setStatus(UserWorkStatus.UWS_0.getCode());
        sysUser.setCreateBy("admin");
        sysUser.setCreateTime(new Date());
        sysUser.setFactorVerify(0);  // 未认证状态
        sysUser.setUpdateTime(new Date());
        sysUser.setUpdateBy("admin");
        this.save(sysUser);
        //角色配置
        SysUserRole userRole = new SysUserRole();
        userRole.setUserId(nextPK);
        userRole.setRoleId(20l);
        sysUserRoleService.save(userRole);
        //添加增员服务消息
        //添加订单消息
        messageSecretaryService.addMessage(MessageTypeConstants.M_6, dto.getReferrerId(),
                dto.getMobile() + "(" + dto.getName() + ")" + "进行注册,请立即认证审核.");
        esmUserReferrerService.addReferrer(dto.getReferrerId(), nextPK);

        // 保存个代认证轨迹
        SpringUtil.getBean(UserAgentTrackUtils.class).addTrack(
                sysUser.getId(), UserAgentStatus.UAS_0.getCode(),
                "admin");
        return sysUser.getId();
    }

    @Override
    @Transactional
    public SysUserAgentVo agentAuth(SysUser sysUser, AgentAuthDto dto) {
        SysUser user = this.getById(sysUser.getId());
        String msg;
        Integer status;
        SysUserAgentVo userAgentVo = new SysUserAgentVo();
        // 三要素认证
        UnionPayRequest request = new UnionPayRequest();
        request.setName(dto.getName());
        request.setPhoneNo(dto.getMobile());
        request.setCertNo(dto.getIdentity());
        UnionPayResponse response = unionPayRequestApiComponent.threeFactorVerifyRequest(request);
        if (response != null && !"00".equals(response.getRespCode())) {
            msg = "认证信息不一致:" + response.getDetailRespMsg();
            status = UserAgentStatus.UAS_2.getCode();
            user.setFactorVerify(2); // 认证失败 即未认证状态
            userAgentVo.setStatus(status);
            userAgentVo.setDesc(msg);
        } else {
            msg = "认证成功";
            status = UserAgentStatus.UAS_1.getCode();
            user.setFactorVerify(1);
            user.setStatus(UserWorkStatus.UWS_8.getCode());
            userAgentVo.setStatus(status);
        }
        user.setName(dto.getName());
        user.setMobile(dto.getMobile());
        user.setIdentity(dto.getIdentity());
        user.setIdentityTime(dto.getIdentityTime());
        user.setUpdateBy("admin");
        user.setUpdateTime(new Date());
        this.saveOrUpdate(user);

        SysUserInfo sysUserInfo = new SysUserInfo();
        sysUserInfo.setId(user.getId());
        // 根据身份证获取出生日期和性别
        sysUserInfo.setBirthday(LocalDate.parse(IDCardUtils.GetBirthday(dto.getIdentity())));
        sysUserInfo.setSex(IDCardUtils.GetSex(dto.getIdentity()).equalsIgnoreCase("FEMALE") ? "F" : "M");
        sysUserInfo.setBankName(dto.getBankName());
        sysUserInfo.setAccountno(dto.getAccountno());
        sysUserInfoService.saveOrUpdate(sysUserInfo);
        // 影像资料
        LambdaQueryWrapper<EsmUserImage> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EsmUserImage::getUserId, user.getId());
        esmUserImageService.remove(wrapper);

        List<EsmUserImageVo> esmUserImageVo = dto.getEsmUserImageVo();
        String finalUserId = user.getId();
        List<EsmUserImage> esmUserImages = esmUserImageVo.stream().map(x -> new EsmUserImage(x, finalUserId)).collect(Collectors.toList());
        esmUserImageService.saveBatch(esmUserImages);
        // 保存个代认证轨迹
        SpringUtil.getBean(UserAgentTrackUtils.class).addTrack(
                user.getId(), status,
                BaseController.getUserName(),
                null, msg);
        return userAgentVo;
    }

    @Override
    public SysUserAgentVo getAuthResult(SysUser sysUser, AgentAuthResultDto dto) {
        SysUser user = this.getById(sysUser.getId());
        SysUserInfo info = sysUserInfoService.getById(sysUser.getId());
        SysUserAgentVo userAgentVo = new SysUserAgentVo();
        userAgentVo.setSysUser(user);
        if (Objects.nonNull(info)) {
            userAgentVo.setSysUserInfo(info);
        }

        if (UserWorkStatus.UWS_0.getCode().equals(user.getStatus()) && user.getFactorVerify().equals(2)) {
            SysUserAgentTrack track = sysUserAgentTrackService.queryTrack(sysUser.getId(),
                    UserAgentStatus.UAS_2.getCode());
            if (Objects.nonNull(track)) {
                userAgentVo.setDesc(track.getApproveMess());
            }
        } else if (UserWorkStatus.UWS_3.getCode().equals(user.getStatus())) {
            userAgentVo.setDesc(sysUserTrackService.getApproveMessByUserId(sysUser.getId(), "1"));
        }
        List<EsmUserImageQueryVo> esmUserImageQueryVo = esmUserImageService.getEsmUserImageQueryVo(sysUser.getId());
        if (CollUtil.isNotEmpty(esmUserImageQueryVo)) {
            userAgentVo.setEsmUserImageVo(esmUserImageQueryVo);
        }
        return userAgentVo;
    }

    @Override
    @Transactional
    public void agentSubmit(SysUser user, AgentSubmitDto dto) {
        SysUserInfo info = sysUserInfoService.getById(user.getId());
        // 银行卡认证
        UnionPayRequest request = new UnionPayRequest();
        request.setName(user.getName());
        request.setPhoneNo(user.getMobile());
        request.setCertNo(user.getIdentity());
        request.setCardNo(dto.getBankName());
        UnionPayResponse response = unionPayRequestApiComponent.bankCardVerifyRequest(request);
        String msg;
        Integer status;
        if (response != null && !"00".equals(response.getRespCode())) {
            msg = "认证信息不一致:" + response.getDetailRespMsg();
            status = UserAgentStatus.UAS_4.getCode();
        } else {
            msg = "银行卡认证成功";
            status = UserAgentStatus.UAS_3.getCode();
            SysUserBankCardVO sysUserBankCardVO = new SysUserBankCardVO();
            sysUserBankCardVO.setUserId(dto.getUserId());
            sysUserBankCardVO.setBankNumber(dto.getBankName());
            sysUserBankCardVO.setBankAccount(dto.getAccountno());
            sysUserBankCardVO.setPhoneNo(user.getMobile());
            sysUserBankCardVO.setRealUserName(user.getName());
            sysUserBankCardVO.setUserName(user.getName());
            bankCardService.insertByBankNumber(sysUserBankCardVO);
        }
        // 保存个代银行卡认证轨迹
        SpringUtil.getBean(UserAgentTrackUtils.class).addTrack(
                user.getId(), status,
                BaseController.getUserName(),
                null, msg);

        user.setStatus(UserWorkStatus.UWS_2.getCode());
        user.setUpdateBy("admin");
        user.setUpdateTime(new Date());
        this.saveOrUpdate(user);
        info.setBankName(dto.getBankName());
        info.setAccountno(dto.getAccountno());
        sysUserInfoService.saveOrUpdate(info);
        // 影像资料
        LambdaQueryWrapper<EsmUserImage> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EsmUserImage::getUserId, user.getId());
        esmUserImageService.remove(wrapper);

        List<EsmUserImageVo> esmUserImageVo = dto.getEsmUserImageVo();
        String finalUserId = user.getId();
        List<EsmUserImage> esmUserImages = esmUserImageVo.stream().map(x -> new EsmUserImage(x, finalUserId)).collect(Collectors.toList());
        esmUserImageService.saveBatch(esmUserImages);
    }

    @Override
    public SysUser getByRoleIdAndDeptId(String roleId, String deptId) {
        return baseMapper.getByRoleIdAndDeptId(roleId, deptId);
    }
}