ContractServiceImpl.java

package vion.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.PageUtil;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.toolkit.Db;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import io.github.linpeilie.Converter;
import lombok.RequiredArgsConstructor;
import org.dromara.hutool.core.array.ArrayUtil;
import org.dromara.hutool.core.bean.BeanUtil;
import org.dromara.hutool.core.collection.CollUtil;
import org.dromara.hutool.core.collection.ListUtil;
import org.dromara.hutool.core.collection.set.SetUtil;
import org.dromara.hutool.core.date.DateUnit;
import org.dromara.hutool.core.date.DateUtil;
import org.dromara.hutool.core.io.file.FileNameUtil;
import org.dromara.hutool.core.io.file.FileUtil;
import org.dromara.hutool.core.lang.Assert;
import org.dromara.hutool.core.lang.Opt;
import org.dromara.hutool.core.map.MapUtil;
import org.dromara.hutool.core.text.StrUtil;
import org.dromara.hutool.core.util.ObjUtil;
import org.dromara.hutool.crypto.SecureUtil;
import org.dromara.hutool.json.JSONObject;
import org.dromara.hutool.json.JSONUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import vion.dto.ContractDTO;
import vion.dto.RContractTeamDTO;
import vion.mapper.ContractMapper;
import vion.mapper.SettlementDiffMapper;
import vion.model.*;
import vion.service.*;
import vion.third.DingMod;
import vion.vo.*;

import java.io.File;
import java.io.IOException;
import java.math.BigDecimal;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author HlQ
 * @date 2023/11/29
 */
@Service
@RequiredArgsConstructor
public class ContractServiceImpl extends MPJBaseServiceImpl<ContractMapper, Contract> implements IContractService {

    private final IFileService fileService;
    private final IContractPaymentService contractPaymentService;
    private final IRContractStoreService contractStoreService;
    private final IContractLogService contractLogService;
    private final IRContractTeamService contractTeamService;
    private final IRContractUserService contractUserService;
    // 引入 settlementDiffService 会循环依赖
    private final SettlementDiffMapper settlementDiffMapper;
    private final DingMod dingMod;
    private final Converter converter;

    @Value("${fileUrl:}")
    private String fileUrl;

    @Override
    public Page<ContractVO> list(ContractDTO dto) {
        Result result = getResult(dto);

        Page<ContractVO> page = Page.of(dto.getPageNum(), dto.getPageSize());
        Opt.ofNullable(dto.getOrderItem())
                .ifPresent(page::addOrder);
        Page<ContractVO> contractVOList = this.selectJoinListPage(page, ContractVO.class, result.wrapper);

        Opt.ofEmptyAble(settlementDiffMapper.selectList(Wrappers.<SettlementDiff>lambdaQuery()
                        .in(CollUtil.isNotEmpty(contractVOList.getRecords()), SettlementDiff::getContractId, contractVOList.getRecords().stream().map(ContractVO::getId).collect(Collectors.toList()))))
                .map(list -> list.stream().collect(Collectors.groupingBy(SettlementDiff::getContractId, Collectors.reducing(BigDecimal.ZERO, SettlementDiff::getSettlementDiff, BigDecimal::add))))
                .ifPresent(map -> contractVOList.getRecords().forEach(vo -> vo.setDiffAmount(map.getOrDefault(vo.getId(), BigDecimal.ZERO))));

        Opt.ofEmptyAble(contractUserService.lambdaQuery()
                        .in(CollUtil.isNotEmpty(contractVOList.getRecords()), RContractUser::getContractId, contractVOList.getRecords().stream().map(ContractVO::getId).collect(Collectors.toList()))
                        .list())
                .map(list -> list.stream().collect(Collectors.groupingBy(RContractUser::getContractId)))
                .ifPresent(map -> contractVOList.getRecords().forEach(vo -> map.getOrDefault(vo.getId(), ListUtil.empty()).stream()
                        .max(Comparator.comparing(RContractUser::getEnterDate))
                        .map(RContractUser::getUsername)
                        .ifPresent(vo::setSaleName)));

        if (!result.roleCodeList.contains("admin") && !result.roleCodeList.contains("xiaoshou") && !result.roleCodeList.contains("caiwu")) {
            contractVOList.getRecords().forEach(vo -> {
                vo.setTotalAmount(null);
                vo.setPaidAmount(null);
                vo.setReceivableAmount(null);
                vo.setOutstandingAmount(null);
                vo.setInvoiceAmount(null);
                vo.setDiffAmount(null);
            });
        }
        completeStoreName(contractVOList.getRecords());
        return contractVOList;
    }

