java-insagent-pc/src/main/java/com/ydtech/modules/protocol/service/impl/PtlAgreementServiceImpl.java

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

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ydtech.config.DictEnumConfig;
import com.ydtech.constants.enums.dict.DictionaryData;
import com.ydtech.constants.enums.dict.DictionaryManagement;
import com.ydtech.core.page.HttpResult;
import com.ydtech.exception.SystemException;
import com.ydtech.modules.base.controller.BaseController;
import com.ydtech.modules.esm.model.EsmInsCompany;
import com.ydtech.modules.esm.service.EsmInsCompanyService;
import com.ydtech.modules.order.service.InsCrawlerOrderService;
import com.ydtech.modules.protocol.constants.HistoryStatusConstants;
import com.ydtech.modules.protocol.dao.PtlAgreementMapper;
import com.ydtech.modules.protocol.entity.constants.PtlApiType;
import com.ydtech.modules.protocol.entity.dto.PtlAgreementAttributionDto;
import com.ydtech.modules.protocol.entity.dto.PtlAgreementDto;
import com.ydtech.modules.protocol.entity.dto.PtlAgreementInsCompanyDto;
import com.ydtech.modules.protocol.entity.dto.PtlAgreementSaveDto;
import com.ydtech.modules.protocol.entity.dto.history.PtlAgreementUndwrtRulesHistory;
import com.ydtech.modules.protocol.entity.po.*;
import com.ydtech.modules.protocol.entity.vo.*;
import com.ydtech.modules.protocol.service.*;
import com.ydtech.modules.protocol.utils.AssertionUtils;
import com.ydtech.utils.idgen.IdGenerate;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;


/**
 * @author wenks
 * @description 针对表【ptl_agreement(协议信息表)】的数据库操作Service实现
 * @createDate 2023-06-05 17:59:52
 */
@Service
public class PtlAgreementServiceImpl extends ServiceImpl<PtlAgreementMapper, PtlAgreement> implements PtlAgreementService {

    private final PtlAgreementProductCostsService ptlAgreementProductCostsService;

    private final PtlAgreementAttributionService ptlAgreementAttributionService;

    private final PtlAgreementDeptService ptlAgreementDeptService;

    private final EsmInsCompanyService esmInsCompanyService;

    private final InsCrawlerOrderService insCrawlerOrderController;

    private final PtlAgreementService proxyObject;

    private final PtlAgreementHistoryService ptlAgreementHistoryService;

    private final PtlNonCarInsuranceProductService ptlNonCarInsuranceProductService;

    private final PtlAgreementNonCarProductCostsService ptlAgreementNonCarProductCostsService;

    private final PtlAgreementUndwrtRulesService ptlAgreementUndwrtRulesService;

    private final PtlAgreementProductCostsHistoryService ptlAgreementProductCostsHistoryService;

    private final PtlAgreementUndwrtRulesHistoryService ptlAgreementUndwrtRulesHistoryService;

    private final PtlAgreementAttributionHistoryService ptlAgreementAttributionHistoryService;

    private final PtlAgreementTrajectoryService ptlAgreementTrajectoryService;

    @Autowired
    private PtlAgreementDeptHistoryService ptlAgreementDeptHistoryService;


    @Autowired
    private PtlAgreementMapper ptlAgreementMapper;


    @Value("${python.check}")
    private String pythonCheck;


    public PtlAgreementServiceImpl(PtlAgreementProductCostsService ptlAgreementProductCostsService,
                                   PtlAgreementAttributionService ptlAgreementAttributionService,
                                   PtlAgreementDeptService ptlAgreementDeptService,
                                   EsmInsCompanyService esmInsCompanyService,
                                   PtlAgreementNonCarProductCostsService ptlAgreementNonCarProductCostsService,
                                   @Lazy InsCrawlerOrderService insCrawlerOrderController, @Lazy PtlAgreementService proxyObject,
                                   PtlNonCarInsuranceProductService ptlNonCarInsuranceProductService,
                                   @Lazy PtlAgreementUndwrtRulesService ptlAgreementUndwrtRulesService,
                                   PtlAgreementHistoryService ptlAgreementHistoryService,
                                   PtlAgreementProductCostsHistoryService ptlAgreementProductCostsHistoryService,
                                   PtlAgreementUndwrtRulesHistoryService ptlAgreementUndwrtRulesHistoryService,
                                   PtlAgreementAttributionHistoryService ptlAgreementAttributionHistoryService,
                                   PtlAgreementTrajectoryService ptlAgreementTrajectoryService) {
        this.ptlAgreementProductCostsService = ptlAgreementProductCostsService;
        this.ptlAgreementAttributionService = ptlAgreementAttributionService;
        this.ptlAgreementDeptService = ptlAgreementDeptService;
        this.esmInsCompanyService = esmInsCompanyService;
        this.ptlAgreementNonCarProductCostsService = ptlAgreementNonCarProductCostsService;
        this.insCrawlerOrderController = insCrawlerOrderController;
        this.proxyObject = proxyObject;
        this.ptlNonCarInsuranceProductService = ptlNonCarInsuranceProductService;
        this.ptlAgreementUndwrtRulesService = ptlAgreementUndwrtRulesService;
        this.ptlAgreementHistoryService = ptlAgreementHistoryService;
        this.ptlAgreementProductCostsHistoryService = ptlAgreementProductCostsHistoryService;
        this.ptlAgreementUndwrtRulesHistoryService = ptlAgreementUndwrtRulesHistoryService;
        this.ptlAgreementAttributionHistoryService = ptlAgreementAttributionHistoryService;
        this.ptlAgreementTrajectoryService = ptlAgreementTrajectoryService;
    }


    @Override
    public List<PtlAgreementInsCompanyDto> getAgreementCompany(String deptId) {
        LocalDate localDate = LocalDate.now();
        List<PtlAgreementInsCompanyDto> agreementCompany = baseMapper.getAgreementCompany(localDate, deptId);

        for (PtlAgreementInsCompanyDto ptlAgreementInsCompanyDto : agreementCompany) {
            List<PtlAgreementDto> agreement = ptlAgreementInsCompanyDto.getAgreement();
            for (PtlAgreementDto ptlAgreementDto : agreement) {
                if (ptlAgreementDto.getProductsCode() != null && !ptlAgreementDto.getProductsCode().equals("")) {
                    String[] split = ptlAgreementDto.getProductsCode().split(",");
                    ptlAgreementDto.setProductsCodes(split);
                }
            }
        }

        List<String> agreementIdList = agreementCompany.stream()
                .flatMap(x -> x.getAgreement().stream().map(PtlAgreementDto::getId))
                .collect(Collectors.toList());

        /*Map<String, List<String>> licenseNoList = ptlAgreementUndwrtRulesService.getByLicenseNo(agreementIdList);

        agreementCompany.forEach(
                x -> x.getAgreement().forEach(a -> a.setLicenseNo(licenseNoList.get(a.getId())))
        );*/

        return agreementCompany;
    }

