Revert "核保规则"

This reverts commit 100a97d948a7c3a7335ef0d86f96e78a4e4d9cbf.

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

@@ -24,8 +24,14 @@ 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.*;
-import com.ydtech.modules.protocol.service.*;
+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 org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.math.NumberUtils;
 import org.springframework.stereotype.Service;
@@ -64,9 +70,6 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
     private PtlNewCarJudgeRulesService ptlNewCarJudgeRulesService;
     @Resource
     private PtlAgreementAttributionService ptlAgreementAttributionService;
-    @Resource
-    private PtlAgreementUndwrtRulesService ptlAgreementUndwrtRulesService;
-
 
     /**
      * 根据跟单信息，以及配置的费用因子，获取合适的跟单费用
@@ -1719,501 +1722,4 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
             return null;
         }
     }
-
-    public String matchTheUndwrtRules(FeeSchemeReqDto feeSchemeReqDto) {
-
-        //先根据业务类别、有效期、协议编码、历史标志代码字段 获取对应费用方案列表
-        List<PtlAgreementUndwrtRules> ptlAgreementUndwrtRulesList =ptlAgreementUndwrtRulesService.selectVliadRules(feeSchemeReqDto.getAgreementId());
-        if (ptlAgreementUndwrtRulesList.isEmpty()) {
-
-            //没有有效的核保规则，直接抛出
-            return null;
-        }else{
-            //符合跟单信息的方案列表
-            List<PtlAgreementUndwrtRules> validSchemeList=new ArrayList();
-            //循环符合的方案列表，再进行细化的因子匹配，获取最终可以匹配到的方案
-            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);
-                }
-            }
-            if(validSchemeList.size()>0){
-                PtlAgreementUndwrtRules undwrtRules = validSchemeList.get(0);
-                throw new SystemException("被拒保规则协议号："+undwrtRules.getAgreementId()+"规则Id："+undwrtRules.getId()+"校验住，无法出单，请联系业管支持！");
-            }
-        }
-        return null;
-    }
-    /**
-     * 根据配置的因子表数据，组装标准的待校验因子列表
-     * 新增因子时，顺序需要与getMatchKeyWithInsuranceInfo()方法放入跟单信息一致
-     * @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;
-    }
-    /**
-     * 根据跟单信息，按照约定顺序进行拼接匹配串
-     * 新增因子时，顺序需要与getFactorToBeVerified()方法放入待校验因子一致
-     * @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

@@ -28,7 +28,7 @@ public class PtlAgreementUndwrtRulesSaveDto {
     private Integer rulesType;
 
     @ApiModelProperty("是否有效(0 否 1 是 )")
-    private String validInd;
+    private Integer validInd;
 
     @ApiModelProperty("过户车(0 否 1 是 )")
     private Integer transfer;

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

@@ -70,7 +70,7 @@ public class PtlAgreementUndwrtRules implements Serializable {
      * 是否有效(0 否 1 是 )
      */
     @TableField(value = "valid_ind")
-    private String validInd;
+    private Integer validInd;
 
     /**
      * 过户车(0 否 1 是 )

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

@@ -47,10 +47,4 @@ 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/PtlAgreementUndwrtRulesServiceImpl.java

@@ -1,6 +1,5 @@
 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.po.PtlAgreementUndwrtRules;
@@ -46,19 +45,6 @@ public class PtlAgreementUndwrtRulesServiceImpl extends ServiceImpl<PtlAgreement
             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.in(PtlAgreementUndwrtRules::getValidInd,1);
-        List<PtlAgreementUndwrtRules> ptlAgreementProductCosts = baseMapper.selectList(wrapper);
-        return ptlAgreementProductCosts;
-    }