java-insagent-pc/src/main/java/com/ydtech/modules/scheme/service/impl/PtlSchemeRulesServiceImpl.java

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

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ydtech.constants.enums.dict.insurance.EnergyType;
import com.ydtech.exception.SystemException;
import com.ydtech.modules.admin.service.SysUserService;
import com.ydtech.modules.base.controller.BaseController;
import com.ydtech.modules.protocol.entity.dto.PtlAgreementInsCompanyDto;
import com.ydtech.modules.protocol.entity.dto.TaxSourceExcludeDto;
import com.ydtech.modules.protocol.service.ITaxSourceExcludeService;
import com.ydtech.modules.protocol.service.ITaxSourceService;
import com.ydtech.modules.scheme.dao.PtlSchemeRulesMapper;
import com.ydtech.modules.scheme.entity.po.PtlSchemeRules;
import com.ydtech.modules.scheme.entity.po.PtlSchemeRulesAttr;
import com.ydtech.modules.scheme.entity.po.PtlSchemeRulesAttrLink;
import com.ydtech.modules.scheme.entity.vo.*;
import com.ydtech.modules.scheme.service.*;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

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

/**
 * @description 协议承保规则属性 service实现类
 * @createDate 2024-2-22 15:44:29
 * @Entity
 */
@Service
public class PtlSchemeRulesServiceImpl extends ServiceImpl<PtlSchemeRulesMapper, PtlSchemeRules>
        implements PtlSchemeRulesService {

    @Autowired
    PtlSchemeRulesAttrLinkService ptlSchemeRulesAttrLinkService;

    @Autowired
    ITaxSourceService taxSourceService;

    @Autowired
    SysUserService sysUserService;

    @Autowired
    RuleFilteringService ruleFilteringService;

    @Autowired
    PtlSchemeRulesAttrService ptlSchemeRulesAttrService;

    @Autowired
    PtlSchemeService ptlSchemeService;

    @Autowired
    PtlOptionalSchemeService ptlOptionalSchemeService;

    @Autowired
    ITaxSourceExcludeService iTaxSourceExcludeService;

    /**
     * 保存规则
     *
     * @param ruleSaveVo
     * @return
     */
    @Override
    @Transactional
    public int addRules(RuleSaveVo ruleSaveVo) {
        //保存 方案
        PtlSchemeRules rule = ruleSaveVo.getRule();
        this.baseMapper.insert(rule);
        //保存 方案规则
        List<PtlSchemeRulesAttrLink> attrs = ruleSaveVo.getAttrs();
        attrs.forEach(attr -> {
            attr.setRulesId(String.valueOf(rule.getId()));
        });
        ptlSchemeRulesAttrLinkService.saveBatch(attrs);
        return Integer.parseInt(rule.getId());
    }


    /**
     * 修改规则
     *
     * @param ruleSaveVo
     * @return
     */
    @Override
    @Transactional
    public boolean updateRules(RuleSaveVo ruleSaveVo) {
        this.updateById(ruleSaveVo.getRule());
        //删除之后再新增
        LambdaQueryWrapper<PtlSchemeRulesAttrLink> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PtlSchemeRulesAttrLink::getRulesId, ruleSaveVo.getRule().getId());
        ptlSchemeRulesAttrLinkService.remove(queryWrapper);
        ruleSaveVo.getAttrs().forEach(attr -> {
            attr.setRulesId(ruleSaveVo.getRule().getId());
        });
        ptlSchemeRulesAttrLinkService.saveBatch(ruleSaveVo.getAttrs());
        return true;
    }

    /**
     * 删除规则
     *
     * @param ruleId
     * @return
     */
    @Override
    @Transactional
    public boolean deleteRules(String ruleId) {
        PtlSchemeRules ptlSchemeRules = this.getById(ruleId);
        if (Objects.isNull(ptlSchemeRules)) {
            throw new SystemException("规则不存在");
        }
        this.removeById(ruleId);

        LambdaQueryWrapper<PtlSchemeRulesAttrLink> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PtlSchemeRulesAttrLink::getRulesId, ruleId);
        ptlSchemeRulesAttrLinkService.remove(queryWrapper);

        return true;
    }

    /**
     * 查询规则分页信息
     *
     * @param page
     * @param ruleQueryVo
     * @return
     */
    @Override
    public Page<RuleResultVo> getRulesPage(Page page, RuleQueryVo ruleQueryVo) {
        Page<RuleResultVo> rulesPage = baseMapper.getRulePage(page, ruleQueryVo);
        return rulesPage;
    }

    public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
        Set<Object> seen = new HashSet<>();
        return t -> seen.add(keyExtractor.apply(t)); // 如果id已存在则过滤
    }

    /**
     * 根据规则过滤保险公司
     *
     * @param ruleFilterVo
     * @return
     */
    @Override
    public List<PtlAgreementInsCompanyDto> ruleFilterCompany(String userId, RuleFilterVo ruleFilterVo) {
        List<PtlAgreementInsCompanyDto> userAgreementInsCompany = new ArrayList<>();
        if(!BaseController.getUserId().equals(userId)){

            userAgreementInsCompany = taxSourceService.getAllAgreement(BaseController.getDeptId(),BaseController.getUserId());
        }
        String deptId = sysUserService.getById(userId).getDeptId();
        //首先获取有权限的保险公司
        List<PtlAgreementInsCompanyDto> agreementInsCompany = taxSourceService.getAllAgreement(deptId, userId);
        agreementInsCompany.addAll(userAgreementInsCompany);

        agreementInsCompany = agreementInsCompany.stream()
                .filter(distinctByKey(PtlAgreementInsCompanyDto::getId))  // 核心：按id去重
                .collect(Collectors.toList());

        //用户可读取的所有保险公司id
        List<String> companyIds = agreementInsCompany.stream()
                .map(PtlAgreementInsCompanyDto::getId)
                .collect(Collectors.toList());

        if (companyIds.isEmpty()) {
            throw new SystemException("暂无可报价公司");
        }

        //获取所有规则的保险公司id
        List<PtlAgreementInsCompanyDto> ptlAgreementInsCompanyDtos = new ArrayList<>();

        List<PtlSchemeRules> userAllSchemeByCompanyIds = ptlSchemeService.getUserAllSchemeByCompanyIds(ruleFilterVo.getProductId(), companyIds,
                ruleFilterVo.getCarInfo().getCimodelclass(), EnergyType.isNewEnergy(ruleFilterVo.getCarInfo()
                        .getEnergyType()));

        //获取所有规则属性
        List<PtlSchemeRulesAttr> rulesAttrList = ptlSchemeRulesAttrService.getAllRulesAttrList();
        //映射的规则属性
        List<SchemeRuleAttrMappingVo> ruleAttrMappingVoList = SchemeRuleAttrMappingVo.getRuleAttrMappingVoList(
                ruleFilterVo.getCarInfo(),
                ruleFilterVo.getOwnerInfo(),
                ruleFilterVo.getApplyInfo(),
                ruleFilterVo.getInsureInfo(),
                null);
        //赛选规则
        List<PtlAgreementInsCompanyDto> finalAgreementInsCompany = agreementInsCompany;
        userAllSchemeByCompanyIds.forEach(scheme -> {
            List<SchemeRuleResultVo> rulesVo = ptlSchemeRulesAttrLinkService.getSchemeRulesAttrLinks(scheme.getCompanyId(), ruleFilterVo.getProductId());

            for (SchemeRuleResultVo rule : rulesVo) {
                List<SchemeRuleResultVo> vo = new ArrayList<>();
                vo.add(rule);
                boolean allRulesPassed = vo.stream().allMatch(r ->
                        ruleFilteringService.judgements(r.getAttrLinks(), rulesAttrList, ruleAttrMappingVoList)
                );
                if (allRulesPassed) {
                    finalAgreementInsCompany.stream()
                            .filter(x -> x.getId().equals(scheme.getCompanyId()))
                            .forEach(item -> {
                                if (ptlAgreementInsCompanyDtos.stream()
                                        .noneMatch(existing -> existing.getId().equals(scheme.getCompanyId()))) {
                                    item.setInsGuide(ptlOptionalSchemeService.getCompanyInsGuide(scheme.getCompanyId(), ruleFilterVo.getProductId(),
                                            ruleFilterVo.getCarInfo().getCarnature(), ruleFilterVo.getCarInfo()
                                                    .getCimodelclass(), EnergyType.isNewEnergy(ruleFilterVo.getCarInfo()
                                                    .getEnergyType()) ? "1" : "0"));
                                    ptlAgreementInsCompanyDtos.add(item);
                                }
                            });
                    break;
                }
            }
        });
        Map<String, PtlAgreementInsCompanyDto> collect = ptlAgreementInsCompanyDtos.stream()
                .collect(Collectors.toMap(PtlAgreementInsCompanyDto::getId, x -> x));

        List<String> list = iTaxSourceExcludeService.lambdaQuery()
                .eq(TaxSourceExcludeDto::getExcludeInfo, deptId)
                .list()
                .stream()
                .map(TaxSourceExcludeDto::getInsCompanyId)
                .collect(Collectors.toList());

        List<PtlAgreementInsCompanyDto> collect1 = companyIds.stream()
                .map(collect::get)
                .peek(x->{
                    if (!ObjectUtils.isEmpty(x) && !list.isEmpty() && list.contains(x.getId())) {
                        x.setIsTaxSource("0");
                    }
                })
                .filter(ObjectUtils::isNotEmpty)
                .collect(Collectors.toList());
        return collect1;
    }

    /**
     * 根据产品id 和保险公司获取规则
     *
     * @param companyId
     * @param productId
     * @return
     */
    @Override
    public PtlSchemeRules getRuleByProductId(String companyId, String productId) {
        LambdaQueryWrapper<PtlSchemeRules> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PtlSchemeRules::getCompanyId, companyId);
        queryWrapper.eq(PtlSchemeRules::getProductId, productId);
        return baseMapper.selectOne(queryWrapper);
    }


