1、增加司机、乘客保额 2、增加税前税后计费标志 3、三者、司乘保额单位改成万

src/main/java/com/ydtech/modules/fee/dto/FeeFactorInfoDto.java

@@ -28,4 +28,20 @@ public class FeeFactorInfoDto {
     private String multipleSelectVal;
     @ApiModelProperty("单选字符串")
     private String singleSelectVal;
+    @ApiModelProperty("司机保额区间最小值")
+    private Integer driverMinRangeVal;
+    @ApiModelProperty("司机保额区间最大值")
+    private Integer driverMaxRangeVal;
+    @ApiModelProperty("司机保额是否需要匹配")
+    private boolean driverIsNeedMatch;
+    @ApiModelProperty("乘客保额区间最小值")
+    private Integer passengerMinRangeVal;
+    @ApiModelProperty("乘客保额区间最大值")
+    private Integer passengerMaxRangeVal;
+    @ApiModelProperty("乘客保额是否需要匹配")
+    private boolean passengerIsNeedMatch;
+    @ApiModelProperty("司乘保额校验关联关系")
+    private String driverPassengerRelation;
+
+
 }

src/main/java/com/ydtech/modules/fee/dto/FeeSchemeReqDto.java

@@ -53,5 +53,9 @@ public class FeeSchemeReqDto {
     private String expectedLossRate;
     @ApiModelProperty("车牌号")
     private String licenseNo;
+    @ApiModelProperty("人员司机险保额")
+    private String driverAmount;
+    @ApiModelProperty("人员乘客险保额")
+    private String passengerAmount;
 
 }

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

@@ -26,8 +26,10 @@ import com.ydtech.modules.order.entity.vo.QueryOrderFeeVo;
 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.PtlAgreementProductCosts;
 import com.ydtech.modules.protocol.service.PtlAgreementProductCostsService;
+import com.ydtech.modules.protocol.service.PtlAgreementService;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.math.NumberUtils;
 import org.springframework.stereotype.Service;
@@ -60,7 +62,8 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
     private EsmUserReferrerService esmUserReferrerService;
     @Resource
     private InsAreaCompanyService insAreaCompanyService;