    @Override
    public List<PtlAgreementInsCompanyDto> getAgreementCompanyExternal(String deptId) {
        LocalDate localDate = LocalDate.now();
        List<PtlAgreementInsCompanyDto> agreementCompany = baseMapper.getAgreementCompanyExternal(localDate, deptId);

        for (PtlAgreementInsCompanyDto ptlAgreementInsCompanyDto : agreementCompany) {
            List<PtlAgreementDto> agreement = ptlAgreementInsCompanyDto.getAgreement();
            for (PtlAgreementDto ptlAgreementDto : agreement) {
                if (ptlAgreementDto.getProductsCode() != null && !ptlAgreementDto.getProductsCode().equals("")) {
                    String[] split = ptlAgreementDto.getProductsCode().split(",");
                    ptlAgreementDto.setProductsCodes(split);
                }
            }
        }

        List<String> agreementIdList = agreementCompany.stream()
                .flatMap(x -> x.getAgreement().stream().map(PtlAgreementDto::getId))
                .collect(Collectors.toList());

        /*Map<String, List<String>> licenseNoList = ptlAgreementUndwrtRulesService.getByLicenseNo(agreementIdList);

        agreementCompany.forEach(
                x -> x.getAgreement().forEach(a -> a.setLicenseNo(licenseNoList.get(a.getId())))
        );*/

        return agreementCompany;
    }


    @Override
    public PtlAgreementInsCompanyDto getAgreementCompany(String deptId, String companyId) {
        LocalDate localDate = LocalDate.now();
        PtlAgreementInsCompanyDto agreementCompany = baseMapper.getAgreementCompanyByCompanyId(localDate, deptId, companyId);
        return agreementCompany;
    }

    @Override
    public PtlAgreement ifExistsById(String agreementId) {
        PtlAgreement ptlAgreement = getById(agreementId);
        if (ObjectUtils.isEmpty(ptlAgreement)) {
            throw new SystemException("协议id 不存在");
        }
        return ptlAgreement;
    }