//    private String verificationRule(List<PtlAgreementInsCompanyDto> agreementInsCompany, InsAreaCompany insAreaCompany,
//                                     InsOrders insOrders, StringBuilder logs) {
//        //匹配费用因子
//        //获取所有费用属性
//        List<PtlAgreementUndwrtRulesAttr> undwrtRulesAttrList = ptlAgreementUndwrtRulesAttrService.getUndwrtRulesAttrList();
//        //获取新旧车信息
//        PtlNewCarJudgeRules carJudgeRule = getCarJudgeRule(insAreaCompany.getCompanyId());
//        //获取所有费用属性关联
//        List<RuleAttrMappingVo> ruleAttrMappingVoList = RuleAttrMappingVo.getRuleAttrMappingVoList(insAreaCompany, insOrders,
//                undwrtRulesAttrList, carJudgeRule);
//
//        for (int i = 0; i < agreementProductCosts.size(); i++) {
//            //判断是否匹配
//            log.debug("费用因子匹配开始:" + agreementProductCosts.get(i).getId());
//
//            log.debug("车牌号:" + insOrders.getLicenseno());
//            log.debug("费用因子备注:" + agreementProductCosts.get(i).getCostsDescription());
//            logs.append("费用id:" + agreementProductCosts.get(i).getId() + "\n");
//            logs.append("费用因子描述:" + agreementProductCosts.get(i).getCostsDescription() + "\n");
//            if (judgements(agreementProductCosts.get(i).getCostsAttrLinks(), undwrtRulesAttrList, ruleAttrMappingVoList, logs)) {
//                //返回 费用id   如果需要匹配非车的情况  将返回值返回list 后赛选
//                return agreementProductCosts.get(i).getId();
//            }
//            log.debug("当前费用因子匹配结束\n");
//        }
//        return null;
////        throw new SystemException("费用因子匹配失败");
//    }
}