    @Override
    public Page<ContractVO> listPart(ContractDTO dto) {
        List<Long> ids = Opt.ofNullable(dto.getStoreId())
                .map(storeId -> contractStoreService.listObjs(Wrappers.<RContractStore>lambdaQuery().select(RContractStore::getContractId).eq(RContractStore::getStoreId, dto.getStoreId()), o -> Long.valueOf(o.toString())))
                .filter(CollUtil::isNotEmpty)
                .orElse(ListUtil.of(0L));

        Page<Contract> contractList = this.lambdaQuery(converter.convert(dto, Contract.class))
                .select(Contract::getId, Contract::getName, Contract::getContractNo, Contract::getType, Contract::getSignDate, Contract::getWarrantyPeriod, Contract::getFinalDate, Contract::getStatus, Contract::getSaleName, Contract::getCustomerName, Contract::getMaintainSdate, Contract::getMaintainEdate)
                .in(CollUtil.isNotEmpty(ids), Contract::getId, ids)
                .orderByDesc(Contract::getEntryTime)
                .page(Page.of(dto.getPageNum(), dto.getPageSize()));
        List<ContractVO> contractVOList = converter.convert(contractList.getRecords(), ContractVO.class);
        completeStoreName(contractVOList);
        return Page.<ContractVO>of(contractList.getCurrent(), contractList.getSize(), contractList.getTotal()).setRecords(contractVOList);
    }

    /**
     * 查出合同关联的项目名
     *
     * @param contractVOList list
     */
    private void completeStoreName(List<ContractVO> contractVOList) {
        Map<Long, List<Long>> contractStoreIdsMap = Opt.ofEmptyAble(contractVOList)
                .map(list -> list.stream().map(ContractVO::getId).collect(Collectors.toList()))
                .map(contractIds -> contractStoreService.list(Wrappers.<RContractStore>lambdaQuery().in(RContractStore::getContractId, contractIds)))
                .map(contractStoreList -> contractStoreList.stream().collect(Collectors.groupingBy(RContractStore::getContractId, Collectors.mapping(RContractStore::getStoreId, Collectors.toList()))))
                .orElse(MapUtil.empty());

        Opt.of(contractStoreIdsMap)
                .filter(MapUtil::isNotEmpty)
                .map(map -> map.values().stream().flatMap(List::stream).collect(Collectors.toList()))
                .map(storeIds -> Db.listByIds(storeIds, Store.class))
                .map(storeList -> storeList.stream().collect(Collectors.toMap(Store::getId, Function.identity())))
                .ifPresent(storeId2StoreMap -> contractVOList.forEach(contractVO -> {
                    if (contractStoreIdsMap.containsKey(contractVO.getId())) {
                        List<StoreVO> storeVOS = converter.convert(contractStoreIdsMap.get(contractVO.getId()).stream().map(storeId2StoreMap::get).collect(Collectors.toList()), StoreVO.class);
                        contractVO.setStoreVOS(storeVOS);
                    }
                }));
    }