-
+    @Resource
+    private PtlAgreementService ptlAgreementService;
 
 
     /**
@@ -266,6 +269,86 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
                     result=false;
                     break;
                 }
+            }else if("4".equals(checkFactorInfo.getMatchType())){//4.特殊规则，司乘险校验，存在关联关系需要单独判断
+                if(matchKeys[key]!=null){
+                    //先获取跟单司机、乘客保额
+                    String[] kindAmountStr= matchKeys[key].split("-");
+                    String driverAmount="NULL".equals(kindAmountStr[0])?"0":kindAmountStr[0];
+                    String passengerAmount="NULL".equals(kindAmountStr[1])?"0":kindAmountStr[1];
+                    if("0".equals(checkFactorInfo.getDriverPassengerRelation())){//无关系，则各自校验各自，有一个不符合，则方案不符合
+                        if(NumberUtils.isCreatable(driverAmount)){//如果司机保额是数字，则可以进行校验
+                            if(checkFactorInfo.isDriverIsNeedMatch()){
+                                //如果需要匹配，且匹配成功，则跳过本次循环，继续校验下一因子
+                                if(Double.parseDouble(driverAmount)>=checkFactorInfo.getDriverMinRangeVal()&&Double.parseDouble(driverAmount)<=checkFactorInfo.getDriverMaxRangeVal()){
+                                    result=true;
+                                    continue;
+                                }else{
+                                    //如果需要匹配且没有匹配到，则直接跳出循环，该方案不符合
+                                    result=false;
+                                    break;
+                                }
+                            }
+                        }
+                        if(NumberUtils.isCreatable(passengerAmount)){//如果司机保额是数字，则可以进行校验
+                            if(checkFactorInfo.isPassengerIsNeedMatch()){
+                                //如果需要匹配，且匹配成功，则跳过本次循环，继续校验下一因子
+                                if(Double.parseDouble(passengerAmount)>=checkFactorInfo.getPassengerMinRangeVal()&&Double.parseDouble(passengerAmount)<=checkFactorInfo.getPassengerMaxRangeVal()){
+                                    result=true;
+                                    continue;
+                                }else{
+                                    //如果需要匹配且没有匹配到，则直接跳出循环，该方案不符合
+                                    result=false;
+                                    break;
+                                }
+                            }
+                        }
+                    }else if("1".equals(checkFactorInfo.getDriverPassengerRelation())){//或的关系  2个里面有一个通过则通过
+                        boolean isDriverPass=false;
+                        boolean isPassengerPass=false;
+                        if(NumberUtils.isCreatable(driverAmount)){//如果司机保额是数字，则可以进行校验
+                            //如果需要匹配，且匹配成功，则跳过本次循环，继续校验下一因子
+                            if(Double.parseDouble(driverAmount)>=checkFactorInfo.getDriverMinRangeVal()&&Double.parseDouble(driverAmount)<=checkFactorInfo.getDriverMaxRangeVal()){
+                                isDriverPass=true;
+                            }
+                        }
+                        if(NumberUtils.isCreatable(passengerAmount)){//如果司机保额是数字，则可以进行校验
+                            //如果需要匹配，且匹配成功，则跳过本次循环，继续校验下一因子
+                            if(Double.parseDouble(passengerAmount)>=checkFactorInfo.getPassengerMinRangeVal()&&Double.parseDouble(passengerAmount)<=checkFactorInfo.getPassengerMaxRangeVal()){
+                                isPassengerPass=true;
+                            }
+                        }
+                        if(!isDriverPass&&!isPassengerPass){//两项都不通过的时候，才不符合
+                            result=false;
+                            break;
+                        }else{
+                            result=true;
+                            continue;
+                        }
+
+                    }else if("2".equals(checkFactorInfo.getDriverPassengerRelation())){//且的关系  2个全部通过才算通过
+                        boolean isDriverPass=false;
+                        boolean isPassengerPass=false;
+                        if(NumberUtils.isCreatable(driverAmount)){//如果司机保额是数字，则可以进行校验
+                            //如果需要匹配，且匹配成功，则跳过本次循环，继续校验下一因子
+                            if(Double.parseDouble(driverAmount)>=checkFactorInfo.getDriverMinRangeVal()&&Double.parseDouble(driverAmount)<=checkFactorInfo.getDriverMaxRangeVal()){
+                                isDriverPass=true;
+                            }
+                        }
+                        if(NumberUtils.isCreatable(passengerAmount)){//如果司机保额是数字，则可以进行校验
+                            //如果需要匹配，且匹配成功，则跳过本次循环，继续校验下一因子
+                            if(Double.parseDouble(passengerAmount)>=checkFactorInfo.getPassengerMinRangeVal()&&Double.parseDouble(passengerAmount)<=checkFactorInfo.getPassengerMaxRangeVal()){
+                                isPassengerPass=true;
+                            }
+                        }
+                        if(isDriverPass&&isPassengerPass){//两项都通过的时候，才符合
+                            result=true;
+                            continue;
+                        }else{
+                            result=false;
+                            break;
+                        }
+                    }
+                }
             }
         }
 
@@ -297,7 +380,8 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
         result.append(feeSchemeReqDto.getJqDiscount()).append(",");
         result.append(feeSchemeReqDto.getInsuranceScore()).append(",");
         result.append(feeSchemeReqDto.getExpectedLossRate()).append(",");
-        result.append(feeSchemeReqDto.getLicenseNo());
+        result.append(feeSchemeReqDto.getLicenseNo()).append(",");
+        result.append(StringUtils.isNotEmpty(feeSchemeReqDto.getDriverAmount())?feeSchemeReqDto.getDriverAmount():"NULL").append("-").append(StringUtils.isNotEmpty(feeSchemeReqDto.getPassengerAmount())?feeSchemeReqDto.getPassengerAmount():"NULL");//司乘险保额因子，特殊处理
         return result.toString();
     }
 
@@ -465,8 +549,8 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
         factor11.setMatchSequence(11);
         if(checkFactorConfigWithArea(factorCost.getMinTheThreePremium(),factorCost.getMaxTheThreePremium(),factor11,factorCost)){
             factor11.setNeedMatch(true);
-            factor11.setMinRangeVal(factorCost.getMinTheThreePremium());
-            factor11.setMaxRangeVal(factorCost.getMaxTheThreePremium());
+            factor11.setMinRangeVal(factorCost.getMinTheThreePremium()*10000);
+            factor11.setMaxRangeVal(factorCost.getMaxTheThreePremium()*10000);
         }else{
             //如果方案中未录入，则不校验该项因子
             factor11.setNeedMatch(false);
@@ -561,6 +645,47 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
             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(checkFactorConfigWithArea(factorCost.getMinDriverAmount(),factorCost.getMaxDriverAmount(),factor18,factorCost)){
+            factor18.setDriverMinRangeVal(factorCost.getMinDriverAmount()*10000);
+            factor18.setDriverMaxRangeVal(factorCost.getMaxDriverAmount()*10000);
+        }else{
+            driverCheckFlag=false;
+        }
+        //临时赋值，下面方法中使用需要区分
+        factor18.setFactorName("人员乘客险保额");
+        if(checkFactorConfigWithArea(factorCost.getMinPassengerAmount(),factorCost.getMaxPassengerAmount(),factor18,factorCost)){
+            factor18.setPassengerMinRangeVal(factorCost.getMinPassengerAmount()*10000);
+            factor18.setPassengerMaxRangeVal(factorCost.getMaxPassengerAmount()*10000);
+        }else{
+            passengerCheckFlag=false;
+        }
+        //最终给因子赋值
+        factor18.setFactorName("司乘险保额");
+        factor18.setDriverIsNeedMatch(driverCheckFlag);
+        factor18.setPassengerIsNeedMatch(passengerCheckFlag);
+        //司机、乘客都不需要校验时，不校验该因子
+        if(!driverCheckFlag&&!passengerCheckFlag){
+            factor18.setNeedMatch(false);
+        }else{//需要校验时，需要考虑俩者关联关系
+            if(factorCost.getDriverPassengerRelation()!=null&&!"".equals(factorCost.getDriverPassengerRelation())){
+                //赋值该因子参数关联关系
+                factor18.setDriverPassengerRelation(factorCost.getDriverPassengerRelation());
+                factor18.setNeedMatch(true);
+            }else{
+                throw new SystemException("协议ID:"+factorCost.getAgreementId()+" 方案序号:"+factorCost.getId()+" 费用因子:"+factor18.getFactorName()+"关联关系配置有问题，请检查!");
+            }
+        }
+        resultMqp.put(18,factor18);
+        //--------------------因子处理分割线----------------------------------
         return resultMqp;
     }
 
@@ -601,11 +726,23 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
         CarInfoVo carInfoVo = quoteInfoVo.getCarInfo();
         List<KindInfoVo> kindList = quoteInfoVo.getKindList();
         String thirdPartyInsurance = "";
+        String driverAmount="";
+        String passengerAmount="";
         if(kindList!=null && kindList.size()>0){
             for(KindInfoVo kindInfoVo:kindList){
+                //三者保额
                 if("B".equals(kindInfoVo.getKindCode())){
                     thirdPartyInsurance = String.valueOf(kindInfoVo.getAmount());
                 }
+                //司机保额
+                if("D3".equals(kindInfoVo.getKindCode())){
+                    driverAmount = String.valueOf(kindInfoVo.getAmount());
+                }
+                //乘客保额
+                if("D4".equals(kindInfoVo.getKindCode())){
+                    int quantity = Integer.parseInt(carInfoVo.getSeatCount())-1;
+                    passengerAmount = String.valueOf(kindInfoVo.getUnitAmount()*quantity);
+                }
             }
         }
         FeeSchemeReqDto feeSchemeReqDto = new FeeSchemeReqDto();
@@ -663,6 +800,9 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
         }else{
             feeSchemeReqDto.setLicenseNo("暂未上牌");//车牌号
         }
+
+        feeSchemeReqDto.setDriverAmount(driverAmount);//人员司机险保额  准
+        feeSchemeReqDto.setPassengerAmount(passengerAmount);//人员乘客险保额  准
         return feeSchemeReqDto;
     }
 
@@ -673,9 +813,15 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
         FeeSchemeReqDto feeSchemeReqDto = this.getFeeSchemeInfo(quoteInfoVo,quoteRespVo,agreementId,insOrders.getProductid());
         FeeSchemeResDto feeSchemeResDto = this.matchTheAppropriateFees(feeSchemeReqDto);
         InsFeeOrder insFeeOrder = new InsFeeOrder(feeSchemeReqDto,feeSchemeResDto,businessNo);
+        PtlAgreement agreement=ptlAgreementService.getById(agreementId);
         //先通过含税保费计算出不含税保费 公式 总保费/(1+增值税率) 目前增值税率是0.06
         if(insFeeOrder.getJqPremium().doubleValue()>0){
-            jqNoTaxPremium = insFeeOrder.getJqPremium().divide(new BigDecimal(1+0.06),BigDecimal.ROUND_HALF_UP,2);
+            //默认用含税保费计算
+            jqNoTaxPremium=insFeeOrder.getJqPremium();
+            //如果协议中配置为不含税结算时，计算不含税保费
+            if(StringUtils.isNotEmpty(agreement.getWithTax())&&"否".equals(agreement.getWithTax())){
+                jqNoTaxPremium = insFeeOrder.getJqPremium().divide(new BigDecimal(1+0.06),BigDecimal.ROUND_HALF_UP,2);
+            }
             insFeeOrder.setJqNoTaxPremium(jqNoTaxPremium);
             //交强险总费用
             insFeeOrder.setJqCostsPremiums(getPremium(jqNoTaxPremium,insFeeOrder.getJqCostsProportion()));
@@ -695,7 +841,12 @@ public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
             insFeeOrder.setJqSpilloverPremiums(getPremium(jqNoTaxPremium,insFeeOrder.getJqSpilloverProportion()));
         }
         if(insFeeOrder.getSyPremium().doubleValue()>0){
-            syNoTaxPremium = insFeeOrder.getSyPremium().divide(new BigDecimal(1+0.06),BigDecimal.ROUND_HALF_UP,2);
+            //默认用含税保费计算
+            syNoTaxPremium = insFeeOrder.getSyPremium();
+            //如果协议中配置为不含税结算时，计算不含税保费
+            if(StringUtils.isNotEmpty(agreement.getWithTax())&&"否".equals(agreement.getWithTax())){
+                syNoTaxPremium = insFeeOrder.getSyPremium().divide(new BigDecimal(1+0.06),BigDecimal.ROUND_HALF_UP,2);
+            }
             insFeeOrder.setSyNoTaxPremium(syNoTaxPremium);
             //商业险总费用
             insFeeOrder.setSyCostsPremiums(getPremium(syNoTaxPremium,insFeeOrder.getSyCostsProportion()));

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

@@ -178,6 +178,21 @@ public class PtlAgreementProductCostsSaveDto implements Serializable {
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private LocalDateTime costsEndDate;
 
+    @ApiModelProperty("司机险保额(最小)")
+    private Integer minDriverAmount;
+
+    @ApiModelProperty("司机险保额(最大)")
+    private Integer maxDriverAmount;
+
+    @ApiModelProperty("乘客险保额(最小)")
+    private Integer minPassengerAmount;
+
+    @ApiModelProperty("乘客险保额(最大)")
+    private Integer maxPassengerAmount;
+
+    @ApiModelProperty("司机乘客关联关系")
+    private String driverPassengerRelation;
+
     public static List<PtlAgreementProductCosts> toPtlAgreementProductCosts(String agreementId, List<PltAgreementSchemeSaveDto> scheme) {
         return scheme.stream().map(x -> PtlAgreementProductCosts.toPtlAgreementProductCostsList(agreementId, x.getProductId(), x.getName(), x.getProductCosts())).flatMap(Collection::stream).collect(Collectors.toList());
     }

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

@@ -369,6 +369,36 @@ public class PtlAgreementProductCosts implements Serializable {
     @TableField(value = "history_time")
     private LocalDateTime historyTime;
 
+    /**
+     * 司机险保额(最小)
+     */
+    @TableField(value = "min_driver_amount")
+    private Integer minDriverAmount;
+
+    /**
+     * 司机险保额(最大)
+     */
+    @TableField(value = "max_driver_amount")
+    private Integer maxDriverAmount;
+
+    /**
+     * 乘客险保额(最小)
+     */
+    @TableField(value = "min_passenger_amount")
+    private Integer minPassengerAmount;
+
+    /**
+     * 乘客险保额(最大)
+     */
+    @TableField(value = "max_passenger_amount")
+    private Integer maxPassengerAmount;
+
+    /**
+     * 司机乘客关联关系
+     */
+    @TableField(value = "driver_passenger_relation")
+    private String driverPassengerRelation;
+
 
     @TableField(exist = false)
     private static final long serialVersionUID = 1L;
@@ -453,6 +483,11 @@ public class PtlAgreementProductCosts implements Serializable {
         result = getObjectHashCode(this.costsStartDate, result);
         result = getObjectHashCode(this.costsEndDate, result);
         result = getObjectHashCode(this.containNoLicense, result);
+        result = getObjectHashCode(this.minDriverAmount, result);
+        result = getObjectHashCode(this.maxDriverAmount, result);
+        result = getObjectHashCode(this.minPassengerAmount, result);
+        result = getObjectHashCode(this.maxPassengerAmount, result);
+        result = getObjectHashCode(this.driverPassengerRelation, result);
         return result;
     }