核保规则

src/main/java/com/ydtech/modules/fee/service/impl/FeeRuleSchemeServiceImpl.java

@@ -24,14 +24,8 @@ import com.ydtech.modules.order.entity.vo.*;
 import com.ydtech.modules.order.service.InsAreaCompanyService;
 import com.ydtech.modules.order.service.InsFeeOrderService;
 import com.ydtech.modules.order.service.InsOrdersService;
-import com.ydtech.modules.protocol.entity.po.PtlAgreement;
-import com.ydtech.modules.protocol.entity.po.PtlAgreementAttribution;
-import com.ydtech.modules.protocol.entity.po.PtlAgreementProductCosts;
-import com.ydtech.modules.protocol.entity.po.PtlNewCarJudgeRules;
-import com.ydtech.modules.protocol.service.PtlAgreementAttributionService;
-import com.ydtech.modules.protocol.service.PtlAgreementProductCostsService;
-import com.ydtech.modules.protocol.service.PtlAgreementService;
-import com.ydtech.modules.protocol.service.PtlNewCarJudgeRulesService;
+import com.ydtech.modules.protocol.entity.po.*;
+import com.ydtech.modules.protocol.service.*;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.math.NumberUtils;
 import org.springframework.stereotype.Service;
@@ -70,6 +64,9 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
     private PtlNewCarJudgeRulesService ptlNewCarJudgeRulesService;
     @Resource
     private PtlAgreementAttributionService ptlAgreementAttributionService;
+    @Resource
+    private PtlAgreementUndwrtRulesService ptlAgreementUndwrtRulesService;
+
 
     /**
      * 根据跟单信息，以及配置的费用因子，获取合适的跟单费用
@@ -1056,6 +1053,7 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
             accidentActualPremium = new BigDecimal(accidentResponseVo.getActualPremium());
         }*/
         FeeSchemeReqDto feeSchemeReqDto = this.getFeeSchemeInfo(quoteInfoVo,quoteRespVo,agreementId,insOrders.getProductid());
+        matchTheUndwrtRules(feeSchemeReqDto);
         FeeSchemeResDto feeSchemeResDto = this.matchTheAppropriateFees(feeSchemeReqDto);
         InsFeeOrder insFeeOrder = new InsFeeOrder(feeSchemeReqDto,feeSchemeResDto,businessNo);
         PtlAgreement agreement=ptlAgreementService.getById(agreementId);
@@ -1722,4 +1720,494 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
             return null;
         }
     }