    @Override
    public ContractVO getVOById(Long id) {
        UserVO userVO = (UserVO) StpUtil.getTokenSession().get("curLoginUser");
        Set<String> roleCodeList = Opt.ofEmptyAble(userVO.getRoleVOList())
                .map(l -> l.stream().map(RoleVO::getCode).collect(Collectors.toSet()))
                .orElse(SetUtil.zero());
        MPJLambdaWrapper<Contract> wrapper = new MPJLambdaWrapper<Contract>()
                .selectAll(Contract.class)
                .selectCollection(ContractLog.class, ContractVO::getContractLogs)
                .leftJoin(ContractLog.class, ContractLog::getContractNo, Contract::getContractNo)
                .eq(Contract::getId, id);
        ContractVO contractVO = this.selectJoinOne(ContractVO.class, wrapper);
        if (!roleCodeList.contains("admin") && !roleCodeList.contains("xiaoshou") && !roleCodeList.contains("caiwu")) {
            contractVO.setTotalAmount(null);
            contractVO.setPaidAmount(null);
            contractVO.setReceivableAmount(null);
            contractVO.setOutstandingAmount(null);
            contractVO.setInvoiceAmount(null);
        }
        return contractVO;
    }

    @Override
    public ContractVO getByNo(String no) {
        Contract contract = this.lambdaQuery()
                .select(Contract::getId, Contract::getName, Contract::getContractNo, Contract::getType, Contract::getSignDate, Contract::getWarrantyPeriod, Contract::getFinalDate, Contract::getStatus, Contract::getSaleName, Contract::getCustomerName)
                .eq(Contract::getContractNo, no)
                .one();
        ContractVO contractVO = converter.convert(contract, ContractVO.class);
        Assert.notNull(contractVO, "合同不存在");
        MPJLambdaWrapper<RContractStore> wrapper = new MPJLambdaWrapper<RContractStore>()
                .select(Store::getId, Store::getName)
                .leftJoin(Store.class, Store::getId, RContractStore::getStoreId)
                .eq(RContractStore::getContractId, contract.getId());
        List<StoreVO> storeVOS = contractStoreService.selectJoinList(StoreVO.class, wrapper);
        contractVO.setStoreVOS(storeVOS);
        return contractVO;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String updateById(Long id, String contractNo, ContractDTO dto) {
        Contract existContract = new Contract();
        if (ObjUtil.isNotNull(id)) {
            existContract = this.getById(id);
        } else if (StrUtil.isNotBlank(contractNo)) {
            existContract = this.lambdaQuery().eq(Contract::getContractNo, contractNo).one();
        }
        Assert.isFalse(BeanUtil.isEmpty(existContract), "合同不存在");

        // todo 如果当前合同进度在要修改的进度前，此时不能修改合同进度。e.g 当前合同进度是项目验收，此时传参过来到货，那么不能修改

        Contract contract = converter.convert(dto, Contract.class);
        Long contractId = existContract.getId();
        String existContractNo = existContract.getContractNo();
        contract.setId(contractId);
        contractPaymentService.calMoney(existContract, contract);
        if (this.updateById(contract)) {
            Opt.ofNullable(dto.getNodeDate())
                    .ifPresent(date -> contractPaymentService.lambdaUpdate()
                            .set(ContractPayment::getNodeDate, date)
                            .eq(ContractPayment::getContractId, contractId)
                            .eq(ContractPayment::getPaymentType, dto.getStatus())
                            .update(new ContractPayment()));

            UserVO userVO = (UserVO) StpUtil.getTokenSession().get("curLoginUser");
            Contract finalExistContract = existContract;
            Opt.ofNullable(dto.getStatus())
                    .ifPresent(status -> {
                        String useridStr = Opt.ofEmptyAble(contractUserService.lambdaQuery()
                                        .eq(RContractUser::getContractNo, existContractNo).list())
                                .map(l -> l.stream().map(RContractUser::getContractNo).collect(Collectors.joining(",")))
                                .orElse("");

                        ContractLog contractLog = new ContractLog();
                        contractLog.setContractNo(existContractNo);
                        if (status == 1) {
                            contractLog.setContent("合同：已签订");
                        } else if (status == 2) {
                            contractLog.setContent("合同：已到货");
                        } else if (status == 3) {
                            contractLog.setContent("合同：系统验收");
                            dingMod.workMsg(buildMsg(useridStr, dto, finalExistContract, "系统验收(初验)"));
                        } else if (status == 4) {
                            contractLog.setContent("合同：项目验收");
                            dingMod.workMsg(buildMsg(useridStr, dto, finalExistContract, "项目验收(终验)"));
                        } else if (status == 5) {
                            contractLog.setContent("合同：质保");
                        } else if (status == 6) {
                            contractLog.setContent("合同：第一笔维保款");
                        } else if (status == 7) {
                            contractLog.setContent("合同：第二笔维保款");
                        } else if (status == 8) {
                            contractLog.setContent("合同：第三笔维保款");
                        }
                        contractLog.setOperator(userVO.getId());
                        contractLogService.save(contractLog);
                    });

            Opt.ofNullable(dto.getFiles())
                    .ifPresent(fileList ->
                            Arrays.stream(fileList).forEach(infile -> {
                                //上传url地址
                                String orgName = infile.getOriginalFilename();
                                String mainName = FileNameUtil.mainName(orgName);
                                String fileExt = FileNameUtil.extName(orgName);
                                String filename = StrUtil.format("{}_{}.{}", mainName, DateUtil.format(new Date(), "yyyyMMdd_HHmmssSSS"), fileExt);
                                String path = fileUrl + FileUtil.FILE_SEPARATOR + "contract" + FileUtil.FILE_SEPARATOR + contract.getId() + FileUtil.FILE_SEPARATOR + filename;
                                File file = FileUtil.touch(path);
                                try {
                                    infile.transferTo(file);
                                } catch (IOException e) {
                                    log.error("保存文件出错", e);
                                }

                                FileInfo fileInfo = new FileInfo();
                                fileInfo.setStoreId(-1L);
                                fileInfo.setSourceId(contract.getId());
                                fileInfo.setSourceType(dto.getSourceType());
                                fileInfo.setContractId(contract.getId());
                                fileInfo.setName(filename);
                                fileInfo.setUrl(path);
                                fileInfo.setType(fileExt);
                                fileInfo.setSha256(SecureUtil.sha256(file).toUpperCase());
                                fileInfo.setUploader(userVO.getUsername());
                                fileService.save(fileInfo);
                            }));
            return "更新成功";
        } else {
            return "更新失败";
        }
    }

    @Override
    public JSONObject calAmount(ContractDTO dto) {
        Result result = getResult(dto);

        JSONObject obj = JSONUtil.ofObj()
                .set("totalAmount", 0)
                .set("paidAmount", 0)
                .set("recAmount", 0)
                .set("outAmount", 0)
                .set("invoiceAmount", 0);
        if (!result.roleCodeList.contains("admin") && !result.roleCodeList.contains("xiaoshou") && !result.roleCodeList.contains("caiwu")) {
            return obj;
        }
        List<Contract> contracts = this.selectJoinList(Contract.class, result.wrapper);

        Opt.ofEmptyAble(contracts)
                .ifPresent(list -> {
                    BigDecimal totalAmount = list.stream().map(Contract::getTotalAmount).reduce(BigDecimal.ZERO, BigDecimal::add);
                    BigDecimal paidAmount = list.stream().map(v -> NumberUtil.max(BigDecimal.ZERO, v.getPaidAmount())).reduce(BigDecimal.ZERO, BigDecimal::add);
                    BigDecimal recAmount = list.stream().map(v -> NumberUtil.max(BigDecimal.ZERO, v.getReceivableAmount())).reduce(BigDecimal.ZERO, BigDecimal::add);
                    BigDecimal outAmount = list.stream().map(Contract::getOutstandingAmount).reduce(BigDecimal.ZERO, BigDecimal::add);

                    List<String> noList = list.stream().map(Contract::getContractNo).collect(Collectors.toList());
                    List<BigDecimal> invoices = Db.listObjs(Wrappers.lambdaQuery(Invoice.class).select(Invoice::getInvoiceAmount).in(BeanUtil.isNotEmpty(dto), Invoice::getContractNo, noList), Invoice::getInvoiceAmount);
                    BigDecimal invoiceAmount = invoices.stream().reduce(BigDecimal.ZERO, BigDecimal::add);

                    obj.set("totalAmount", totalAmount)
                            .set("paidAmount", paidAmount)
                            .set("recAmount", recAmount)
                            .set("outAmount", outAmount)
                            .set("invoiceAmount", invoiceAmount);
                });
        return obj;
    }

    @Override
    public Map<String, Object> analyze(ContractDTO dto) {
        List<Contract> contractList = this.lambdaQuery(converter.convert(dto, Contract.class))
                .gt(Contract::getReceivableAmount, 0)
                .gt(Contract::getTotalAmount, 0)
                .between(ArrayUtil.isAllNotNull(dto.getSignDateStart(), dto.getSignDateEnd()), Contract::getSignDate, dto.getSignDateStart(), dto.getSignDateEnd())
                .list();
        if (CollUtil.isEmpty(contractList)) {
            return new JSONObject();
        }

        // todo 优化查询，当下是查询所有
        Map<Long, List<ContractPayment>> id2PaymentMap = Opt.ofEmptyAble(contractPaymentService
                        .lambdaQuery().gt(ContractPayment::getPaymentRatio, 0)
                        .list())
                .map(list -> list.stream().collect(Collectors.groupingBy(ContractPayment::getContractId)))
                .orElse(MapUtil.empty());
        if (MapUtil.isEmpty(id2PaymentMap)) {
            return new JSONObject();
        }
        List<FinancialAgeVO> financialAgeVOList = new ArrayList<>();

        contractList.forEach(c -> {
            List<ContractPayment> contractPaymentList = id2PaymentMap.get(c.getId());
            if (CollUtil.isEmpty(contractPaymentList)) {
                return;
            }
            BigDecimal totalAmount = c.getTotalAmount();
            BigDecimal paidAmount = c.getPaidAmount();
            Map<Integer, Date> type2DateMap = contractPaymentList.stream().filter(cp -> cp.getPaymentType() <= c.getStatus()).collect(HashMap::new, (m, v) -> m.put(v.getPaymentType(), v.getPaymentDate()), HashMap::putAll);

            Map<Integer, BigDecimal> type2AmountMap = contractPaymentList.stream().filter(cp -> cp.getPaymentType() <= c.getStatus()).collect(Collectors.toMap(ContractPayment::getPaymentType, v -> NumberUtil.mul(v.getPaymentRatio(), totalAmount)));
            TreeMap<Integer, BigDecimal> sortMap = MapUtil.sort(type2AmountMap, Comparator.comparingInt(Integer::intValue));

            for (Map.Entry<Integer, BigDecimal> entry : sortMap.entrySet()) {
                Integer type = entry.getKey();
                BigDecimal curAmount = entry.getValue();
                if (NumberUtil.isGreater(paidAmount, BigDecimal.ZERO)) {
                    paidAmount = NumberUtil.sub(paidAmount, curAmount);
                    if (NumberUtil.equals(paidAmount, BigDecimal.ZERO)) {
                        continue;
                    }
                }
                if (NumberUtil.isLessOrEqual(paidAmount, BigDecimal.ZERO)) {
                    FinancialAgeVO financialAgeVO = new FinancialAgeVO();
                    financialAgeVO.setContractNo(c.getContractNo());
                    financialAgeVO.setContractName(c.getName());
                    financialAgeVO.setStatus(type);
                    financialAgeVO.setAmount(NumberUtil.equals(paidAmount, BigDecimal.ZERO) ? curAmount : BigDecimal.valueOf(Math.abs(paidAmount.doubleValue())));
                    Opt.ofNullable(type2DateMap.get(type)).ifPresent(
                            date -> {
                                financialAgeVO.setPayableDate(date);
                                long age = DateUtil.between(date, new Date(), DateUnit.DAY, true);
                                financialAgeVO.setAge(((int) age));
                            }
                    );
                    financialAgeVOList.add(financialAgeVO);
                    paidAmount = BigDecimal.ZERO;
                }
            }
        });
        Map<String, Object> map = MapUtil.<String, Object>builder()
                .put("totalAmount", financialAgeVOList.stream().map(FinancialAgeVO::getAmount).reduce(BigDecimal.ZERO, BigDecimal::add)).build();
        // 手动分页
        int[] transToStartEnd = PageUtil.transToStartEnd(dto.getPageNum() - 1, dto.getPageSize());
        Page<FinancialAgeVO> financialAgeVOPage = Page.<FinancialAgeVO>of(dto.getPageNum(), dto.getPageSize(), financialAgeVOList.size())
                .setRecords(CollUtil.sub(financialAgeVOList, transToStartEnd[0], transToStartEnd[1]));
        map.put("list", financialAgeVOPage);
        return map;
    }

    @Override
    public String dispatch(RContractTeamDTO dto) {
        RContractTeam rContractTeam = converter.convert(dto, RContractTeam.class);
        if (contractTeamService.save(rContractTeam)) {
            // todo 推送钉钉消息到王平川，要支持可配置吗？
            Contract contract = this.getById(dto.getContractId());
            dingMod.workMsg(buildMsg("01005444040832705136", contract, dto.getApplicantName()));
            return "派工成功，待分配施工队。";
        }
        return "派工失败";
    }

    @Override
    public Page<RContractUser> getSaleList(RContractUser dto) {
        return contractUserService.lambdaQuery(dto).orderByDesc(RContractUser::getEnterDate).page(Page.of(dto.getPageNum(), dto.getPageSize()));
    }

    @Override
    public String assignSale(RContractUser contractUser) {
        return contractUserService.save(contractUser) ? "分配成功" : "分配失败";
    }

    @Override
    public String unbindSale(RContractUser contractUser) {
        return contractUserService.remove(Wrappers.<RContractUser>lambdaQuery().eq(RContractUser::getContractId, contractUser.getContractId()).eq(RContractUser::getUserId, contractUser.getUserId())) ? "解绑成功" : "解绑失败";
    }

    private Result getResult(ContractDTO dto) {
        // 查询已关联项目的合同id
        List<Long> contractIdList = dto.getSwitchFlag() == 1 ?
                contractStoreService.listObjs(Wrappers.<RContractStore>lambdaQuery()
                        .select(RContractStore::getContractId), o -> Long.valueOf(o.toString()))
                : ListUtil.empty();
        // 根据产品线查出关联的合同
        List<Long> lineContractIdList = Opt.ofEmptyAble(dto.getProductLines())
                .map(pl -> Db.listObjs(Wrappers.lambdaQuery(Store.class).in(Store::getProductLine, pl), Store::getId))
                .map(storeIds -> contractStoreService.listObjs(Wrappers.<RContractStore>lambdaQuery().select(RContractStore::getContractId).in(RContractStore::getStoreId, storeIds), o -> Long.valueOf(o.toString())))
                .orElse(new ArrayList<>());
        // 根据当前登录用户的角色获取用户名
        UserVO userVO = (UserVO) StpUtil.getTokenSession().get("curLoginUser");
        Set<String> roleCodeList = Opt.ofEmptyAble(userVO.getRoleVOList())
                .map(l -> l.stream().map(RoleVO::getCode).collect(Collectors.toSet()))
                .orElse(SetUtil.zero());
        Assert.notEmpty(roleCodeList, "当前用户角色不详，请联系管理员");
        String curName = "";
        boolean isPerm = !roleCodeList.contains("admin") && !roleCodeList.contains("shangwu") && !roleCodeList.contains("caiwu");
        if (isPerm) {
            // 不是以上三个角色，只能访问自己相关的合同
            curName = userVO.getUsername();
        }

        // 根据查询条件的销售人查询关联的合同
        List<Long> contractUserIdList1 = Opt.ofBlankAble(dto.getSaleName())
                .map(name -> contractUserService.listObjs(Wrappers.<RContractUser>lambdaQuery()
                        .select(RContractUser::getContractId).eq(RContractUser::getUsername, name), o -> Long.valueOf(o.toString())))
                .orElse(new ArrayList<>());
        // 根据查询条件的销售人查询其销售的合同
        List<Long> contractUserIdList2 = Opt.ofBlankAble(dto.getSaleName())
                .map(name -> this.listObjs(Wrappers.<Contract>lambdaQuery()
                        .select(Contract::getId).eq(Contract::getSaleName, name), o -> Long.valueOf(o.toString())))
                .orElse(new ArrayList<>());
        // 查询共同销售人为当前用户的关联合同
        List<Long> contractUserIdList3 = Opt.ofBlankAble(curName)
                .map(name -> contractUserService.listObjs(Wrappers.<RContractUser>lambdaQuery()
                        .select(RContractUser::getContractId).eq(RContractUser::getUsername, name), o -> Long.valueOf(o.toString())))
                .orElse(new ArrayList<>());
        // 查询合同销售人为当前用户的合同
        List<Long> contractUserIdList4 = Opt.ofBlankAble(curName)
                .map(name -> this.listObjs(Wrappers.<Contract>lambdaQuery()
                        .select(Contract::getId).eq(Contract::getSaleName, name), o -> Long.valueOf(o.toString())))
                .orElse(new ArrayList<>());
        Collection<Long> queryContractUserIdList = ListUtil.addAllIfNotContains(contractUserIdList1, contractUserIdList2);
        Collection<Long> curContractUserIdList = ListUtil.addAllIfNotContains(contractUserIdList3, contractUserIdList4);
        Set<Long> allContractUserIdList;
        if (StrUtil.isNotBlank(curName) && StrUtil.isNotBlank(dto.getSaleName())) {
            // 当前用户和查询条件的销售人都存在，取交集
            allContractUserIdList = CollUtil.intersectionDistinct(queryContractUserIdList, curContractUserIdList);
        } else {
            allContractUserIdList = CollUtil.unionDistinct(queryContractUserIdList, curContractUserIdList);
        }

        Set<Long> finalIdSet;
        if (isPerm) {
            // 不是以上三个角色，只能访问自己相关的合同或自己产品线相关的合同
            if (CollUtil.isNotEmpty(dto.getProductLines())) {
                finalIdSet = CollUtil.intersectionDistinct(lineContractIdList, allContractUserIdList);
            } else {
                finalIdSet = CollUtil.unionDistinct(lineContractIdList, allContractUserIdList);
            }
            if (CollUtil.isEmpty(finalIdSet)) {
                // 根据条件筛选要查询的合同为空，集合补元素 -1，防止数据库查询出错
                finalIdSet.add(-1L);
            }
        } else {
            if (StrUtil.isNotBlank(dto.getSaleName()) && CollUtil.isNotEmpty(dto.getProductLines())) {
                finalIdSet = CollUtil.intersectionDistinct(lineContractIdList, allContractUserIdList);
            } else {
                finalIdSet = CollUtil.unionDistinct(lineContractIdList, allContractUserIdList);
            }
            if ((StrUtil.isNotBlank(dto.getSaleName()) || CollUtil.isNotEmpty(dto.getProductLines())) && CollUtil.isEmpty(finalIdSet)) {
                finalIdSet.add(-1L);
            }
        }

        // 前端传参中的 saleName 字段已单独处理，这里置空，不参与下一步的 converter.convert
        dto.setSaleName(null);
        MPJLambdaWrapper<Contract> wrapper = new MPJLambdaWrapper<>(converter.convert(dto, Contract.class))
                .selectAll(Contract.class)
                .in(CollUtil.isNotEmpty(finalIdSet), Contract::getId, finalIdSet)
                .notIn(CollUtil.isNotEmpty(contractIdList), Contract::getId, contractIdList)
                .between(ArrayUtil.isAllNotNull(dto.getSignDateStart(), dto.getSignDateEnd()), Contract::getSignDate, dto.getSignDateStart(), dto.getSignDateEnd());
        if (StrUtil.isNotBlank(dto.getOperator()) && ObjUtil.isNotNull(dto.getAmount())) {
            String ope = dto.getOperator();
            if (">".equals(ope)) {
                wrapper.gt(getCol(dto), dto.getAmount());
            } else if ("<".equals(ope)) {
                wrapper.lt(getCol(dto), dto.getAmount());
            } else {
                wrapper.eq(getCol(dto), dto.getAmount());
            }
        }
        return new Result(roleCodeList, wrapper);
    }

    private SFunction<Contract, Object> getCol(ContractDTO dto) {
        if (dto.getTotalAmount() != null) {
            return Contract::getTotalAmount;
        } else if (dto.getPaidAmount() != null) {
            return Contract::getPaidAmount;
        } else if (dto.getReceivableAmount() != null) {
            return Contract::getReceivableAmount;
        } else {
            return Contract::getOutstandingAmount;
        }
    }

    JSONObject buildMsg(String userid, Contract contract, String applicantName) {
        JSONObject jsonObj = new JSONObject();
        jsonObj.set("agent_id", 2358374016L);
        jsonObj.set("userid_list", userid);

        JSONObject msg = new JSONObject();
        JSONObject content = new JSONObject();
        content.set("title", "合同施工申请，请及时处理哦~_~");
        String markdown = StrUtil.format("#### 合同编号: **{}**" +
                        "  \n  #### 合同名称：**{}**" +
                        "  \n  #### 申请人：{}" +
                        "  \n  #### 发送时间：{}",
                contract.getContractNo(), contract.getName(), applicantName, DateUtil.now());
        content.set("markdown", markdown);

        msg.set("msgtype", "action_card");
        msg.set("action_card", content);
        jsonObj.set("msg", msg);
        return jsonObj;
    }

    JSONObject buildMsg(String userid, ContractDTO dto, Contract contract, String statusStr) {
        JSONObject jsonObj = new JSONObject();
        jsonObj.set("agent_id", 2358374016L);
        jsonObj.set("userid_list", userid);

        JSONObject msg = new JSONObject();
        JSONObject content = new JSONObject();
        content.set("title", "验收提醒");
        String markdown = StrUtil.format("#### 验收提醒" +
                        "  \n  #### 合同编号:**{}**" +
                        "  \n  #### 合同名称:**{}**" +
                        "  \n  #### 状态:{}" +
                        "  \n  #### 验收时间:{}" +
                        "  \n  #### 发送时间:{}",
                contract.getContractNo(), contract.getName(), statusStr, DateUtil.formatDate(dto.getNodeDate()), DateUtil.now());
        content.set("text", markdown);

        msg.set("msgtype", "markdown");
        msg.set("markdown", content);
        jsonObj.set("msg", msg);
        return jsonObj;
    }

    private static class Result {
        public final Set<String> roleCodeList;
        public final MPJLambdaWrapper<Contract> wrapper;

        public Result(Set<String> roleCodeList, MPJLambdaWrapper<Contract> wrapper) {
            this.roleCodeList = roleCodeList;
            this.wrapper = wrapper;
        }
    }
}