    @Override
    @Transactional
    public HttpResult<Object> saveAgreement(PtlAgreementSaveVo agreement, String userName) {
        PtlAgreementSaveDto agreementSaveDto = agreement.getAgreement();
        PtlAgreementAttributionDto attribution = agreement.getAttribution();
        attribution.setCheck(pythonCheck);
        PtlAgreement ptlAgreement = new PtlAgreement();
        BeanUtils.copyProperties(agreementSaveDto, ptlAgreement);

        EsmInsCompany esmInsCompany = proxyObject.verifyLogin(ptlAgreement, agreementSaveDto, attribution, true);
//        ptlAgreement.setId(IdGenerate.nextId());
        ptlAgreement.setProductsCode(agreementSaveDto.getProductsCode());
        ptlAgreement.setCreator(userName);
        ptlAgreement.setCreateTime(LocalDateTime.now());
        ptlAgreement.setDeleted(0);
        save(ptlAgreement);
        // 新增协议轨迹
        PtlAgreementTrajectory ptlAgreementTrajectory = new PtlAgreementTrajectory();
        ptlAgreementTrajectory.setId(IdGenerate.nextId());
        ptlAgreementTrajectory.setAgreementId(ptlAgreement.getId());
        ptlAgreementTrajectory.setReadme("添加协议");
        ptlAgreementTrajectory.setCreateTime(LocalDateTime.now());
        ptlAgreementTrajectory.setCreateBy(userName);
        ptlAgreementTrajectoryService.save(ptlAgreementTrajectory);
        // 新增协议后按序号重新排序
        List<PtlAgreement> updateList = new ArrayList<>();
        List<PtlAgreement> list = ptlAgreementMapper.selectList(new QueryWrapper<PtlAgreement>()
                .ge("serial_number", ptlAgreement.getSerialNumber())
                .ne("id", ptlAgreement.getId())
                .eq("is_external", ptlAgreement.getIsExternal()));
        if (list != null && !list.isEmpty()) {
            int newSerialNumber = ptlAgreement.getSerialNumber();
            for (PtlAgreement ptlAgreement1 : list) {
                ptlAgreement1.setSerialNumber(++newSerialNumber);
                updateList.add(ptlAgreement1);
            }
            proxyObject.updateBatchById(updateList);
        }
        // 提交  账号信息 授权部门
        proxyObject.saveAssociationInformation(ptlAgreement.getId(), esmInsCompany, agreement);
        // 添加 历史记录表
        //生成批次号
        String batchNo = IdGenerate.nextId();
        //添加授权部门历史信息
        List<String> dept = agreement.getDept();
        List<PtlAgreementDeptHistory> ptlAgreementDeptList = PtlAgreementDeptHistory.toPtlAgreementDeptHistoryList(ptlAgreement.getId(),
                dept, batchNo);
        ptlAgreementDeptHistoryService.saveBatch(ptlAgreementDeptList);
        PtlAgreementHistory ptlAgreementHistory = new PtlAgreementHistory(batchNo, userName, HistoryStatusConstants.HISTORY_TYPE_ADD,
                ptlAgreement);
        ptlAgreementHistory.setStartDate(ptlAgreement.getStartDate().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        ptlAgreementHistory.setEndDate(ptlAgreement.getEndDate().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        ptlAgreementHistory.setAgreementId(ptlAgreement.getId());
        ptlAgreementHistory.setId(IdGenerate.nextId());
        ptlAgreementHistory.setOperatorType("add");
        ptlAgreementHistoryService.saveAgreementHistory(ptlAgreementHistory);
        PtlAgreementAttributionHistory ptlAgreementAttributionHistory = new PtlAgreementAttributionHistory(batchNo, ptlAgreement.getId(),
                esmInsCompany.getId(), esmInsCompany.getName(), agreement.getAttribution());
        ptlAgreementAttributionHistory.setId(IdGenerate.nextId());
        if (StringUtils.isNotEmpty(attribution.getTemplateId())) {
            ptlAgreementAttributionHistoryService.save(ptlAgreementAttributionHistory);
        }

        return HttpResult.ok("添加成功");
    }

    @Override
    @Transactional
    public HttpResult<Object> saveAgreementProduct(PtlAgreementProductCosts ptlAgreementProductCosts, String userName) {

        PtlAgreement ptlAgreement = baseMapper.selectOne(new LambdaQueryWrapper<PtlAgreement>().eq(PtlAgreement::getId,
                ptlAgreementProductCosts.getAgreementId()));
        if (ptlAgreement == null) {
            throw new SystemException("协议不存在");
        }
        ptlAgreement.setModifiedBy(userName);
        ptlAgreement.setModifiedName(BaseController.getUser().getName());
        ptlAgreement.setUpdateTime(LocalDateTime.now());
        //更新协议信息
        baseMapper.updateById(ptlAgreement);
        // 产品费用
        ptlAgreementProductCostsService.save(ptlAgreementProductCosts);
        // 添加 历史记录表
        PtlAgreementProductCostsHistory history = new PtlAgreementProductCostsHistory(userName, DateUtil.format(new Date(), "yyyy-MM-dd " +
                "HH:mm:ss"),
                HistoryStatusConstants.HISTORY_TYPE_UPDATE, ptlAgreementProductCosts);
        ptlAgreementProductCostsHistoryService.save(history);
        return HttpResult.ok("添加成功");
    }

    @Override
    public HttpResult<Object> updateAgreementProduct(PtlAgreementProductCosts agreement, String userName) {
        PtlAgreement ptlAgreement = baseMapper.selectOne(new LambdaQueryWrapper<PtlAgreement>().eq(PtlAgreement::getId,
                agreement.getAgreementId()));
        if (ptlAgreement == null) {
            throw new SystemException("协议不存在");
        }
        ptlAgreement.setModifiedBy(userName);
        ptlAgreement.setModifiedName(BaseController.getUser().getName());
        ptlAgreement.setUpdateTime(LocalDateTime.now());
        //更新协议信息
        baseMapper.updateById(ptlAgreement);
        // 产品费用
        ptlAgreementProductCostsService.updateById(agreement);
        // 添加 历史记录表
        PtlAgreementProductCostsHistory history = new PtlAgreementProductCostsHistory(userName, DateUtil.format(new Date(), "yyyy-MM-dd " +
                "HH:mm:ss"),
                HistoryStatusConstants.HISTORY_TYPE_UPDATE, agreement);
        ptlAgreementProductCostsHistoryService.save(history);
        return HttpResult.ok("修改成功");
    }

    @Override
    @Transactional
    public HttpResult<Object> deleteAgreementProduct(String id, String userName) {
        PtlAgreementProductCosts ptlAg = ptlAgreementProductCostsService.getById(id);
        if (ptlAg == null) {
            throw new SystemException("协议产品费用不存在");
        }
        PtlAgreement ptlAgreement = baseMapper.selectOne(new LambdaQueryWrapper<PtlAgreement>().eq(PtlAgreement::getId,
                ptlAg.getAgreementId()));
        if (ptlAgreement == null) {
            throw new SystemException("协议不存在");
        }
        ptlAgreement.setModifiedBy(userName);
        ptlAgreement.setModifiedName(BaseController.getUser().getName());
        ptlAgreement.setUpdateTime(LocalDateTime.now());
        //更新协议信息
        baseMapper.updateById(ptlAgreement);
        //删除协议
        ptlAgreementProductCostsService.removeById(id);
        PtlAgreementProductCostsHistory history = new PtlAgreementProductCostsHistory(userName, DateUtil.format(new Date(), "yyyy-MM-dd " +
                "HH:mm:ss"),
                HistoryStatusConstants.HISTORY_TYPE_DELETE, ptlAg);
        ptlAgreementProductCostsHistoryService.save(history);
        return HttpResult.ok("删除成功");
    }

    @Override
    @Transactional
    public HttpResult<Object> saveAgreementNonCarProductCosts(PtlAgreementNonVehicleProductCostsVo agreement, String userName) {
        //同步刷新其他协议非车产品费用信息(有待同步协议时，进行同步)
        if (agreement.getSyncAgreementIds() != null && agreement.getSyncAgreementIds().size() > 0) {
            for (int i = 0; i < agreement.getSyncAgreementIds().size(); i++) {
                String tempAgreementId = agreement.getSyncAgreementIds().get(i);
                PtlAgreement destAgreement = getById(tempAgreementId);
                //根据归属保司，找出本级和上级 所有产品代码
                //先获取相关保险公司列表
                String companyId = destAgreement.getPartnerCompaniesId();
                if (destAgreement.getAssociationCompaniesId() != null && !"".equals(destAgreement.getAssociationCompaniesId())) {
                    companyId = destAgreement.getAssociationCompaniesId();
                }
                List<String> companyIdList = esmInsCompanyService.getAllRelationCompanyId(companyId);
                //再根据保险公司列表获取所有非车产品列表
                List<PtlNonCarInsuranceProduct> productList = ptlNonCarInsuranceProductService.findProductListByCompangIds(companyIdList);
                List<PtlAgreementNonCarProductCostsSaveVo> finalList = new ArrayList<>();
                //按找出的产品过滤传进来的 费用方案列表
                for (PtlNonCarInsuranceProduct tempProductDto : productList) {
                    for (PtlAgreementNonCarProductCostsSaveVo productCostDto : agreement.getNonCarProductCosts()) {
                        if (productCostDto.getProductId().equals(tempProductDto.getProductCode())) {
                            finalList.add(productCostDto);
                        }
                    }
                }
                ptlAgreementNonCarProductCostsService.synNonCarProductCosts(destAgreement, finalList);
            }
        }

        return HttpResult.ok("添加成功");
    }

    @Override
    @Transactional
    public HttpResult<Object> saveAgreementUndwrtRules(PtlAgreementUndwrtRules ptlAgreementUndwrtRules, String userName) {
        PtlAgreement ptlAgreement = baseMapper.selectOne(new LambdaQueryWrapper<PtlAgreement>().eq(PtlAgreement::getId,
                ptlAgreementUndwrtRules.getAgreementId()));
        if (ptlAgreement == null) {
            throw new SystemException("协议不存在");
        }
        ptlAgreement.setModifiedBy(userName);
        ptlAgreement.setModifiedName(BaseController.getUser().getName());
        ptlAgreement.setUpdateTime(LocalDateTime.now());
        //更新协议信息
        baseMapper.updateById(ptlAgreement);
        //添加承保规则
        ptlAgreementUndwrtRulesService.save(ptlAgreementUndwrtRules);
        //添加历史记录
        PtlAgreementUndwrtRulesHistory ptlAgreementUndwrtRulesHistory = new PtlAgreementUndwrtRulesHistory(userName,
                HistoryStatusConstants.HISTORY_TYPE_ADD, ptlAgreementUndwrtRules);
        ptlAgreementUndwrtRulesHistoryService.save(ptlAgreementUndwrtRulesHistory);
        return HttpResult.ok("添加成功");
    }

    @Override
    @Transactional
    public HttpResult<Object> updateAgreementUndwrtRules(PtlAgreementUndwrtRules ptlAgreementUndwrtRules, String userName) {
        PtlAgreement ptlAgreement = baseMapper.selectOne(new LambdaQueryWrapper<PtlAgreement>().eq(PtlAgreement::getId,
                ptlAgreementUndwrtRules.getAgreementId()));
        if (ptlAgreement == null) {
            throw new SystemException("协议不存在");
        }
        ptlAgreement.setModifiedBy(userName);
        ptlAgreement.setModifiedName(BaseController.getUser().getName());
        ptlAgreement.setUpdateTime(LocalDateTime.now());
        //更新协议信息
        baseMapper.updateById(ptlAgreement);
        //添加承保规则
        ptlAgreementUndwrtRulesService.updateById(ptlAgreementUndwrtRules);
        //添加历史记录
        PtlAgreementUndwrtRulesHistory ptlAgreementUndwrtRulesHistory = new PtlAgreementUndwrtRulesHistory(userName,
                HistoryStatusConstants.HISTORY_TYPE_UPDATE, ptlAgreementUndwrtRules);
        ptlAgreementUndwrtRulesHistoryService.save(ptlAgreementUndwrtRulesHistory);
        return HttpResult.ok("修改成功");
    }

    @Override
    @Transactional
    public HttpResult<Object> deleteAgreementUndwrtRules(String id, String userName) {
        PtlAgreementUndwrtRules ptlAgreementUndwrtRules =
                ptlAgreementUndwrtRulesService.getOne(new LambdaQueryWrapper<PtlAgreementUndwrtRules>().eq(PtlAgreementUndwrtRules::getId
                        , id));
        if (ptlAgreementUndwrtRules == null) {
            throw new SystemException("协议承保规则不存在");
        }
        PtlAgreement ptlAgreement = baseMapper.selectOne(new LambdaQueryWrapper<PtlAgreement>().eq(PtlAgreement::getId,
                ptlAgreementUndwrtRules.getAgreementId()));
        if (ptlAgreement == null) {
            throw new SystemException("协议不存在");
        }
        ptlAgreement.setModifiedBy(userName);
        ptlAgreement.setModifiedName(BaseController.getUser().getName());
        ptlAgreement.setUpdateTime(LocalDateTime.now());
        //更新协议信息
        baseMapper.updateById(ptlAgreement);
        //删除承保规则
        ptlAgreementUndwrtRulesService.removeById(id);
        //添加历史记录
        PtlAgreementUndwrtRulesHistory ptlAgreementUndwrtRulesHistory = new PtlAgreementUndwrtRulesHistory(userName,
                HistoryStatusConstants.HISTORY_TYPE_DELETE, ptlAgreementUndwrtRules);
        ptlAgreementUndwrtRulesHistoryService.save(ptlAgreementUndwrtRulesHistory);
        return HttpResult.ok("删除成功");
    }

    @Override
    public Page<PtlAgreement> pageAgreement(Page page, PtlAgreementPageVo ptlAgreementPageVo) {

        LambdaQueryWrapper<PtlAgreement> wrapper = new LambdaQueryWrapper<>();
        // 获取供应商本级id 及其 下级id
        List<String> lowerId = esmInsCompanyService.getByLowerId(ptlAgreementPageVo.getPartnerCompaniesId());
        //是否有效
        wrapper.eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getValidStatus()), PtlAgreement::getValidStatus,
                        ptlAgreementPageVo.getValidStatus())
                // 供应商类型
                .eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getCompaniesType()), PtlAgreement::getCompaniesType,
                        ptlAgreementPageVo.getCompaniesType())
                // 协议类型
                .eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getAgreementType()), PtlAgreement::getAgreementType,
                        ptlAgreementPageVo.getAgreementType())
                // 录入人
                .eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getCreator()), PtlAgreement::getCreator, ptlAgreementPageVo.getCreator())
                // 修改人
                .eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getModifiedBy()), PtlAgreement::getModifiedBy,
                        ptlAgreementPageVo.getModifiedBy())
                // 修改人名字
                .eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getModifiedName()), PtlAgreement::getModifiedName,
                        ptlAgreementPageVo.getModifiedName())
                // 合作公司
                .in(!StringUtils.isEmpty(ptlAgreementPageVo.getPartnerCompaniesId()) && !lowerId.isEmpty(),
                        PtlAgreement::getPartnerCompaniesId, lowerId)
                // 费用描述
                .like(!ObjectUtils.isEmpty(ptlAgreementPageVo.getCostsDescription()), PtlAgreement::getUnderwritingDescription,
                        ptlAgreementPageVo.getCostsDescription())
                // 协议起期
                .le(!ObjectUtils.isEmpty(ptlAgreementPageVo.getAgreementStartDate()), PtlAgreement::getStartDate,
                        ptlAgreementPageVo.getAgreementStartDate())
                // 协议止期
                .ge(!ObjectUtils.isEmpty(ptlAgreementPageVo.getAgreementEndDate()), PtlAgreement::getEndDate,
                        ptlAgreementPageVo.getAgreementEndDate())
                // 外部订单
                .eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getIsExternal()), PtlAgreement::getIsExternal,
                        ptlAgreementPageVo.getIsExternal())
                // 审核方式
                .eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getAuditType()), PtlAgreement::getAuditType,
                        ptlAgreementPageVo.getAuditType())
                // 对接人名字
                .eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getDockingPerson()), PtlAgreement::getDockingPerson,
                        ptlAgreementPageVo.getDockingPerson());
        // 录入时间
        if (!ObjectUtils.isEmpty(ptlAgreementPageVo.getStartDate()) && !ObjectUtils.isEmpty(ptlAgreementPageVo.getEndDate())) {
            LocalDateTime startDateTime = ptlAgreementPageVo.getStartDate().atTime(LocalTime.MIN);
            LocalDateTime endDateTime = ptlAgreementPageVo.getEndDate().atTime(LocalTime.MAX);
            wrapper.between(!ObjectUtils.isEmpty(ptlAgreementPageVo.getStartDate()) && !ObjectUtils.isEmpty(ptlAgreementPageVo.getEndDate()), PtlAgreement::getCreateTime, startDateTime, endDateTime);

        }
        // 修改时间
        if (!ObjectUtils.isEmpty(ptlAgreementPageVo.getUpdateStarTime()) && !ObjectUtils.isEmpty(ptlAgreementPageVo.getUpdateEndTime())) {
            LocalDateTime startDateTime = ptlAgreementPageVo.getUpdateStarTime().atTime(LocalTime.MIN);
            LocalDateTime endDateTime = ptlAgreementPageVo.getUpdateEndTime().atTime(LocalTime.MAX);
            wrapper.between(!ObjectUtils.isEmpty(ptlAgreementPageVo.getUpdateStarTime()) && !ObjectUtils.isEmpty(ptlAgreementPageVo.getUpdateEndTime()), PtlAgreement::getUpdateTime, startDateTime, endDateTime);
        }
        // 省市县
        if (ptlAgreementPageVo.getAreaCode() != null && !"".equals(ptlAgreementPageVo.getAreaCode()) && ptlAgreementPageVo.getLevel() != null) {
            String area = ptlAgreementPageVo.getAreaCode();
            String prefix = null;
            Integer sign = 0;
            switch (ptlAgreementPageVo.getLevel()) {
                case "1": { // 省级查询逻辑
                    sign = 2;
                    prefix = area.substring(0, 2);
                    break;
                }
                case "2": {  // 市级查询逻辑
                    sign = 4;
                    prefix = area.substring(0, 4);
                    break;
                }
                case "3": { // 区县级查询逻辑
                    sign = 6;
                    prefix = area.substring(0, 6);
                    break;
                }
            }
            wrapper.apply("SUBSTRING(partner_companies_id, 6, " + sign + ") =" + prefix);
        }
        List<PtlAgreementDept> deptList = new ArrayList<>();
        if(StringUtils.isNotBlank(ptlAgreementPageVo.getDeptId())){
            // 获取所有该部门下勾选的协议
            LambdaQueryWrapper<PtlAgreementDept> deptWrapper = new LambdaQueryWrapper<>();
            deptWrapper.eq(PtlAgreementDept::getDeptId, ptlAgreementPageVo.getDeptId());
            deptList = ptlAgreementDeptService.list(deptWrapper);
        }
        Map<String, Object> agreeMap = new HashMap<>();
        if(CollUtil.isNotEmpty(deptList)){
            agreeMap = deptList.stream().collect(Collectors.toMap(PtlAgreementDept::getAgreementId,PtlAgreementDept::getDeptId));
        }
        Page<PtlAgreement> agreementPage = page(page, wrapper);
        for (PtlAgreement agreement : agreementPage.getRecords()) {
            LocalDate startDate = agreement.getStartDate();
            System.out.println(startDate);
            LocalDate endDate = agreement.getEndDate();
            LocalDate now = LocalDate.now();

            if (now.isEqual(startDate) || (now.isAfter(startDate) && now.isBefore(endDate))) {
                agreement.setIsValid("1");
            } else {
                agreement.setIsValid("0");
            }
            // 判断是否勾选
            if(agreeMap.containsKey(agreement.getId())){
                agreement.setCheck(true);
            }
        }
        return agreementPage;
    }

    @Override
    public HttpResult<List<PtlAgreement>> listAgreement(PtlAgreementPageVo ptlAgreementPageVo) {
        LambdaQueryWrapper<PtlAgreement> wrapper = new LambdaQueryWrapper<>();
        if (!ObjectUtils.isEmpty(ptlAgreementPageVo.getPartnerCompaniesId())){
            // 获取供应商本级id 及其 下级id
            List<String> lowerId = esmInsCompanyService.getByLowerId(ptlAgreementPageVo.getPartnerCompaniesId());
            wrapper.in(!StringUtils.isEmpty(ptlAgreementPageVo.getPartnerCompaniesId()) && !lowerId.isEmpty(),
                    PtlAgreement::getPartnerCompaniesId, lowerId);
        }
        // 审核状态
        wrapper.eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getAuditStatus()), PtlAgreement::getAuditStatus,
                        ptlAgreementPageVo.getAuditStatus())
                //是否有效
                .eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getValidStatus()), PtlAgreement::getValidStatus,
                        ptlAgreementPageVo.getValidStatus())
                // 供应商类型
                .eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getCompaniesType()), PtlAgreement::getCompaniesType,
                        ptlAgreementPageVo.getCompaniesType())
                // 录入时间
                .between(!ObjectUtils.isEmpty(ptlAgreementPageVo.getStartDate()) && !ObjectUtils.isEmpty(ptlAgreementPageVo.getEndDate())
                        , PtlAgreement::getCreateTime, ptlAgreementPageVo.getStartDate(), ptlAgreementPageVo.getEndDate())
                .eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getIsExternal()),PtlAgreement::getIsExternal,
                        ptlAgreementPageVo.getIsExternal())
        ;
        List<PtlAgreement> agreementPage = list(wrapper);
        return HttpResult.ok(agreementPage);
    }

    @Override
    public HttpResult<List<PtlAgreement>> listAgreementInternal(PtlAgreementPageVo ptlAgreementPageVo) {
        LambdaQueryWrapper<PtlAgreement> wrapper = new LambdaQueryWrapper<>();
        // 获取供应商本级id 及其 下级id
        List<String> lowerId = esmInsCompanyService.getByLowerId(ptlAgreementPageVo.getPartnerCompaniesId());
        // 审核状态
        wrapper.eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getAuditStatus()), PtlAgreement::getAuditStatus,
                        ptlAgreementPageVo.getAuditStatus())
                //是否有效
                .eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getValidStatus()), PtlAgreement::getValidStatus,
                        ptlAgreementPageVo.getValidStatus())
                .eq(PtlAgreement::getIsExternal, "0")
                // 供应商类型
                .eq(!ObjectUtils.isEmpty(ptlAgreementPageVo.getCompaniesType()), PtlAgreement::getCompaniesType,
                        ptlAgreementPageVo.getCompaniesType())
                // 合作公司
                .in(!StringUtils.isEmpty(ptlAgreementPageVo.getPartnerCompaniesId()) && !lowerId.isEmpty(),
                        PtlAgreement::getPartnerCompaniesId, lowerId)
                // 录入时间
                .between(!ObjectUtils.isEmpty(ptlAgreementPageVo.getStartDate()) && !ObjectUtils.isEmpty(ptlAgreementPageVo.getEndDate())
                        , PtlAgreement::getCreateTime, ptlAgreementPageVo.getStartDate(), ptlAgreementPageVo.getEndDate());

        List<PtlAgreement> agreementPage = list(wrapper);
        return HttpResult.ok(agreementPage);
    }

    @Override
    public HttpResult<PtlAgreementQueryVo> getByAgreementId(String agreementId) {
        PtlAgreement ptlAgreement = proxyObject.ifExistsById(agreementId);
//        // 获取产品费用
//        List<PltAgreementSchemeSaveDto> schemeQueryDto = ptlAgreementProductCostsService.getByAgreementId(agreementId);
//        // 获取非车险产品费用
//        List<PtlAgreementNonCarProductCosts> nonCarProductCosts = ptlAgreementNonCarProductCostsService.getByAgreementId(agreementId);
//        // 获取承保规则
//        List<PtlAgreementUndwrtRulesSaveDto> underwritingRules = ptlAgreementUndwrtRulesService.getByAgreementId(agreementId);
        //  账号信息查询
        PtlAgreementAttribution ptlAgreementAttribution = ptlAgreementAttributionService.getById(agreementId);
        //2023-08-28 lig 增加  解决前端空对象为null问题，改为返回为空对象
        if (null == ptlAgreementAttribution) {
            ptlAgreementAttribution = new PtlAgreementAttribution();
            ptlAgreementAttribution.setId("");
            ptlAgreementAttribution.setInsCompanyId("");
            ptlAgreementAttribution.setInsCompanyName("");
            ptlAgreementAttribution.setTemplateId("");
            ptlAgreementAttribution.setApiType(1);
            ptlAgreementAttribution.setFields(new JSONArray());
            ptlAgreementAttribution.setUsername("");
            ptlAgreementAttribution.setPassword("");

        }
        // 授权查询
        List<PtlAgreementDept> deptList = ptlAgreementDeptService.getByAgreementId(agreementId);
        PtlAgreementQueryVo ptlAgreementQueryVo = new PtlAgreementQueryVo(ptlAgreement, ptlAgreementAttribution, deptList);
        return HttpResult.ok(ptlAgreementQueryVo);
    }

    @Override
    @Transactional
    public HttpResult<Object> deleteAgreement(String agreementId, String userName) {
        PtlAgreement ptlAgreement = proxyObject.ifExistsById(agreementId);
        HttpResult<PtlAgreementQueryVo> byAgreementId = getByAgreementId(agreementId);

        boolean b = removeById(agreementId);
        AssertionUtils.isSucceed(b, "协议信息删除失败");
        // 删除协议后按序号重新排序
        List<PtlAgreement> updateList = new ArrayList<>();
        List<PtlAgreement> list = ptlAgreementMapper.selectList(new QueryWrapper<PtlAgreement>()
                .ge("serial_number", ptlAgreement.getSerialNumber())
                .ne("id", agreementId)
                .eq("is_external", ptlAgreement.getIsExternal()));
        if (list != null && !list.isEmpty()) {
            int newSerialNumber = ptlAgreement.getSerialNumber(); // 被删除协议的序列号
            for (PtlAgreement ptlAgreement1 : list) {
                // 对于每一个协议，如果其序列号大于等于被删除协议的序列号，则递增
                if (ptlAgreement1.getSerialNumber() >= ptlAgreement.getSerialNumber()) {
                    ptlAgreement1.setSerialNumber(newSerialNumber++);
                }
                updateList.add(ptlAgreement1);
            }
            proxyObject.updateBatchById(updateList);
        }
        // 关联表删除
        proxyObject.deleteAssociationInformation(agreementId);
        // 添加 历史记录表
        //生成批次号
        String batchNo = IdGenerate.nextId();
        List<PtlAgreementDept> dept = byAgreementId.getData().getDept();
        ArrayList<PtlAgreementDeptHistory> histories = new ArrayList<>();
        for (PtlAgreementDept ptlAgreementDept : dept) {
            PtlAgreementDeptHistory deptHistory = new PtlAgreementDeptHistory();
            deptHistory.setAgreementId(ptlAgreementDept.getAgreementId());
            deptHistory.setDeptId(ptlAgreementDept.getDeptId());
            deptHistory.setBatch(batchNo);
        }
        ptlAgreementDeptHistoryService.saveBatch(histories);
        PtlAgreementHistory ptlAgreementHistory = new PtlAgreementHistory(batchNo, userName, HistoryStatusConstants.HISTORY_TYPE_ADD,
                byAgreementId.getData().getAgreement());
        ptlAgreementHistory.setStartDate(byAgreementId.getData().getAgreement().getStartDate().format(DateTimeFormatter.ofPattern("yyyy" +
                "-MM-dd")));
        ptlAgreementHistory.setEndDate(byAgreementId.getData().getAgreement().getEndDate().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"
        )));
        ptlAgreementHistory.setAgreementId(ptlAgreementHistory.getId());
        ptlAgreementHistory.setId(IdGenerate.nextId());
        ptlAgreementHistory.setOperatorType("delete");
        ptlAgreementHistoryService.saveAgreementHistory(ptlAgreementHistory);
        PtlAgreementAttributionHistory ptlAgreementAttributionHistory = new PtlAgreementAttributionHistory(batchNo, agreementId,
                byAgreementId.getData().getAgreement().getInsuranceCompanyId(),
                byAgreementId.getData().getAgreement().getInsuranceCompany(),
                byAgreementId.getData().getPtlAgreementAttribution()
        );
        ptlAgreementAttributionHistory.setId(IdGenerate.nextId());
        if (StringUtils.isNotEmpty(ptlAgreementAttributionHistory.getTemplateId())) {
            ptlAgreementAttributionHistoryService.save(ptlAgreementAttributionHistory);
        }
        return HttpResult.ok("删除成功");
    }

    @Override
    @Transactional
    public HttpResult<Object> reviseAgreement(String userName, String agreementId, PtlAgreementSaveVo agreement) {
        PtlAgreementSaveDto agreementSaveDto = agreement.getAgreement();
        PtlAgreementAttributionDto attribution = agreement.getAttribution();
        attribution.setCheck(pythonCheck);
        PtlAgreement ptlAgreement = proxyObject.ifExistsById(agreementId);
        BeanUtils.copyProperties(agreementSaveDto, ptlAgreement);
        EsmInsCompany esmInsCompany = proxyObject.verifyLogin(ptlAgreement, agreementSaveDto, attribution,
                "1".equals(ptlAgreement.getValidStatus()));
        ptlAgreement.setIsExternal(agreementSaveDto.getIsExternal());
        ptlAgreement.setProductsCode(agreementSaveDto.getProductsCode());
        ptlAgreement.setModifiedBy(userName);
        ptlAgreement.setModifiedName(BaseController.getUser().getName());
        ptlAgreement.setUpdateTime(LocalDateTime.now());
        //add by hxl  2024-06-12 修改协议改为可以更新null的判断
        boolean b = ptlAgreementMapper.updateWithNull(ptlAgreement);
        // 修改协议序号
        List<PtlAgreement> updateList = new ArrayList<>();
        List<PtlAgreement> list = ptlAgreementMapper.selectList(new QueryWrapper<PtlAgreement>()
                .ge("serial_number", ptlAgreement.getSerialNumber())
                .ne("id", agreementId)
                .eq("is_external", ptlAgreement.getIsExternal()));
        if (list != null && list.size() > 0) {
            int newSerialNumber = ptlAgreement.getSerialNumber();
            for (PtlAgreement ptlAgreement1 : list) {
                ptlAgreement1.setSerialNumber(++newSerialNumber);
                updateList.add(ptlAgreement1);
            }
            proxyObject.updateBatchById(updateList);
        }
        // 修改协议
        //boolean b = updateById(ptlAgreement);
        AssertionUtils.isSucceed(b, "协议信息修改失败");
        //添加协议修改轨迹
        PtlAgreementTrajectory ptlAgreementTrajectory = new PtlAgreementTrajectory();
        ptlAgreementTrajectory.setId(IdGenerate.nextId());
        ptlAgreementTrajectory.setAgreementId(agreementId);
        ptlAgreementTrajectory.setReadme("修改协议");
        ptlAgreementTrajectory.setCreateTime(LocalDateTime.now());
        ptlAgreementTrajectory.setCreateBy(userName);
        ptlAgreementTrajectoryService.save(ptlAgreementTrajectory);
        // 关联表都是先删除后添加
        proxyObject.deleteAssociationInformationExcludeCosts(agreementId);
        // 提交 账号信息 授权部门
        proxyObject.saveAssociationInformation(agreementId, esmInsCompany, agreement);

        // 添加 历史记录表
        //生成批次号
        String batchNo = IdGenerate.nextId();
        //添加授权部门历史信息
        List<String> dept = agreement.getDept();
        List<PtlAgreementDeptHistory> ptlAgreementDeptList = PtlAgreementDeptHistory.toPtlAgreementDeptHistoryList(ptlAgreement.getId(),
                dept, batchNo);
        ptlAgreementDeptHistoryService.saveBatch(ptlAgreementDeptList);
        PtlAgreementHistory ptlAgreementHistory = new PtlAgreementHistory(batchNo, userName, HistoryStatusConstants.HISTORY_TYPE_ADD,
                ptlAgreement);
        ptlAgreementHistory.setStartDate(ptlAgreement.getStartDate().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        ptlAgreementHistory.setEndDate(ptlAgreement.getEndDate().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        ptlAgreementHistory.setAgreementId(ptlAgreement.getId());
        ptlAgreementHistory.setId(IdGenerate.nextId());
        ptlAgreementHistory.setOperatorType("update");
        ptlAgreementHistoryService.saveAgreementHistory(ptlAgreementHistory);
        PtlAgreementAttributionHistory ptlAgreementAttributionHistory = new PtlAgreementAttributionHistory(batchNo, ptlAgreement.getId(),
                esmInsCompany.getId(), esmInsCompany.getName(), agreement.getAttribution());
        ptlAgreementAttributionHistory.setId(IdGenerate.nextId());
        if (StringUtils.isNotEmpty(attribution.getTemplateId())) {
            ptlAgreementAttributionHistoryService.save(ptlAgreementAttributionHistory);
        }
        return HttpResult.ok("修改成功");
    }

    @Override
    public void saveAssociationInformation(String agreementId, EsmInsCompany esmInsCompany, PtlAgreementSaveVo agreement) {

        // 账号添加
        PtlAgreementAttributionDto attribution = agreement.getAttribution();
        if (StringUtils.isNotEmpty(attribution.getTemplateId())) {
            ptlAgreementAttributionService.saveAttribution(agreementId, esmInsCompany, agreement.getAttribution());
        }
        // 部门授权
        ptlAgreementDeptService.saveBatchDept(agreementId, agreement.getDept());
    }


    @Override
    public void deleteAssociationInformation(String agreementId) {
        // 删除产品费用
        ptlAgreementProductCostsService.deleteByAgreementId(agreementId);
        // 删除关联信息 删除非车险产品费用  承保规则 账号信息 授权部门
        proxyObject.deleteAssociationInformationExcludeCosts(agreementId);
    }

    @Override
    public void deleteAssociationInformationExcludeCosts(String agreementId) {
        // 删除非车险产品费用
        ptlAgreementNonCarProductCostsService.deleteByAgreementId(agreementId);
        // 删除承保规则
        ptlAgreementUndwrtRulesService.deleteByAgreementId(agreementId);
        // 删除账号信息
        ptlAgreementAttributionService.removeById(agreementId);
        // 删除授权部门
        ptlAgreementDeptService.deleteByAgreementId(agreementId);
    }

    @Override
    public EsmInsCompany verifyLogin(PtlAgreement ptlAgreement, PtlAgreementSaveDto agreementSaveDto,
                                     PtlAgreementAttributionDto attribution, boolean verificationLogin) {
        EsmInsCompany esmInsCompany;

        esmInsCompany = esmInsCompanyService.getBySubsidiary(agreementSaveDto.getPartnerCompaniesId());

        // 验证用户名密码 python api 对接需要验证用户名
        if (!ObjectUtils.isEmpty(attribution.getApiType()) && PtlApiType.PTL_API_2.getCode() == attribution.getApiType() && verificationLogin) {
            String nameSimple = esmInsCompany.getNamesimple();
            String id = esmInsCompany.getId();
            insCrawlerOrderController.isLogin(attribution, id, nameSimple);
        }

        ptlAgreement.setCompaniesType(esmInsCompany.getType());
        ptlAgreement.setInsuranceCompanyId(esmInsCompany.getId());
        ptlAgreement.setInsuranceCompany(esmInsCompany.getNamesimple());
        // 生成协议id
        ptlAgreement.generateTheProtocolCode();
        return esmInsCompany;
    }

    @Override
    public HttpResult<Object> auditAgreement(String agreementId, PtlAgreementAuditVo ptlAgreementAuditVo) {
        PtlAgreement ptlAgreement = proxyObject.ifExistsById(agreementId);
        ptlAgreement.setAuditStatus(ptlAgreementAuditVo.getAuditStatus());
        ptlAgreement.setAuditContent(ptlAgreementAuditVo.getAuditContent());
        // 修改协议
        boolean b = updateById(ptlAgreement);
        AssertionUtils.isSucceed(b, "协议信息修改失败");
        return HttpResult.ok("修改成功");
    }

    @Override
    public HttpResult<List<PtlAgreementNonCarProductCostsVo>> getNonCarCostsInfo(String agreementId, String companyId) {
        List<PtlAgreementNonCarProductCostsVo> result = new ArrayList<>();
        //先根据传过来的保险公司代码，找上下级所有机构层级对应的非车产品列表
        if (companyId != null && !"".equals(companyId)) {
            //先获取相关保险公司列表
            List<String> companyIdList = esmInsCompanyService.getAllRelationCompanyId(companyId);
            //再根据保险公司列表获取所有非车产品列表
            List<PtlNonCarInsuranceProduct> productList = ptlNonCarInsuranceProductService.findProductListByCompangIds(companyIdList);
            if (productList != null && productList.size() > 0) {
                for (int i = 0; i < productList.size(); i++) {
                    PtlNonCarInsuranceProduct tempProductDto = productList.get(i);
                    PtlAgreementNonCarProductCostsVo costsVo = new PtlAgreementNonCarProductCostsVo();
                    costsVo.setProductId(tempProductDto.getProductCode());
                    costsVo.setProductName(tempProductDto.getProductName());
                    costsVo.setCompanyId(tempProductDto.getCompanyId());
                    EsmInsCompany tempInsCompany = esmInsCompanyService.getById(tempProductDto.getCompanyId());
                    costsVo.setCompanyName(tempInsCompany.getName());
                    costsVo.setRiskCode(tempProductDto.getInsuranceCode());
                    Map<String, DictionaryManagement> m = DictEnumConfig.getDmMap();
                    DictionaryManagement dictionaryManagement = m.get("nonCarInsuranceCode");
                    String riskName = "";
                    for (DictionaryData data : dictionaryManagement.getDdList()) {
                        if (tempProductDto.getInsuranceCode().equals(data.getDictValue())) {
                            riskName = data.getDictTag();
                        }
                    }
                    costsVo.setRiskName(riskName);
                    //然后根据协议ID 查询所有已配置费用的产品进行赋值
                    if (agreementId != null && !"".equals(agreementId)) {
                        //使用协议ID  产品ID  获取已经配置好的信息
                        PtlAgreementNonCarProductCosts agreementNonCarProductCosts =
                                ptlAgreementNonCarProductCostsService.getNonCarProductCostsInfo(agreementId,
                                        tempProductDto.getProductCode());
                        //赋值已配置的费用比例
                        if (agreementNonCarProductCosts != null) {
                            costsVo.setCostsProportion(agreementNonCarProductCosts.getCostsProportion());
                        }
                    }
                    result.add(costsVo);
                }
            }
        } else {
            //如果归属保司没选，则直接返回空列表，相当于没查到对应非车产品信息
        }
        return HttpResult.ok(result);
    }

    @Override
    public HttpResult<List<PtlAgreement>> findRelationAgreement(String companyId) {
        List<PtlAgreement> resultList = new ArrayList<>();
        if (companyId != null && !"".equals(companyId)) {
            //先获取相关保险公司列表
            List<String> companyIdList = esmInsCompanyService.getAllRelationCompanyId(companyId);
            if (companyIdList != null && companyIdList.size() > 0) {
                for (int i = 0; i < companyIdList.size(); i++) {
                    String tempCom = companyIdList.get(i);
                    LambdaQueryWrapper<PtlAgreement> wrapper = new LambdaQueryWrapper<>();
                    wrapper.eq(PtlAgreement::getValidStatus, "1");
                    wrapper.and(wq1 -> wq1.eq(PtlAgreement::getPartnerCompaniesId, tempCom).or(wq2 -> wq2.eq(PtlAgreement::getAssociationCompaniesId, tempCom)));
                    resultList.addAll(list(wrapper));
                }
                for (int j = 0; j < resultList.size(); j++) {
                    PtlAgreement agreement = resultList.get(j);
                    String tempCompanyId =
                            agreement.getAssociationCompaniesId() != null && !"".equals(agreement.getAssociationCompaniesId()) ?
                                    agreement.getAssociationCompaniesId() : agreement.getPartnerCompaniesId();
                    EsmInsCompany tempCompany = esmInsCompanyService.getById(tempCompanyId);
                    agreement.setInsuranceCompany(tempCompany.getName());
                }
            }
        }
        return HttpResult.ok(resultList);
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/4/15 18:02
     * @Description: 查询审核的协议
     */
    public List<PtlAgreement> findCheckAgreementList(PtlAgreement ptlAgreement) {
        LambdaQueryWrapper<PtlAgreement> wrapper = new LambdaQueryWrapper<>();
        // wrapper.eq(PtlAgreement::getAuditStatus,"1");
        //添加协议编码排序
        wrapper.orderByAsc(PtlAgreement::getAgreementCode);
        List<PtlAgreement> list = proxyObject.list(wrapper);
        return list;
    }

    /**
     * @version
     * @author: whp
     * @Date: 2024/07/23
     * @Description: 查询审核的所有协议  协议名称拼接
     */
    public List<PtlAgreement> findCheckAgreementListNew(PtlAgreement ptlAgreement) {
        List<PtlAgreement> list = baseMapper.findCheckAgreementListNew(ptlAgreement);
        return list;
    }

    //    @Autowired
//    private PtlAgreementProductCostsNewService ptlAgreementProductCostsNewService;
    public List<PtlAgreement> getCurrentAgreementList(String agreementId) {
        PtlAgreement ptlAgreement = this.getById(agreementId);
        String insuranceCompanyId = ptlAgreement.getInsuranceCompanyId();
        List<PtlAgreement> ptlAgreements =
                baseMapper.selectList(new LambdaQueryWrapper<PtlAgreement>().eq(PtlAgreement::getInsuranceCompanyId, insuranceCompanyId));
        return ptlAgreements;
    }

    @Override
    public PtlAgreement getByAgreementIdNew(String agreementId) {
        PtlAgreement ptlAgreement = baseMapper.getByAgreementIdNew(agreementId);
        return ptlAgreement;
    }

    @Override
    public List<PtlAgreement> getByCompanyCode(String companyCode) {
        return baseMapper.selectList(new LambdaQueryWrapper<PtlAgreement>().eq(PtlAgreement::getInsuranceCompanyId, companyCode));
    }

    @Override
    public List<HashMap<String, Object>> getDockingPersonList() {
        return baseMapper.getDockingPersonList();
    }

    @Override
    public PtlAgreement selectAgreeId(HashMap<String, Object> params) {
        return baseMapper.selectAgreeId(params);
    }

    @Override
    public List<PtlAgreementInsCompanyDto> getExternalAgreement() {
        LocalDate localDate = LocalDate.now();
        List<PtlAgreement> list = this.list(new LambdaQueryWrapper<PtlAgreement>()
                .eq(PtlAgreement::getIsExternal, "1")
                .eq(PtlAgreement::getValidStatus, "1"));

        List<String> agreementCompanys = list.stream().map(PtlAgreement::getInsuranceCompanyId).collect(Collectors.toList());

        List<EsmInsCompany> companyList = esmInsCompanyService.list(new LambdaQueryWrapper<EsmInsCompany>().in(EsmInsCompany::getId, agreementCompanys));

        List<PtlAgreementInsCompanyDto> result = new ArrayList<>();


        companyList.forEach(item -> {
            PtlAgreementInsCompanyDto ptlAgreementInsCompanyDto = new PtlAgreementInsCompanyDto();
            ptlAgreementInsCompanyDto.setId(item.getId());
            ptlAgreementInsCompanyDto.setCnName(item.getCnName());
            ptlAgreementInsCompanyDto.setLogo(item.getLogo());
            ptlAgreementInsCompanyDto.setName(item.getName());
            ptlAgreementInsCompanyDto.setNamesimple(item.getNamesimple());
            List<PtlAgreement> collect = list.stream().filter(x -> x.getInsuranceCompanyId().equals(item.getId())).collect(Collectors.toList());
            List<PtlAgreementDto> agreementDtos = new ArrayList<>();
            collect.forEach(x -> {
                PtlAgreementDto ptlAgreementDto = new PtlAgreementDto();
                BeanUtils.copyProperties(x, ptlAgreementDto);
                agreementDtos.add(ptlAgreementDto);
            });
            ptlAgreementInsCompanyDto.setAgreement(agreementDtos);
            result.add(ptlAgreementInsCompanyDto);
        });
        return result;
    }

    @Override
    public List<PtlAgreement> getAllAgreement(String agreementId) {
        PtlAgreement ptlAgreement = getById(agreementId);
        return baseMapper.selectList(new LambdaQueryWrapper<PtlAgreement>()
                .eq(PtlAgreement::getInsuranceCompanyId, ptlAgreement.getInsuranceCompanyId()));
    }

    @Override
    public HttpResult getAgreementCopy(PtlAgreementVo ptlAgreementVo) {
        PtlAgreement ptlAgreement = baseMapper.selectById(ptlAgreementVo.getId());
        PtlAgreement newPtlAgreement = new PtlAgreement();
        BeanUtils.copyProperties(ptlAgreement, newPtlAgreement, "id", "agreementCode");
        newPtlAgreement.setPartnerCompaniesId(ptlAgreement.getPartnerCompaniesId());
        newPtlAgreement.generateTheProtocolCode();
        save(newPtlAgreement);
        PtlAgreementAttribution ptlAgreementAttributionOld = ptlAgreementAttributionService.getById(ptlAgreementVo.getId());
        // 复制账号配置
        PtlAgreementAttribution ptlAgreementAttributionNew = new PtlAgreementAttribution();
        BeanUtils.copyProperties(ptlAgreementAttributionOld, ptlAgreementAttributionNew, "id");
        ptlAgreementAttributionNew.setId(newPtlAgreement.getId());
        ptlAgreementAttributionService.save(ptlAgreementAttributionNew);
        EsmInsCompany esmInsCompany = esmInsCompanyService.getById(newPtlAgreement.getInsuranceCompanyId());
        // 添加账号配置记录
        String batchNo = IdGenerate.nextId();
        PtlAgreementAttributionHistory ptlAgreementAttributionHistory = new PtlAgreementAttributionHistory();
        ptlAgreementAttributionHistory.setId(IdGenerate.nextId());
        ptlAgreementAttributionHistory.setBatch(batchNo);
        ptlAgreementAttributionHistory.setInsCompanyId(newPtlAgreement.getInsuranceCompanyId());
        ptlAgreementAttributionHistory.setInsCompanyName(esmInsCompany.getName());
        ptlAgreementAttributionHistory.setFields(ptlAgreementAttributionNew.getFields());
        ptlAgreementAttributionHistory.setTemplateId(ptlAgreementAttributionNew.getTemplateId());
        ptlAgreementAttributionHistory.setApiType(ptlAgreementAttributionNew.getApiType());
        ptlAgreementAttributionHistory.setUsername(ptlAgreementAttributionNew.getUsername());
        ptlAgreementAttributionHistory.setPassword(ptlAgreementAttributionNew.getPassword());
        ptlAgreementAttributionHistoryService.save(ptlAgreementAttributionHistory);
        // 复制授权部门
        List<PtlAgreementDept> ptlAgreementDept = ptlAgreementDeptService.list(new LambdaQueryWrapper<PtlAgreementDept>().eq(PtlAgreementDept::getAgreementId, ptlAgreement.getId()));
        List<String> deptIds = ptlAgreementDept.stream().map(PtlAgreementDept::getDeptId).collect(Collectors.toList());
        ptlAgreementDeptService.saveBatchDept(newPtlAgreement.getId(),deptIds);
        // 添加授权部门记录
        List<PtlAgreementDeptHistory> ptlAgreementDeptList = PtlAgreementDeptHistory.toPtlAgreementDeptHistoryList(newPtlAgreement.getId(),
                deptIds, batchNo);
        ptlAgreementDeptHistoryService.saveBatch(ptlAgreementDeptList);
        // 添加协议轨迹
        PtlAgreementTrajectory ptlAgreementTrajectory = new PtlAgreementTrajectory();
        ptlAgreementTrajectory.setId(IdGenerate.nextId());
        ptlAgreementTrajectory.setAgreementId(newPtlAgreement.getId());
        ptlAgreementTrajectory.setReadme("添加协议");
        ptlAgreementTrajectory.setCreateTime(LocalDateTime.now());
        ptlAgreementTrajectory.setCreateBy(BaseController.getUserId());
        ptlAgreementTrajectoryService.save(ptlAgreementTrajectory);
        return HttpResult.ok("协议复制成功");
    }
    /**
     *  @version
     *  @author: hxl
     *  @Date: 2024/9/21 15:33
     *  @Description: 通过协议名称查询数据
     */
    @Override
    public PtlAgreement getByAgreementTitle(String title) {
        LambdaQueryWrapper<PtlAgreement> lqw = new LambdaQueryWrapper<>();
        lqw.eq(PtlAgreement::getAgreementTitle, title);
        List<PtlAgreement> list = list(lqw);
        if (null != list && !list.isEmpty()) {
            return list.get(0);
        }
        return null;
    }
}