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.fee.dto.vo.RuleAttrMappingVo;
import com.ydtech.modules.order.entity.InsAreaCompany;
import com.ydtech.modules.order.entity.InsOrders;
import com.ydtech.modules.protocol.entity.dto.PtlAgreementInsCompanyDto;
import com.ydtech.modules.protocol.entity.po.PtlNewCarJudgeRules;
import com.ydtech.modules.protocol.service.ITaxSourceService;
import com.ydtech.modules.protocols.entity.po.PtlAgreementUndwrtRulesAttr;
import com.ydtech.modules.protocols.entity.vo.AgreementProductCosts;
import com.ydtech.modules.scheme.dao.PtlSchemeRulesAttrLinkMapper;
import com.ydtech.modules.scheme.dao.PtlSchemeRulesMapper;
import com.ydtech.modules.scheme.entity.po.*;
import com.ydtech.modules.scheme.entity.vo.*;
import com.ydtech.modules.scheme.service.*;
import com.ydtech.utils.ObjectUtil;
import com.ydtech.utils.idgen.IdGenerate;
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 java.util.*;
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;

    /**
     * 保存规则
     * @param ruleSaveVo
     * @return
     */
    @Override
    @Transactional
    public boolean 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 true;
    }


    /**
     * 修改规则
     * @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;
    }

    /**
     * 根据规则过滤保险公司
     * @param ruleFilterVo
     * @return
     */
    @Override
    public List<PtlAgreementInsCompanyDto> ruleFilterCompany(String userId,RuleFilterVo ruleFilterVo) {
        String deptId = sysUserService.getById(userId).getDeptId();
        //首先获取有权限的保险公司
        List<PtlAgreementInsCompanyDto> agreementInsCompany = taxSourceService.getAllAgreement(deptId, userId);
        //用户可读取的所有保险公司id
        List<String> companyIds = agreementInsCompany.stream().map(PtlAgreementInsCompanyDto::getId).collect(Collectors.toList());

        //获取所有规则的保险公司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);
        //赛选规则
        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) {
                    agreementInsCompany.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<PtlAgreementInsCompanyDto> collect1 = companyIds.stream().map(collect::get).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("费用因子匹配失败");
//    }
}