+
+    public void matchTheUndwrtRules(FeeSchemeReqDto feeSchemeReqDto) {
+
+        //根据协议号获取有效的规则
+        List<PtlAgreementUndwrtRules> ptlAgreementUndwrtRulesList =ptlAgreementUndwrtRulesService.selectVliadRules(feeSchemeReqDto.getAgreementId());
+        if (ptlAgreementUndwrtRulesList.isEmpty()) {
+            //没有有效的核保规则，直接抛出
+            return;
+        }else{
+            //循环有效的规则列表，进行因子匹配，抛出匹配到的因子项
+            for(int i=0;i<ptlAgreementUndwrtRulesList.size();i++){
+                PtlAgreementUndwrtRules undwrtRules = ptlAgreementUndwrtRulesList.get(i);
+                //获取处理后的待校验因子
+                Map<Integer, FeeFactorInfoDto> factorToBeVerified=getFactorToBeVerifiedForRules(undwrtRules);
+                //按规则拼接跟单信息
+                String matchKeyStr=getMatchKeyWithInsuranceInfoForRules(feeSchemeReqDto);
+                //循环进行各项因子校验
+                boolean checkFlag=checkFactorValidWithInsuranceInfo(matchKeyStr,factorToBeVerified);
+                //如果该方案所有因子都校验通过，则放入符合校验方案列表
+                if(checkFlag){
+                    //validSchemeList.add(undwrtRules);
+                    throw new SystemException("被拒保规则规则Id："+undwrtRules.getId()+"校验住，无法出单，请联系业管支持！规则描述信息为："+undwrtRules.getRuleDescription());
+                }
+            }
+        }
+    }
+    /**
+     * 根据配置的因子表数据，组装标准的待校验因子列表
+     * 新增因子时，顺序需要与getMatchKeyWithInsuranceInfoForRules()方法放入跟单信息一致
+     * @param rulesFactor
+     * @return
+     */
+    private Map<Integer, FeeFactorInfoDto> getFactorToBeVerifiedForRules(PtlAgreementUndwrtRules rulesFactor) {
+        Map<Integer, FeeFactorInfoDto> resultMqp=new HashMap<>();
+        //以下各项因子必须按顺序放入MAP，以便校验时关联
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor0=new FeeFactorInfoDto();
+        factor0.setFactorName("是否过户");
+        factor0.setMatchType("1");
+        factor0.setMatchSequence(0);
+        if(rulesFactor.getTransfer()!=null&&rulesFactor.getTransfer()!=9){
+            factor0.setNeedMatch(true);
+            factor0.setSingleSelectVal(String.valueOf(rulesFactor.getTransfer()));
+        }else{
+            //如果方案中未录入(是空或为9时)，则不校验该项因子
+            factor0.setNeedMatch(false);
+        }
+        resultMqp.put(0,factor0);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor1=new FeeFactorInfoDto();
+        factor1.setFactorName("新旧车");
+        factor1.setMatchType("1");
+        factor1.setMatchSequence(1);
+        if(rulesFactor.getOldAndNew()!=null&&rulesFactor.getOldAndNew()!=9){
+            factor1.setNeedMatch(true);
+            factor1.setSingleSelectVal(String.valueOf(rulesFactor.getOldAndNew()));
+        }else{
+            //如果方案中未录入(是空或为9时)，则不校验该项因子
+            factor1.setNeedMatch(false);
+        }
+        resultMqp.put(1,factor1);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor2=new FeeFactorInfoDto();
+        factor2.setFactorName("是否新能源");
+        factor2.setMatchType("1");
+        factor2.setMatchSequence(2);
+        if(rulesFactor.getNewEnergy()!=null&&rulesFactor.getNewEnergy()!=9){
+            factor2.setNeedMatch(true);
+            factor2.setSingleSelectVal(String.valueOf(rulesFactor.getNewEnergy()));
+        }else{
+            //如果方案中未录入(是空或为9时)，则不校验该项因子
+            factor2.setNeedMatch(false);
+        }
+        resultMqp.put(2,factor2);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor3=new FeeFactorInfoDto();
+        factor3.setFactorName("是否续保");
+        factor3.setMatchType("1");
+        factor3.setMatchSequence(3);
+        if(rulesFactor.getRenewal()!=null&&rulesFactor.getRenewal()!=9){
+            factor3.setNeedMatch(true);
+            factor3.setSingleSelectVal(String.valueOf(rulesFactor.getRenewal()));
+        }else{
+            //如果方案中未录入(是空或为9时)，则不校验该项因子
+            factor3.setNeedMatch(false);
+        }
+        resultMqp.put(3,factor3);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor4=new FeeFactorInfoDto();
+        factor4.setFactorName("车辆大类");
+        factor4.setMatchType("2");
+        factor4.setMatchSequence(4);
+        if(rulesFactor.getVehicleCategory()!=null&&!"".equals(rulesFactor.getVehicleCategory())){
+            factor4.setNeedMatch(true);
+            factor4.setMultipleSelectVal(String.valueOf(rulesFactor.getVehicleCategory()));
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor4.setNeedMatch(false);
+        }
+        resultMqp.put(4,factor4);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor5=new FeeFactorInfoDto();
+        factor5.setFactorName("使用性质");
+        factor5.setMatchType("2");
+        factor5.setMatchSequence(5);
+        if(rulesFactor.getNatureOfUse()!=null&&!"".equals(rulesFactor.getNatureOfUse())){
+            factor5.setNeedMatch(true);
+            factor5.setMultipleSelectVal(String.valueOf(rulesFactor.getNatureOfUse()));
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor5.setNeedMatch(false);
+        }
+        resultMqp.put(5,factor5);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor6=new FeeFactorInfoDto();
+        factor6.setFactorName("客车座位数区间");
+        factor6.setMatchType("3");
+        factor6.setMatchSequence(6);
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinSeats(),rulesFactor.getMaxSeats())){
+            factor6.setNeedMatch(true);
+            factor6.setMinRangeVal((double)rulesFactor.getMinSeats());
+            factor6.setMaxRangeVal((double)rulesFactor.getMaxSeats());
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor6.setNeedMatch(false);
+        }
+        resultMqp.put(6,factor6);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor7=new FeeFactorInfoDto();
+        factor7.setFactorName("新车购置价区间");
+        factor7.setMatchType("3");
+        factor7.setMatchSequence(7);
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinPurchasePrice(),rulesFactor.getMaxPurchasePrice())){
+            factor7.setNeedMatch(true);
+            factor7.setMinRangeVal((double)rulesFactor.getMinPurchasePrice());
+            factor7.setMaxRangeVal((double)rulesFactor.getMaxPurchasePrice());
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor7.setNeedMatch(false);
+        }
+        resultMqp.put(7,factor7);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor8=new FeeFactorInfoDto();
+        factor8.setFactorName("核定载质量区间");
+        factor8.setMatchType("3");
+        factor8.setMatchSequence(8);
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinApprovedLoadCapacity(),rulesFactor.getMaxApprovedLoadCapacity())){
+            factor8.setNeedMatch(true);
+            factor8.setMinRangeVal((double)rulesFactor.getMinApprovedLoadCapacity());
+            factor8.setMaxRangeVal((double)rulesFactor.getMaxApprovedLoadCapacity());
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor8.setNeedMatch(false);
+        }
+        resultMqp.put(8,factor8);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor9=new FeeFactorInfoDto();
+        factor9.setFactorName("交强险保费区间");
+        factor9.setMatchType("3");
+        factor9.setMatchSequence(9);
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinCompulsoryInsurancePremium(),rulesFactor.getMaxCompulsoryInsurancePremium())){
+            factor9.setNeedMatch(true);
+            factor9.setMinRangeVal((double)rulesFactor.getMinCompulsoryInsurancePremium());
+            factor9.setMaxRangeVal((double)rulesFactor.getMaxCompulsoryInsurancePremium());
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor9.setNeedMatch(false);
+        }
+        resultMqp.put(9,factor9);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor10=new FeeFactorInfoDto();
+        factor10.setFactorName("车船税金额区间");
+        factor10.setMatchType("3");
+        factor10.setMatchSequence(10);
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinTaxAmount(),rulesFactor.getMaxTaxAmount())){
+            factor10.setNeedMatch(true);
+            factor10.setMinRangeVal((double)rulesFactor.getMinTaxAmount());
+            factor10.setMaxRangeVal((double)rulesFactor.getMaxTaxAmount());
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor10.setNeedMatch(false);
+        }
+        resultMqp.put(10,factor10);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor11=new FeeFactorInfoDto();
+        factor11.setFactorName("三者保额区间");
+        factor11.setMatchType("3");
+        factor11.setMatchSequence(11);
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinTheThreePremium(),rulesFactor.getMaxTheThreePremium())){
+            factor11.setNeedMatch(true);
+            factor11.setMinRangeVal((double)rulesFactor.getMinTheThreePremium()*10000);
+            factor11.setMaxRangeVal((double)rulesFactor.getMaxTheThreePremium()*10000);
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor11.setNeedMatch(false);
+        }
+        resultMqp.put(11,factor11);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor12=new FeeFactorInfoDto();
+        factor12.setFactorName("随车产品保费区间");
+        factor12.setMatchType("3");
+        factor12.setMatchSequence(12);
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinOnboardProductsPremium(),rulesFactor.getMaxOnboardProductsPremium())){
+            factor12.setNeedMatch(true);
+            factor12.setMinRangeVal((double)rulesFactor.getMinOnboardProductsPremium());
+            factor12.setMaxRangeVal((double)rulesFactor.getMaxOnboardProductsPremium());
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor12.setNeedMatch(false);
+        }
+        resultMqp.put(12,factor12);
+
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor13=new FeeFactorInfoDto();
+        factor13.setFactorName("商业险折扣区间");
+        factor13.setMatchType("3");
+        factor13.setMatchSequence(13);
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinCommercialInsuranceDiscount(),rulesFactor.getMaxCommercialInsuranceDiscount())){
+            factor13.setNeedMatch(true);
+            factor13.setMinRangeVal((double)rulesFactor.getMinCommercialInsuranceDiscount());
+            factor13.setMaxRangeVal((double)rulesFactor.getMaxCommercialInsuranceDiscount());
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor13.setNeedMatch(false);
+        }
+        resultMqp.put(13,factor13);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor14=new FeeFactorInfoDto();
+        factor14.setFactorName("交强险折扣区间");
+        factor14.setMatchType("3");
+        factor14.setMatchSequence(14);
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinCompulsoryInsuranceDiscount(),rulesFactor.getMaxCompulsoryInsuranceDiscount())){
+            factor14.setNeedMatch(true);
+            factor14.setMinRangeVal(rulesFactor.getMinCompulsoryInsuranceDiscount());
+            factor14.setMaxRangeVal(rulesFactor.getMaxCompulsoryInsuranceDiscount());
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor14.setNeedMatch(false);
+        }
+        resultMqp.put(14,factor14);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor15=new FeeFactorInfoDto();
+        factor15.setFactorName("保司评分区间");
+        factor15.setMatchType("3");
+        factor15.setMatchSequence(15);
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinScore(),rulesFactor.getMaxScore())){
+            factor15.setNeedMatch(true);
+            factor15.setMinRangeVal((double)rulesFactor.getMinScore());
+            factor15.setMaxRangeVal((double)rulesFactor.getMaxScore());
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor15.setNeedMatch(false);
+        }
+        resultMqp.put(15,factor15);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor16=new FeeFactorInfoDto();
+        factor16.setFactorName("预期赔付率区间");
+        factor16.setMatchType("3");
+        factor16.setMatchSequence(16);
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinLossRation(),rulesFactor.getMaxLossRation())){
+            factor16.setNeedMatch(true);
+            factor16.setMinRangeVal((double)rulesFactor.getMinLossRation());
+            factor16.setMaxRangeVal((double)rulesFactor.getMaxLossRation());
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor16.setNeedMatch(false);
+        }
+        resultMqp.put(16,factor16);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor17=new FeeFactorInfoDto();
+        factor17.setFactorName("车牌号地区");
+        factor17.setMatchType("2");
+        factor17.setMatchSequence(17);
+        if(rulesFactor.getLicenseNumber()!=null&&!"".equals(rulesFactor.getLicenseNumber())){
+            factor17.setNeedMatch(true);
+            String matchStr=rulesFactor.getLicenseNumber();
+            //考虑是否含暂未上牌标志
+            if(rulesFactor.getContainNoLicense()!=null&&"1".equals(rulesFactor.getContainNoLicense())){
+                matchStr=matchStr+",暂未上牌";
+            }
+            factor17.setMultipleSelectVal(matchStr);
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor17.setNeedMatch(false);
+        }
+        resultMqp.put(17,factor17);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor18=new FeeFactorInfoDto();
+
+        factor18.setMatchType("4");
+        factor18.setMatchSequence(18);
+        boolean driverCheckFlag=true;//司机保额是否需要校验
+        boolean passengerCheckFlag=true;//乘客保额是否需要校验
+        //临时赋值，下面方法中使用需要区分
+        factor18.setFactorName("人员司机险保额");
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinDriverAmount(),rulesFactor.getMaxDriverAmount())){
+            factor18.setDriverMinRangeVal(rulesFactor.getMinDriverAmount()*10000);
+            factor18.setDriverMaxRangeVal(rulesFactor.getMaxDriverAmount()*10000);
+        }else{
+            driverCheckFlag=false;
+        }
+        //临时赋值，下面方法中使用需要区分
+        factor18.setFactorName("人员乘客险保额");
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinPassengerAmount(),rulesFactor.getMaxPassengerAmount())){
+            factor18.setPassengerMinRangeVal(rulesFactor.getMinPassengerAmount()*10000);
+            factor18.setPassengerMaxRangeVal(rulesFactor.getMaxPassengerAmount()*10000);
+        }else{
+            passengerCheckFlag=false;
+        }
+        //最终给因子赋值
+        factor18.setFactorName("司乘险保额");
+        factor18.setDriverIsNeedMatch(driverCheckFlag);
+        factor18.setPassengerIsNeedMatch(passengerCheckFlag);
+        //司机、乘客都不需要校验时，不校验该因子
+        if(!driverCheckFlag&&!passengerCheckFlag){
+            factor18.setNeedMatch(false);
+        }else{//需要校验时，需要考虑俩者关联关系
+            if(rulesFactor.getDriverPassengerRelation()!=null&&!"".equals(rulesFactor.getDriverPassengerRelation())){
+                //赋值该因子参数关联关系
+                factor18.setDriverPassengerRelation(rulesFactor.getDriverPassengerRelation());
+                factor18.setNeedMatch(true);
+            }else{
+                factor18.setNeedMatch(false);
+            }
+        }
+        resultMqp.put(18,factor18);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor19=new FeeFactorInfoDto();
+        factor19.setFactorName("被保人年龄");
+        factor19.setMatchType("3");
+        factor19.setMatchSequence(19);
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinInsureAge(),rulesFactor.getMaxInsureAge())){
+            factor19.setNeedMatch(true);
+            factor19.setMinRangeVal((double)rulesFactor.getMinInsureAge());
+            factor19.setMaxRangeVal((double)rulesFactor.getMaxInsureAge());
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor19.setNeedMatch(false);
+        }
+        resultMqp.put(19,factor19);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor20=new FeeFactorInfoDto();
+        factor20.setFactorName("车主年龄");
+        factor20.setMatchType("3");
+        factor20.setMatchSequence(20);
+        if(checkFactorConfigWithAreaForRules(rulesFactor.getMinCarOwnerAge(),rulesFactor.getMaxCarOwnerAge())){
+            factor20.setNeedMatch(true);
+            factor20.setMinRangeVal((double)rulesFactor.getMinCarOwnerAge());
+            factor20.setMaxRangeVal((double)rulesFactor.getMaxCarOwnerAge());
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor20.setNeedMatch(false);
+        }
+        resultMqp.put(20,factor20);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor21=new FeeFactorInfoDto();
+
+        boolean thirdMCheckFlag=true;//三者医保外用保额是否需要校验
+        boolean driverMCheckFlag=true;//司机医保外用保额是否需要校验
+        boolean passengerMCheckFlag=true;//乘客医保外用保额是否需要校验
+        boolean anyMCheckFlag=true;//任意医保外用保额是否需要校验
+        factor21.setMatchType("5");
+        factor21.setMatchSequence(21);
+        //三者
+        if(rulesFactor.getThirdMedicalAmount()!=null&&rulesFactor.getThirdMedicalAmount()!=0){
+            factor21.setThirdMedicalAmountVal(rulesFactor.getThirdMedicalAmount()*10000);
+        }else{
+            factor21.setThirdMedicalAmountVal(null);
+            thirdMCheckFlag=false;
+        }
+        //司机
+        if(rulesFactor.getDriverMedicalAmount()!=null&&rulesFactor.getDriverMedicalAmount()!=0){
+            factor21.setDriverMedicalAmountVal(rulesFactor.getDriverMedicalAmount()*10000);
+        }else{
+            factor21.setDriverMedicalAmountVal(null);
+            driverMCheckFlag=false;
+        }
+        //乘客
+        if(rulesFactor.getPassengerMedicalAmount()!=null&&rulesFactor.getPassengerMedicalAmount()!=0){
+            factor21.setPassengerMedicalAmountVal(rulesFactor.getPassengerMedicalAmount()*10000);
+        }else{
+            factor21.setPassengerMedicalAmountVal(null);
+            passengerMCheckFlag=false;
+        }
+        //任意
+        if(rulesFactor.getAnyMedicalAmount()!=null&&rulesFactor.getAnyMedicalAmount()!=0){
+            factor21.setAnyMedicalAmountVal(rulesFactor.getAnyMedicalAmount()*10000);
+        }else{
+            factor21.setAnyMedicalAmountVal(null);
+            anyMCheckFlag=false;
+        }
+        //最终给因子赋值
+        factor21.setFactorName("医保外用保额");
+        if(!thirdMCheckFlag&&!driverMCheckFlag&&!passengerMCheckFlag&&!anyMCheckFlag){//如果四项都没有配置时，不需要校验
+            factor21.setNeedMatch(false);
+        }else{
+            factor21.setNeedMatch(true);
+        }
+        resultMqp.put(21,factor21);
+        //--------------------因子处理分割线----------------------------------
+        FeeFactorInfoDto factor22=new FeeFactorInfoDto();
+        factor22.setFactorName("业务类型");
+        factor22.setMatchType("2");
+        factor22.setMatchSequence(5);
+        if(rulesFactor.getProductType()!=null&&!"".equals(rulesFactor.getProductType())){
+            factor22.setNeedMatch(true);
+            factor22.setMultipleSelectVal(String.valueOf(rulesFactor.getProductType()));
+        }else{
+            //如果方案中未录入，则不校验该项因子
+            factor22.setNeedMatch(false);
+        }
+        resultMqp.put(22,factor22);
+        //--------------------因子处理分割线----------------------------------
+        return resultMqp;
+    }
+    /**
+     * 判断区间类因子是否需要匹配
+     * @param minVal
+     * @param maxVal
+     * @return
+     */
+    private boolean checkFactorConfigWithAreaForRules(Double minVal, Double maxVal) {
+        boolean result=false; //默认不需要匹配
+        if(minVal!=null&&maxVal!=null){
+            if(minVal==0&&maxVal==0){//初始化没有配置的时候，全部默认的0,这种不需要匹配
+                result=false;
+            }else{
+                if(minVal<=maxVal){
+                    result=true;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * 判断区间类因子是否需要匹配
+     * @param minVal
+     * @param maxVal
+     * @return
+     */
+    private boolean checkFactorConfigWithAreaForRules(Integer minVal, Integer maxVal) {
+        boolean result=false; //默认不需要匹配
+        if(minVal!=null&&maxVal!=null){
+            if(minVal==0&&maxVal==0){//初始化没有配置的时候，全部默认的0,这种不需要匹配
+                result=false;
+            }else{
+                if(minVal<=maxVal){
+                    result=true;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * 根据跟单信息，按照约定顺序进行拼接匹配串
+     * 新增因子时，顺序需要与getFactorToBeVerifiedForRules()方法放入待校验因子一致
+     * @param feeSchemeReqDto
+     * @return
+     */
+    private String getMatchKeyWithInsuranceInfoForRules(FeeSchemeReqDto feeSchemeReqDto) {
+        StringBuffer result=new StringBuffer();
+        result.append(feeSchemeReqDto.getIsTransfer()).append(",");
+        result.append(feeSchemeReqDto.getIsNewCar()).append(",");
+        result.append(feeSchemeReqDto.getIsNewEnergy()).append(",");
+        result.append(feeSchemeReqDto.getIsRenewal()).append(",");
+        result.append(feeSchemeReqDto.getVehicleCategory()).append(",");
+        result.append(feeSchemeReqDto.getUseNature()).append(",");
+        result.append(feeSchemeReqDto.getSeatNum()).append(",");
+        result.append(feeSchemeReqDto.getPurchasePrice()).append(",");
+        result.append(feeSchemeReqDto.getApprovedLoadCapacity()).append(",");
+        result.append(feeSchemeReqDto.getJqPremium()).append(",");
+        result.append(feeSchemeReqDto.getSumPayTax()).append(",");
+        result.append(feeSchemeReqDto.getThirdPartyInsurance()).append(",");
+        result.append(feeSchemeReqDto.getNoCarPremium()).append(",");
+        result.append(feeSchemeReqDto.getSyDiscount()).append(",");
+        result.append(feeSchemeReqDto.getJqDiscount()).append(",");
+        result.append(feeSchemeReqDto.getInsuranceScore()).append(",");
+        result.append(feeSchemeReqDto.getExpectedLossRate()).append(",");
+        result.append(feeSchemeReqDto.getLicenseNo()).append(",");
+        //司乘险保额因子，特殊处理(司机保额-乘客保额)
+        result.append(StringUtils.isNotEmpty(feeSchemeReqDto.getDriverAmount())?feeSchemeReqDto.getDriverAmount():"NULL").append("-").append(StringUtils.isNotEmpty(feeSchemeReqDto.getPassengerAmount())?feeSchemeReqDto.getPassengerAmount():"NULL").append(",");
+        result.append(feeSchemeReqDto.getInsureAge()).append(",");
+        result.append(feeSchemeReqDto.getCarOwnerAge()).append(",");
+        //医保外用险保额因子，特殊处理(三者保额-司机保额-乘客保额)
+        result.append(StringUtils.isNotEmpty(feeSchemeReqDto.getThirdMedicalAmount())?feeSchemeReqDto.getThirdMedicalAmount():"NULL").append("-")
+                .append(StringUtils.isNotEmpty(feeSchemeReqDto.getDriverMedicalAmount())?feeSchemeReqDto.getDriverMedicalAmount():"NULL").append("-")
+                .append(StringUtils.isNotEmpty(feeSchemeReqDto.getPassengerMedicalAmount())?feeSchemeReqDto.getPassengerMedicalAmount():"NULL");
+        result.append(feeSchemeReqDto.getBusType()).append(",");
+        return result.toString();
+    }
 }

src/main/java/com/ydtech/modules/protocol/entity/dto/PtlAgreementUndwrtRulesSaveDto.java

@@ -15,11 +15,8 @@ import java.util.stream.Collectors;
 public class PtlAgreementUndwrtRulesSaveDto {
 
 
-    @ApiModelProperty("产品id")
-    private String productId;
-
-    @ApiModelProperty("产品名称")
-    private String productName;
+    @ApiModelProperty("业务类型")
+    private String productType;
 
     @ApiModelProperty("规则描述")
     private String ruleDescription;
@@ -28,7 +25,7 @@ public class PtlAgreementUndwrtRulesSaveDto {
     private Integer rulesType;
 
     @ApiModelProperty("是否有效(0 否 1 是 )")
-    private Integer validInd;
+    private String validInd;
 
     @ApiModelProperty("过户车(0 否 1 是 )")
     private Integer transfer;
@@ -168,10 +165,12 @@ public class PtlAgreementUndwrtRulesSaveDto {
     @ApiModelProperty("医保外用乘客")
     private Integer passengerMedicalAmount;
 
+    public PtlAgreementUndwrtRulesSaveDto() {
+    }
 
 
-    public static List<PtlAgreementUndwrtRulesSaveDto> toPltAgreementRuleSaveDto(List<PtlAgreementUndwrtRules> productCosts) {
-        return productCosts.stream().map(PtlAgreementUndwrtRulesSaveDto::new).collect(Collectors.toList());
+    public static List<PtlAgreementUndwrtRulesSaveDto> toPltAgreementRuleSaveDto(List<PtlAgreementUndwrtRules> ptlAgreementUndwrtRulesList) {
+        return ptlAgreementUndwrtRulesList.stream().map(PtlAgreementUndwrtRulesSaveDto::new).collect(Collectors.toList());
     }
 
     public PtlAgreementUndwrtRulesSaveDto(PtlAgreementUndwrtRules ptlAgreementUndwrtRules) {

src/main/java/com/ydtech/modules/protocol/entity/po/PtlAgreementUndwrtRules.java

@@ -49,16 +49,11 @@ public class PtlAgreementUndwrtRules implements Serializable {
     private Integer rulesType;
 
     /**
-     * 产品id
+     * 业务类型
      */
-    @TableField(value = "product_id")
-    private String productId;
+    @TableField(value = "product_type")
+    private String productType;
 
-    /**
-     * 产品名称
-     */
-    @TableField(value = "product_name")
-    private String productName;
 
     /**
      * 规则描述
@@ -70,7 +65,7 @@ public class PtlAgreementUndwrtRules implements Serializable {
      * 是否有效(0 否 1 是 )
      */
     @TableField(value = "valid_ind")
-    private Integer validInd;
+    private String validInd;
 
     /**
      * 过户车(0 否 1 是 )
@@ -295,11 +290,6 @@ public class PtlAgreementUndwrtRules implements Serializable {
     @TableField(value = "driver_passenger_relation")
     private String driverPassengerRelation;
 
-    /**
-     * 方案优先级别
-     */
-    @TableField(value = "priority_level")
-    private Integer priorityLevel;
 
     /**
      * 被保人年龄(最小)
@@ -352,19 +342,15 @@ public class PtlAgreementUndwrtRules implements Serializable {
 
     /**
      * @param agreementId                         协议id
-     * @param productId                           产品id
-     * @param productName                         产品名称
      * @param ptlAgreementUndwrtRulesSaveDtoList 协议费用 Dto list
      * @return List<PtlAgreementProductCosts>
      */
-    public static List<PtlAgreementUndwrtRules> toPtlAgreementUndwrtRulesSaveDtoList(String agreementId, String productId, String productName, List<PtlAgreementUndwrtRulesSaveDto> ptlAgreementUndwrtRulesSaveDtoList) {
-        return ptlAgreementUndwrtRulesSaveDtoList.stream().map(ptlAgreementUndwrtRulesSaveDto -> new PtlAgreementUndwrtRules(agreementId, productId, productName, ptlAgreementUndwrtRulesSaveDto)).collect(Collectors.toList());
+    public static List<PtlAgreementUndwrtRules> toPtlAgreementUndwrtRulesSaveDtoList(String agreementId,  List<PtlAgreementUndwrtRulesSaveDto> ptlAgreementUndwrtRulesSaveDtoList) {
+        return ptlAgreementUndwrtRulesSaveDtoList.stream().map(ptlAgreementUndwrtRulesSaveDto -> new PtlAgreementUndwrtRules(agreementId,  ptlAgreementUndwrtRulesSaveDto)).collect(Collectors.toList());
     }
 
-    public PtlAgreementUndwrtRules(String agreementId, String productId, String productName, PtlAgreementUndwrtRulesSaveDto ptlAgreementUndwrtRulesSaveDto) {
+    public PtlAgreementUndwrtRules(String agreementId, PtlAgreementUndwrtRulesSaveDto ptlAgreementUndwrtRulesSaveDto) {
         this.agreementId = agreementId;
-        this.productId = productId;
-        this.productName = productName;
         BeanUtils.copyProperties(ptlAgreementUndwrtRulesSaveDto, this);
     }
 
@@ -376,8 +362,7 @@ public class PtlAgreementUndwrtRules implements Serializable {
     public int getHashCode() {
         int result = 0;
         result = getObjectHashCode(this.agreementId, result);
-        result = getObjectHashCode(this.productId, result);
-        result = getObjectHashCode(this.productName, result);
+        result = getObjectHashCode(this.productType, result);
         result = getObjectHashCode(this.transfer, result);
         result = getObjectHashCode(this.oldAndNew, result);
         result = getObjectHashCode(this.newEnergy, result);
@@ -416,7 +401,6 @@ public class PtlAgreementUndwrtRules implements Serializable {
         result = getObjectHashCode(this.minPassengerAmount, result);
         result = getObjectHashCode(this.maxPassengerAmount, result);
         result = getObjectHashCode(this.driverPassengerRelation, result);
-        result = getObjectHashCode(this.priorityLevel,result);
         result = getObjectHashCode(this.minInsureAge,result);
         result = getObjectHashCode(this.maxInsureAge,result);
         result = getObjectHashCode(this.minCarOwnerAge,result);

src/main/java/com/ydtech/modules/protocol/entity/vo/PtlAgreementQueryVo.java

@@ -1,7 +1,11 @@
 package com.ydtech.modules.protocol.entity.vo;
 
 import com.ydtech.modules.protocol.entity.dto.PltAgreementSchemeSaveDto;
-import com.ydtech.modules.protocol.entity.po.*;
+import com.ydtech.modules.protocol.entity.dto.PtlAgreementUndwrtRulesSaveDto;
+import com.ydtech.modules.protocol.entity.po.PtlAgreement;
+import com.ydtech.modules.protocol.entity.po.PtlAgreementAttribution;
+import com.ydtech.modules.protocol.entity.po.PtlAgreementDept;
+import com.ydtech.modules.protocol.entity.po.PtlAgreementNonCarProductCosts;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.AllArgsConstructor;
 import lombok.Data;
@@ -24,7 +28,7 @@ public class PtlAgreementQueryVo {
     private List<PtlAgreementNonCarProductCosts> nonCarProductCosts;
 
     @ApiModelProperty("承保规则")
-    List<PtlAgreementUnderwritingRules> underwritingRules;
+    private List<PtlAgreementUndwrtRulesSaveDto> underwritingRules;
 
     @ApiModelProperty("账号信息")
     private PtlAgreementAttribution ptlAgreementAttribution;

src/main/java/com/ydtech/modules/protocol/entity/vo/PtlAgreementSaveVo.java

@@ -4,8 +4,7 @@ package com.ydtech.modules.protocol.entity.vo;
 import com.ydtech.modules.protocol.entity.dto.PltAgreementSchemeSaveDto;
 import com.ydtech.modules.protocol.entity.dto.PtlAgreementAttributionDto;
 import com.ydtech.modules.protocol.entity.dto.PtlAgreementSaveDto;
-import com.ydtech.modules.protocol.entity.dto.PtlAgreementUnderwritingRulesSaveDto;
-import com.ydtech.modules.protocol.entity.po.PtlAgreementUndwrtRules;
+import com.ydtech.modules.protocol.entity.dto.PtlAgreementUndwrtRulesSaveDto;
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
@@ -26,7 +25,7 @@ public class PtlAgreementSaveVo {
     private List<PtlAgreementNonCarProductCostsSaveVo> nonCarProductCosts;
 
     @ApiModelProperty("承保规则")
-    private List<PtlAgreementUnderwritingRulesSaveDto> underwritingRules;
+    private List<PtlAgreementUndwrtRulesSaveDto> underwritingRules;
 
     @ApiModelProperty("授权部门id")
     private List<String> dept;

src/main/java/com/ydtech/modules/protocol/service/PtlAgreementUndwrtRulesService.java

@@ -2,6 +2,7 @@ package com.ydtech.modules.protocol.service;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.IService;
+import com.ydtech.modules.protocol.entity.dto.PtlAgreementUndwrtRulesSaveDto;
 import com.ydtech.modules.protocol.entity.po.PtlAgreementUndwrtRules;
 
 import java.util.List;
@@ -25,15 +26,15 @@ public interface PtlAgreementUndwrtRulesService extends IService<PtlAgreementUnd
      *
      * @param agreementId 协议id
      */
-    List<PtlAgreementUndwrtRules> getByAgreementId(String agreementId);
+    List<PtlAgreementUndwrtRulesSaveDto> getByAgreementId(String agreementId);
 
     /**
      * 批量提添加承保规则
      *
      * @param agreementId 协议id
-     * @param undwrtRulesList      产品
+     * @param undwrtRulesSaveDtoList      产品
      */
-    void saveBatchProductCosts(String agreementId, List<PtlAgreementUndwrtRules> undwrtRulesList);
+    void saveBatchProductCosts(String agreementId, List<PtlAgreementUndwrtRulesSaveDto> undwrtRulesSaveDtoList);
 
     /**
      * 通过 协议id 构造查询条件
@@ -47,4 +48,10 @@ public interface PtlAgreementUndwrtRulesService extends IService<PtlAgreementUnd
         return wrapper;
     }
 
+    /**
+     * 通过协议ID 获取需要进行匹配的核保规则
+     * @param agreementId
+     * @return
+     */
+    List<PtlAgreementUndwrtRules> selectVliadRules(String agreementId);
 }

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

@@ -62,10 +62,12 @@ public class PtlAgreementServiceImpl extends ServiceImpl<PtlAgreementMapper, Ptl
 
     private final PtlAgreementNonCarProductCostsService ptlAgreementNonCarProductCostsService;
 
+    private final PtlAgreementUndwrtRulesService ptlAgreementUndwrtRulesService;
+
     public PtlAgreementServiceImpl(PtlAgreementProductCostsService ptlAgreementProductCostsService, PtlAgreementUnderwritingRulesService ptlAgreementUnderwritingRulesService,
                                    PtlAgreementAttributionService ptlAgreementAttributionService, PtlAgreementDeptService ptlAgreementDeptService,
                                    EsmInsCompanyService esmInsCompanyService, PtlAgreementNonCarProductCostsService ptlAgreementNonCarProductCostsService,
-                                   @Lazy InsCrawlerOrderService insCrawlerOrderController, @Lazy PtlAgreementService proxyObject,PtlNonCarInsuranceProductService ptlNonCarInsuranceProductService) {
+                                   @Lazy InsCrawlerOrderService insCrawlerOrderController, @Lazy PtlAgreementService proxyObject,PtlNonCarInsuranceProductService ptlNonCarInsuranceProductService,@Lazy PtlAgreementUndwrtRulesService ptlAgreementUndwrtRulesService) {
         this.ptlAgreementProductCostsService = ptlAgreementProductCostsService;
         this.ptlAgreementUnderwritingRulesService = ptlAgreementUnderwritingRulesService;
         this.ptlAgreementAttributionService = ptlAgreementAttributionService;
@@ -75,6 +77,7 @@ public class PtlAgreementServiceImpl extends ServiceImpl<PtlAgreementMapper, Ptl
         this.insCrawlerOrderController = insCrawlerOrderController;
         this.proxyObject = proxyObject;
         this.ptlNonCarInsuranceProductService=ptlNonCarInsuranceProductService;
+        this.ptlAgreementUndwrtRulesService=ptlAgreementUndwrtRulesService;
     }
 
 
@@ -153,7 +156,7 @@ public class PtlAgreementServiceImpl extends ServiceImpl<PtlAgreementMapper, Ptl
         // 获取非车险产品费用
         List<PtlAgreementNonCarProductCosts> nonCarProductCosts = ptlAgreementNonCarProductCostsService.getByAgreementId(agreementId);
         // 获取承保规则
-        List<PtlAgreementUnderwritingRules> underwritingRules = ptlAgreementUnderwritingRulesService.getByAgreementId(agreementId);
+        List<PtlAgreementUndwrtRulesSaveDto> underwritingRules = ptlAgreementUndwrtRulesService.getByAgreementId(agreementId);
         //  账号信息查询
         PtlAgreementAttribution ptlAgreementAttribution = ptlAgreementAttributionService.getById(agreementId);
         //2023-08-28 lig 增加  解决前端空对象为null问题，改为返回为空对象
@@ -241,7 +244,7 @@ public class PtlAgreementServiceImpl extends ServiceImpl<PtlAgreementMapper, Ptl
             }
         }
         // 承包规则
-        ptlAgreementUnderwritingRulesService.saveBatchUnderwritingRules(agreementId, agreement.getUnderwritingRules());
+        ptlAgreementUndwrtRulesService.saveBatchProductCosts(agreementId,agreement.getUnderwritingRules());
         // 账号添加
         PtlAgreementAttributionDto attribution = agreement.getAttribution();
         if (StringUtils.isNotEmpty(attribution.getTemplateId())) {
@@ -265,7 +268,7 @@ public class PtlAgreementServiceImpl extends ServiceImpl<PtlAgreementMapper, Ptl
         // 删除非车险产品费用
         ptlAgreementNonCarProductCostsService.deleteByAgreementId(agreementId);
         // 删除承保规则
-        ptlAgreementUnderwritingRulesService.deleteByAgreementId(agreementId);
+        ptlAgreementUndwrtRulesService.deleteByAgreementId(agreementId);
         // 删除账号信息
         ptlAgreementAttributionService.removeById(agreementId);
         // 删除授权部门

src/main/java/com/ydtech/modules/protocol/service/impl/PtlAgreementUndwrtRulesServiceImpl.java

@@ -1,7 +1,9 @@
 package com.ydtech.modules.protocol.service.impl;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.ydtech.modules.protocol.dao.PtlAgreementUndwrtRulesMapper;
+import com.ydtech.modules.protocol.entity.dto.PtlAgreementUndwrtRulesSaveDto;
 import com.ydtech.modules.protocol.entity.po.PtlAgreementUndwrtRules;
 import com.ydtech.modules.protocol.service.PtlAgreementAttributionService;
 import com.ydtech.modules.protocol.service.PtlAgreementUndwrtRulesService;
@@ -13,7 +15,7 @@ import java.util.List;
 
 /**
  * @author CXP
- * @description 针对表【ptl_agreement_undwrt_rules(协议产品费用)】的数据库操作Service实现
+ * @description 针对表【ptl_agreement_undwrt_rules(协议承保规则)】的数据库操作Service实现
  * @createDate 2023年12月20日22:25:57
  */
 @Service
@@ -32,19 +34,35 @@ public class PtlAgreementUndwrtRulesServiceImpl extends ServiceImpl<PtlAgreement
     }
 
     @Override
-    public List<PtlAgreementUndwrtRules> getByAgreementId(String agreementId) {
+    public List<PtlAgreementUndwrtRulesSaveDto> getByAgreementId(String agreementId) {
         List<PtlAgreementUndwrtRules> ptlAgreementUndwrtRulesList = baseMapper.selectList(getByAgreementIdWrapper(agreementId));
-        return ptlAgreementUndwrtRulesList;
+
+        List<PtlAgreementUndwrtRulesSaveDto> undwrtRulesSaveDtoList = PtlAgreementUndwrtRulesSaveDto.toPltAgreementRuleSaveDto(ptlAgreementUndwrtRulesList);
+        return undwrtRulesSaveDtoList;
     }
 
     @Override
     @Transactional
-    public void saveBatchProductCosts(String agreementId, List<PtlAgreementUndwrtRules> ptlAgreementUndwrtRulesList) {
-        if (ptlAgreementUndwrtRulesList != null && !ptlAgreementUndwrtRulesList.isEmpty()) {
+    public void saveBatchProductCosts(String agreementId, List<PtlAgreementUndwrtRulesSaveDto> undwrtRulesSaveDtoList) {
+        if (undwrtRulesSaveDtoList != null && !undwrtRulesSaveDtoList.isEmpty()) {
+            List<PtlAgreementUndwrtRules> ptlAgreementUndwrtRulesList = PtlAgreementUndwrtRules.toPtlAgreementUndwrtRulesSaveDtoList(agreementId, undwrtRulesSaveDtoList);
             boolean b = saveBatch(ptlAgreementUndwrtRulesList);
             AssertionUtils.isSucceed(b, "批量添加承保规则失败");
         }
     }
+    /**
+     * 通过协议ID 获取需要进行匹配的核保规则
+     * @param agreementId
+     * @return
+     */
+    @Override
+    public List<PtlAgreementUndwrtRules> selectVliadRules(String agreementId){
+        LambdaQueryWrapper<PtlAgreementUndwrtRules> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(PtlAgreementUndwrtRules::getAgreementId, agreementId);
+        wrapper.eq(PtlAgreementUndwrtRules::getValidInd,1);
+        List<PtlAgreementUndwrtRules> ptlAgreementProductCosts = baseMapper.selectList(wrapper);
+        return ptlAgreementProductCosts;
+    }