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

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

import com.ydtech.exception.SystemException;
import com.ydtech.modules.admin.model.SysDept;
import com.ydtech.modules.admin.model.SysUser;
import com.ydtech.modules.admin.service.SysDeptService;
import com.ydtech.modules.admin.service.SysUserService;
import com.ydtech.modules.esm.model.EsmRetail;
import com.ydtech.modules.esm.model.EsmUserReferrer;
import com.ydtech.modules.esm.service.EsmRetailService;
import com.ydtech.modules.esm.service.EsmUserReferrerService;
import com.ydtech.modules.fee.dto.FeeFactorInfoDto;
import com.ydtech.modules.fee.dto.FeeSchemeReqDto;
import com.ydtech.modules.fee.dto.FeeSchemeResDto;
import com.ydtech.modules.fee.service.FeeRuleSchemeService;
import com.ydtech.modules.ins.model.vo.AccidentResponseVo;
import com.ydtech.modules.ins.model.vo.CarInfoVo;
import com.ydtech.modules.ins.model.vo.KindInfoVo;
import com.ydtech.modules.ins.model.vo.QuoteRespVo;
import com.ydtech.modules.order.entity.InsAreaCompany;
import com.ydtech.modules.order.entity.InsCopyFeeOrder;
import com.ydtech.modules.order.entity.InsFeeOrder;
import com.ydtech.modules.order.entity.InsOrders;
import com.ydtech.modules.order.entity.vo.*;
import com.ydtech.modules.order.service.InsAreaCompanyService;
import com.ydtech.modules.order.service.InsCopyFeeOrderService;
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 org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.joda.time.DateTime;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 费用接口中相关功能的实现类
 */
@Service
public class FeeRuleSchemeServiceImpl implements FeeRuleSchemeService {
    @Resource
    private   PtlAgreementProductCostsService ptlAgreementProductCostsService;
    @Resource
    private InsOrdersService insOrdersService;
    @Resource
    private InsFeeOrderService insFeeOrderService;
    @Resource
    private InsCopyFeeOrderService insCopyFeeOrderService;
    @Resource
    private SysUserService sysUserService;
    @Resource
    private SysDeptService sysDeptService;
    @Resource
    private EsmRetailService esmRetailService;
    @Resource
    private EsmUserReferrerService esmUserReferrerService;
    @Resource
    private InsAreaCompanyService insAreaCompanyService;
    @Resource
    private PtlAgreementService ptlAgreementService;
    @Resource
    private PtlNewCarJudgeRulesService ptlNewCarJudgeRulesService;
    @Resource
    private PtlAgreementAttributionService ptlAgreementAttributionService;
    @Resource
    private PtlAgreementUndwrtRulesService ptlAgreementUndwrtRulesService;


    /**
     * 根据跟单信息，以及配置的费用因子，获取合适的跟单费用
     * @param feeSchemeReqDto
     * @return
     */
    public FeeSchemeResDto matchTheAppropriateFees(FeeSchemeReqDto feeSchemeReqDto) {
        FeeSchemeResDto feeSchemeResDto=new FeeSchemeResDto();

        //先根据业务类别、有效期、协议编码、历史标志代码字段 获取对应费用方案列表
        List<PtlAgreementProductCosts> ptlAgreementProductCosts =ptlAgreementProductCostsService.selectVliadFeeFactor(feeSchemeReqDto.getBusType(),feeSchemeReqDto.getAgreementId());
        if (ptlAgreementProductCosts.isEmpty()) {
           //如果查询不到费用方案信息，则阻断算费流程，进行提示
            throw new SystemException("未查询到费用配置，请先配置该协议的费用方案！");
        }else{
            //符合跟单信息的方案列表
            List<PtlAgreementProductCosts> validSchemeList=new ArrayList();
            //循环符合的方案列表，再进行细化的因子匹配，获取最终可以匹配到的方案
            for(int i=0;i<ptlAgreementProductCosts.size();i++){
                PtlAgreementProductCosts factorCost=ptlAgreementProductCosts.get(i);
                //获取处理后的待校验因子
                Map<Integer, FeeFactorInfoDto> factorToBeVerified=getFactorToBeVerified(factorCost);
                //按规则拼接跟单信息
                String matchKeyStr=getMatchKeyWithInsuranceInfo(feeSchemeReqDto);
                //循环进行各项因子校验
                boolean checkFlag=checkFactorValidWithInsuranceInfo(matchKeyStr,factorToBeVerified,factorCost.getProductId());
                //如果该方案所有因子都校验通过，则放入符合校验方案列表
                if(checkFlag){
                    validSchemeList.add(factorCost);
                }
            }

            if(validSchemeList.size()>0){
                //先判断匹配到的是不是只有兜底类型，如果不是则过滤掉兜底类型的费用，优先以跟单的为准，如果只有兜底类型，则按同样逻辑进行筛选
                //根据ProductId去重后的结果集
                List tempList=validSchemeList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(PtlAgreementProductCosts :: getProductId))), ArrayList::new));
                if(tempList.size()>1){//如果有多种类型，则过滤掉兜底类型的
                    validSchemeList=validSchemeList.stream().filter(x -> !"039999".equals(x.getProductId())).collect(Collectors.toList());
                }
                //匹配到唯一一条费用方案，直接用这条
                if(validSchemeList.size()==1){
                    //进行费用比例赋值，给返回对象
                    feeSchemeResDto=generateSchemeResDto((PtlAgreementProductCosts)validSchemeList.get(0));
                }else{
                   /* //如果最终符合的有多条，则按特殊规则选择其中一条 (原来使用保费多少判断优先的停用)
                    PtlAgreementProductCosts finalSchemeCost=changeSchemeWithSpecialRule(validSchemeList,feeSchemeReqDto);*/
                    PtlAgreementProductCosts finalSchemeCost=null;
                    //调整为使用协议方案中优先级字段判断优先方案(循环找出对应优先级最高的)
                    for(int i=0;i<validSchemeList.size();i++){
                        PtlAgreementProductCosts tempCostDto=validSchemeList.get(i);
                        int currentLevel=tempCostDto.getPriorityLevel()==null?0:tempCostDto.getPriorityLevel();
                        if(finalSchemeCost!=null){
                            int oldLevel=finalSchemeCost.getPriorityLevel()==null?0:finalSchemeCost.getPriorityLevel();
                            if(oldLevel>currentLevel){
                                finalSchemeCost=tempCostDto;
                            }
                        }else{
                            finalSchemeCost=tempCostDto;
                        }
                    }
                    //进行费用比例赋值，给返回对象
                    feeSchemeResDto=generateSchemeResDto(finalSchemeCost);
                }
            }else{
                throw new SystemException("未匹配到合适的费用方案，请先配置该协议的费用方案！");
            }
        }
        return feeSchemeResDto;
    }

    /**
     * 特殊处理选择费用方案
     * 如果最终符合的有多条，则先看交强、商业谁的保费多，然后根据保费多得在匹配到的方案中找费用比例大的那一条
     * @param validSchemeList
     * @param feeSchemeReqDto
     * @return
     */
    private PtlAgreementProductCosts changeSchemeWithSpecialRule(List<PtlAgreementProductCosts> validSchemeList, FeeSchemeReqDto feeSchemeReqDto) {
        PtlAgreementProductCosts finalScheme=null;
        //险种标志，最终取哪个险种费用比例   1取交强   2取商业
        String riskFlag="";
        //判断险种标志
        if("0330".equals(feeSchemeReqDto.getBusType())){//单交
            riskFlag="1";
        }else if("034001".equals(feeSchemeReqDto.getBusType())){//单商
            riskFlag="2";
        }else if("034002".equals(feeSchemeReqDto.getBusType())){//单三
            riskFlag="2";
        }else if("0330034002".equals(feeSchemeReqDto.getBusType())){//交三
            if(Double.parseDouble(feeSchemeReqDto.getJqPremium())<=Double.parseDouble(feeSchemeReqDto.getSyPremium())){
                riskFlag="2";
            }else{
                riskFlag="1";
            }
        }else if("0330034001".equals(feeSchemeReqDto.getBusType())){//交商
            if(Double.parseDouble(feeSchemeReqDto.getJqPremium())<=Double.parseDouble(feeSchemeReqDto.getSyPremium())){
                riskFlag="2";
            }else{
                riskFlag="1";
            }
        }
        //循环找出对应比例最大的
        for(int i=0;i<validSchemeList.size();i++){
            PtlAgreementProductCosts tempCostDto=validSchemeList.get(i);
            if(finalScheme!=null){
                if("1".equals(riskFlag)){//按交强比例排序，找比例最大的
                    if(Double.parseDouble(finalScheme.getJqCostsProportion())<Double.parseDouble(tempCostDto.getJqCostsProportion())){
                        finalScheme=tempCostDto;
                    }
                }else if("2".equals(riskFlag)){//按商业比例排序，找比例最大的
                    if(Double.parseDouble(finalScheme.getSyCostsProportion())<Double.parseDouble(tempCostDto.getSyCostsProportion())){
                        finalScheme=tempCostDto;
                    }
                }
            }else{
                finalScheme=tempCostDto;
            }
        }
        return  finalScheme;
    }

    /**
     * 组装费用接口反参对象
     * @param agreementProductCost
     * @return
     */
    private FeeSchemeResDto generateSchemeResDto(PtlAgreementProductCosts agreementProductCost) {
        FeeSchemeResDto resDto=new FeeSchemeResDto();
        resDto.setAgreementId(agreementProductCost.getAgreementId());
        resDto.setSchemeId(agreementProductCost.getId());
        resDto.setJqSpilloverPremiums(agreementProductCost.getJqSpilloverPremiums());
        resDto.setJqSpilloverProportion(agreementProductCost.getJqSpilloverProportion());
        resDto.setJqNewCarCostsProportion(agreementProductCost.getJqNewCarCostsProportion());
        resDto.setJqOldCarCostsProportion(agreementProductCost.getJqOldCarCostsProportion());
        resDto.setJqCostsProportion(agreementProductCost.getJqCostsProportion());
        resDto.setJqNewCarOtherCostsProportion(agreementProductCost.getJqNewCarOtherCostsProportion());
        resDto.setJqOldCarOtherCostsProportion(agreementProductCost.getJqOldCarOtherCostsProportion());
        resDto.setSySpilloverPremiums(agreementProductCost.getSySpilloverPremiums());
        resDto.setSySpilloverProportion(agreementProductCost.getSySpilloverProportion());
        resDto.setSyNewCarCostsProportion(agreementProductCost.getSyNewCarCostsProportion());
        resDto.setSyOldCarCostsProportion(agreementProductCost.getSyOldCarCostsProportion());
        resDto.setSyCostsProportion(agreementProductCost.getSyCostsProportion());
        resDto.setSyNewCarOtherCostsProportion(agreementProductCost.getSyNewCarOtherCostsProportion());
        resDto.setSyOldCarOtherCostsProportion(agreementProductCost.getSyOldCarOtherCostsProportion());
        return resDto;
    }

    /**
     * 根据跟单信息，循环各项因子 校验该方案的匹配情况
     * @param matchKeyStr
     * @param factorToBeVerified
     * @return
     */
    private boolean checkFactorValidWithInsuranceInfo(String matchKeyStr, Map<Integer, FeeFactorInfoDto> factorToBeVerified,String productId) {
        boolean result=false; //默认没有匹配到
        boolean isConfigFactor=false;//是否配置了因子校验项  默认否
        String[] matchKeys= matchKeyStr.split(",");
        //循环待校验因子列表
        for(Map.Entry<Integer,FeeFactorInfoDto> entry : factorToBeVerified.entrySet()){
            Integer key=entry.getKey();
            FeeFactorInfoDto checkFactorInfo=entry.getValue();
            //特殊处理，如果跟单是客车时，不关注配置的核定载质量字段
           if("客车".equals(matchKeys[4])){
                if(checkFactorInfo.getMatchSequence()==8){
                    continue;
                }
           }
            //先看该方案是否需要匹配该因子，不需要则跳过本条因子
            if(!checkFactorInfo.isNeedMatch()){
                continue;
            }else {
                isConfigFactor=true;//不跳过因子时，则有配置的因子项
            }
            //下面处理需要进行匹配的因子
            if("1".equals(checkFactorInfo.getMatchType())){//1.单字符串匹配(相等)
                if(matchKeys[key]!=null&&!"".equals(matchKeys[key])){
                    if(checkFactorInfo.getSingleSelectVal().equals(matchKeys[key])){
                        result=true;
                        continue;
                    }else{
                        //如果需要匹配且没有匹配到，则直接跳出本次循环，该方案不符合
                        result=false;
                        break;
                    }
                }else{
                    //判断跟单信息是否为空,如果为空，则直接没有匹配到,该方案不符合
                    result=false;
                    break;
                }
            }else if("2".equals(checkFactorInfo.getMatchType())){//2.多字符串匹配(包含)
                //如果匹配的是业务类型，需要全字符匹配
                //业务类型：单交0330、单商034001、单三034002、交三0330034002、交商0330034001
                //034002,0330
                if("业务类型".equals(checkFactorInfo.getFactorName())){
                    if(matchKeys[key]!=null&&!"".equals(matchKeys[key])){
                        //如果需要匹配，且匹配成功，则跳过本次循环，继续校验下一因子
                        if(checkFactorInfo.getMultipleSelectVal().indexOf(matchKeys[key]+",")>-1){
                            result=true;
                            continue;
                        }else{
                            //如果需要匹配且没有匹配到，则直接跳出循环，该方案不符合
                            result=false;
                            break;
                        }
                    }else{
                        //判断跟单信息是否为空,如果为空，则直接没有匹配到,该方案不符合
                        result=false;
                        break;
                    }
                }else{
                    if(matchKeys[key]!=null&&!"".equals(matchKeys[key])){
                        //如果需要匹配，且匹配成功，则跳过本次循环，继续校验下一因子
                        if(checkFactorInfo.getMultipleSelectVal().indexOf(matchKeys[key])>-1){
                            result=true;
                            continue;
                        }else{
                            //如果需要匹配且没有匹配到，则直接跳出循环，该方案不符合
                            result=false;
                            break;
                        }
                    }else{
                        //判断跟单信息是否为空,如果为空，则直接没有匹配到,该方案不符合
                        result=false;
                        break;
                    }
                }
            }else if("3".equals(checkFactorInfo.getMatchType())){//3.区间范围比较(左闭右闭)
                if(matchKeys[key]!=null&&NumberUtils.isCreatable(matchKeys[key])){
                    //如果需要匹配，且匹配成功，则跳过本次循环，继续校验下一因子
                    if(Double.parseDouble(matchKeys[key])>=checkFactorInfo.getMinRangeVal()&&Double.parseDouble(matchKeys[key])<=checkFactorInfo.getMaxRangeVal()){
                        result=true;
                        continue;
                    }else{
                        //如果需要匹配且没有匹配到，则直接跳出循环，该方案不符合
                        result=false;
                        break;
                    }
                }else{
                    //判断跟单信息是否为空和可转整型,如果不符，则直接没有匹配到,该方案不符合
                    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;
                        }
                    }
                }
            }else if("5".equals(checkFactorInfo.getMatchType())) {//5.特殊规则，医保外用校验，存在互斥关系需要单独判断
                if(matchKeys[key]!=null){
                    //先获取跟单医保外用保额  三者-司机-乘客
                    String[] kindAmountStr= matchKeys[key].split("-");
                    String thirdMedicalAmount="NULL".equals(kindAmountStr[0])?"0":kindAmountStr[0];
                    String driverMedicalAmount="NULL".equals(kindAmountStr[1])?"0":kindAmountStr[1];
                    String passengerMedicalAmount="NULL".equals(kindAmountStr[2])?"0":kindAmountStr[2];

                    if(checkFactorInfo.getAnyMedicalAmountVal()!=null){//不为空时，为任意险别符合即可  三者 司机  乘客 三者为 或的关系
                        boolean isThirdPass=false;
                        boolean isDriverPass=false;
                        boolean isPassengerPass=false;
                        if(NumberUtils.isCreatable(thirdMedicalAmount)){//如果医保外用三者保额是数字，则可以进行校验
                            if(Double.parseDouble(thirdMedicalAmount)>=checkFactorInfo.getAnyMedicalAmountVal()){
                                isThirdPass=true;
                            }
                        }
                        if(NumberUtils.isCreatable(driverMedicalAmount)){//如果医保外用保额是数字，则可以进行校验
                            if(Double.parseDouble(driverMedicalAmount)>=checkFactorInfo.getAnyMedicalAmountVal()){
                                isDriverPass=true;
                            }
                        }
                        if(NumberUtils.isCreatable(passengerMedicalAmount)){//如果医保外用乘客保额是数字，则可以进行校验
                            if(Double.parseDouble(passengerMedicalAmount)>=checkFactorInfo.getAnyMedicalAmountVal()){
                                isPassengerPass=true;
                            }
                        }
                        if(!isThirdPass&&!isDriverPass&&!isPassengerPass){//三项都不通过的时候，才不符合
                            result=false;
                            break;
                        }else{
                            result=true;
                            continue;
                        }

                    }else {//看指定险别的判断  三者 司机  乘客 三者为 且的关系
                        boolean isThirdPass=false;
                        boolean isDriverPass=false;
                        boolean isPassengerPass=false;
                        if(NumberUtils.isCreatable(thirdMedicalAmount)){//如果医保外用三者保额是数字，则可以进行校验
                            if(checkFactorInfo.getThirdMedicalAmountVal()!=null){
                                if(Double.parseDouble(thirdMedicalAmount)>=checkFactorInfo.getThirdMedicalAmountVal()){
                                    isThirdPass=true;
                                }
                            }else{
                                isThirdPass=true;
                            }
                        }
                        if(NumberUtils.isCreatable(driverMedicalAmount)){//如果医保外用保额是数字，则可以进行校验
                            if(checkFactorInfo.getDriverMedicalAmountVal()!=null){
                                if(Double.parseDouble(driverMedicalAmount)>=checkFactorInfo.getDriverMedicalAmountVal()){
                                    isDriverPass=true;
                                }
                            }else{
                                isDriverPass=true;
                            }

                        }
                        if(NumberUtils.isCreatable(passengerMedicalAmount)){//如果医保外用乘客保额是数字，则可以进行校验
                            if(checkFactorInfo.getPassengerMedicalAmountVal()!=null){
                                if(Double.parseDouble(passengerMedicalAmount)>=checkFactorInfo.getPassengerMedicalAmountVal()){
                                    isPassengerPass=true;
                                }
                            }else{
                                isPassengerPass=true;
                            }
                        }

                        if(isThirdPass&&isDriverPass&&isPassengerPass){//三项都通过的时候，才符合
                            result=true;
                            continue;
                        }else{
                            result=false;
                            break;
                        }
                    }
                }
            }
        }

        if(productId!=null&&"039999".equals(productId)){
            if(!isConfigFactor){//如果是兜底配置  且 没有配置因子项时，则认为匹配到
                result=true;
            }
        }

        return result;
    }

    /**
     * 根据跟单信息，按照约定顺序进行拼接匹配串
     * 新增因子时，顺序需要与getFactorToBeVerified()方法放入待校验因子一致
     * @param feeSchemeReqDto
     * @return
     */
    private String getMatchKeyWithInsuranceInfo(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");
        return result.toString();
    }

    /**
     * 根据配置的因子表数据，组装标准的待校验因子列表
     * 新增因子时，顺序需要与getMatchKeyWithInsuranceInfo()方法放入跟单信息一致
     * @param factorCost
     * @return
     */
    private Map<Integer, FeeFactorInfoDto> getFactorToBeVerified(PtlAgreementProductCosts factorCost) {
        Map<Integer, FeeFactorInfoDto> resultMqp=new HashMap<>();
        //以下各项因子必须按顺序放入MAP，以便校验时关联
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor0=new FeeFactorInfoDto();
        factor0.setFactorName("是否过户");
        factor0.setMatchType("1");
        factor0.setMatchSequence(0);
        if(factorCost.getTransfer()!=null&&factorCost.getTransfer()!=9){
            factor0.setNeedMatch(true);
            factor0.setSingleSelectVal(String.valueOf(factorCost.getTransfer()));
        }else{
            //如果方案中未录入(是空或为9时)，则不校验该项因子
            factor0.setNeedMatch(false);
        }
        resultMqp.put(0,factor0);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor1=new FeeFactorInfoDto();
        factor1.setFactorName("新旧车");
        factor1.setMatchType("1");
        factor1.setMatchSequence(1);
        if(factorCost.getOldAndNew()!=null&&factorCost.getOldAndNew()!=9){
            factor1.setNeedMatch(true);
            factor1.setSingleSelectVal(String.valueOf(factorCost.getOldAndNew()));
        }else{
            //如果方案中未录入(是空或为9时)，则不校验该项因子
            factor1.setNeedMatch(false);
        }
        resultMqp.put(1,factor1);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor2=new FeeFactorInfoDto();
        factor2.setFactorName("是否新能源");
        factor2.setMatchType("1");
        factor2.setMatchSequence(2);
        if(factorCost.getNewEnergy()!=null&&factorCost.getNewEnergy()!=9){
            factor2.setNeedMatch(true);
            factor2.setSingleSelectVal(String.valueOf(factorCost.getNewEnergy()));
        }else{
            //如果方案中未录入(是空或为9时)，则不校验该项因子
            factor2.setNeedMatch(false);
        }
        resultMqp.put(2,factor2);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor3=new FeeFactorInfoDto();
        factor3.setFactorName("是否续保");
        factor3.setMatchType("1");
        factor3.setMatchSequence(3);
        if(factorCost.getRenewal()!=null&&factorCost.getRenewal()!=9){
            factor3.setNeedMatch(true);
            factor3.setSingleSelectVal(String.valueOf(factorCost.getRenewal()));
        }else{
            //如果方案中未录入(是空或为9时)，则不校验该项因子
            factor3.setNeedMatch(false);
        }
        resultMqp.put(3,factor3);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor4=new FeeFactorInfoDto();
        factor4.setFactorName("车辆大类");
        factor4.setMatchType("2");
        factor4.setMatchSequence(4);
        if(factorCost.getVehicleCategory()!=null&&!"".equals(factorCost.getVehicleCategory())){
            factor4.setNeedMatch(true);
            factor4.setMultipleSelectVal(String.valueOf(factorCost.getVehicleCategory()));
        }else{
            //如果方案中未录入，则不校验该项因子
            factor4.setNeedMatch(false);
        }
        resultMqp.put(4,factor4);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor5=new FeeFactorInfoDto();
        factor5.setFactorName("使用性质");
        factor5.setMatchType("2");
        factor5.setMatchSequence(5);
        if(factorCost.getNatureOfUse()!=null&&!"".equals(factorCost.getNatureOfUse())){
            factor5.setNeedMatch(true);
            factor5.setMultipleSelectVal(String.valueOf(factorCost.getNatureOfUse()));
        }else{
            //如果方案中未录入，则不校验该项因子
            factor5.setNeedMatch(false);
        }
        resultMqp.put(5,factor5);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor6=new FeeFactorInfoDto();
        factor6.setFactorName("客车座位数区间");
        factor6.setMatchType("3");
        factor6.setMatchSequence(6);
        if(checkFactorConfigWithArea(factorCost.getMinSeats(),factorCost.getMaxSeats(),factor6,factorCost)){
            factor6.setNeedMatch(true);
            factor6.setMinRangeVal((double)factorCost.getMinSeats());
            factor6.setMaxRangeVal((double)factorCost.getMaxSeats());
        }else{
            //如果方案中未录入，则不校验该项因子
            factor6.setNeedMatch(false);
        }
        resultMqp.put(6,factor6);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor7=new FeeFactorInfoDto();
        factor7.setFactorName("新车购置价区间");
        factor7.setMatchType("3");
        factor7.setMatchSequence(7);
        if(checkFactorConfigWithArea(factorCost.getMinPurchasePrice(),factorCost.getMaxPurchasePrice(),factor7,factorCost)){
            factor7.setNeedMatch(true);
            factor7.setMinRangeVal((double)factorCost.getMinPurchasePrice());
            factor7.setMaxRangeVal((double)factorCost.getMaxPurchasePrice());
        }else{
            //如果方案中未录入，则不校验该项因子
            factor7.setNeedMatch(false);
        }
        resultMqp.put(7,factor7);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor8=new FeeFactorInfoDto();
        factor8.setFactorName("核定载质量区间");
        factor8.setMatchType("3");
        factor8.setMatchSequence(8);
        if(checkFactorConfigWithArea(factorCost.getMinApprovedLoadCapacity(),factorCost.getMaxApprovedLoadCapacity(),factor8,factorCost)){
            factor8.setNeedMatch(true);
            factor8.setMinRangeVal((double)factorCost.getMinApprovedLoadCapacity());
            factor8.setMaxRangeVal((double)factorCost.getMaxApprovedLoadCapacity());
        }else{
            //如果方案中未录入，则不校验该项因子
            factor8.setNeedMatch(false);
        }
        resultMqp.put(8,factor8);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor9=new FeeFactorInfoDto();
        factor9.setFactorName("交强险保费区间");
        factor9.setMatchType("3");
        factor9.setMatchSequence(9);
        if(checkFactorConfigWithArea(factorCost.getMinCompulsoryInsurancePremium(),factorCost.getMaxCompulsoryInsurancePremium(),factor9,factorCost)){
            factor9.setNeedMatch(true);
            factor9.setMinRangeVal((double)factorCost.getMinCompulsoryInsurancePremium());
            factor9.setMaxRangeVal((double)factorCost.getMaxCompulsoryInsurancePremium());
        }else{
            //如果方案中未录入，则不校验该项因子
            factor9.setNeedMatch(false);
        }
        resultMqp.put(9,factor9);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor10=new FeeFactorInfoDto();
        factor10.setFactorName("车船税金额区间");
        factor10.setMatchType("3");
        factor10.setMatchSequence(10);
        if(checkFactorConfigWithArea(factorCost.getMinTaxAmount(),factorCost.getMaxTaxAmount(),factor10,factorCost)){
            factor10.setNeedMatch(true);
            factor10.setMinRangeVal((double)factorCost.getMinTaxAmount());
            factor10.setMaxRangeVal((double)factorCost.getMaxTaxAmount());
        }else{
            //如果方案中未录入，则不校验该项因子
            factor10.setNeedMatch(false);
        }
        resultMqp.put(10,factor10);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor11=new FeeFactorInfoDto();
        factor11.setFactorName("三者保额区间");
        factor11.setMatchType("3");
        factor11.setMatchSequence(11);
        if(checkFactorConfigWithArea(factorCost.getMinTheThreePremium(),factorCost.getMaxTheThreePremium(),factor11,factorCost)){
            factor11.setNeedMatch(true);
            factor11.setMinRangeVal((double)factorCost.getMinTheThreePremium()*10000);
            factor11.setMaxRangeVal((double)factorCost.getMaxTheThreePremium()*10000);
        }else{
            //如果方案中未录入，则不校验该项因子
            factor11.setNeedMatch(false);
        }
        resultMqp.put(11,factor11);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor12=new FeeFactorInfoDto();
        factor12.setFactorName("随车产品保费区间");
        factor12.setMatchType("3");
        factor12.setMatchSequence(12);
        if(checkFactorConfigWithArea(factorCost.getMinOnboardProductsPremium(),factorCost.getMaxOnboardProductsPremium(),factor12,factorCost)){
            factor12.setNeedMatch(true);
            factor12.setMinRangeVal((double)factorCost.getMinOnboardProductsPremium());
            factor12.setMaxRangeVal((double)factorCost.getMaxOnboardProductsPremium());
        }else{
            //如果方案中未录入，则不校验该项因子
            factor12.setNeedMatch(false);
        }
        resultMqp.put(12,factor12);

        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor13=new FeeFactorInfoDto();
        factor13.setFactorName("商业险折扣区间");
        factor13.setMatchType("3");
        factor13.setMatchSequence(13);
        if(checkFactorConfigWithArea(factorCost.getMinCommercialInsuranceDiscount(),factorCost.getMaxCommercialInsuranceDiscount(),factor13,factorCost)){
            factor13.setNeedMatch(true);
            factor13.setMinRangeVal((double)factorCost.getMinCommercialInsuranceDiscount());
            factor13.setMaxRangeVal((double)factorCost.getMaxCommercialInsuranceDiscount());
        }else{
            //如果方案中未录入，则不校验该项因子
            factor13.setNeedMatch(false);
        }
        resultMqp.put(13,factor13);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor14=new FeeFactorInfoDto();
        factor14.setFactorName("交强险折扣区间");
        factor14.setMatchType("3");
        factor14.setMatchSequence(14);
        if(checkFactorConfigWithArea(factorCost.getMinCompulsoryInsuranceDiscount(),factorCost.getMaxCompulsoryInsuranceDiscount(),factor14,factorCost)){
            factor14.setNeedMatch(true);
            factor14.setMinRangeVal(factorCost.getMinCompulsoryInsuranceDiscount());
            factor14.setMaxRangeVal(factorCost.getMaxCompulsoryInsuranceDiscount());
        }else{
            //如果方案中未录入，则不校验该项因子
            factor14.setNeedMatch(false);
        }
        resultMqp.put(14,factor14);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor15=new FeeFactorInfoDto();
        factor15.setFactorName("保司评分区间");
        factor15.setMatchType("3");
        factor15.setMatchSequence(15);
        if(checkFactorConfigWithArea(factorCost.getMinScore(),factorCost.getMaxScore(),factor15,factorCost)){
            factor15.setNeedMatch(true);
            factor15.setMinRangeVal((double)factorCost.getMinScore());
            factor15.setMaxRangeVal((double)factorCost.getMaxScore());
        }else{
            //如果方案中未录入，则不校验该项因子
            factor15.setNeedMatch(false);
        }
        resultMqp.put(15,factor15);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor16=new FeeFactorInfoDto();
        factor16.setFactorName("预期赔付率区间");
        factor16.setMatchType("3");
        factor16.setMatchSequence(16);
        if(checkFactorConfigWithArea(factorCost.getMinLossRation(),factorCost.getMaxLossRation(),factor16,factorCost)){
            factor16.setNeedMatch(true);
            factor16.setMinRangeVal((double)factorCost.getMinLossRation());
            factor16.setMaxRangeVal((double)factorCost.getMaxLossRation());
        }else{
            //如果方案中未录入，则不校验该项因子
            factor16.setNeedMatch(false);
        }
        resultMqp.put(16,factor16);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor17=new FeeFactorInfoDto();
        factor17.setFactorName("车牌号地区");
        factor17.setMatchType("2");
        factor17.setMatchSequence(17);
        if(factorCost.getLicenseNumber()!=null&&!"".equals(factorCost.getLicenseNumber())){
            factor17.setNeedMatch(true);
            String matchStr=factorCost.getLicenseNumber();
            //考虑是否含暂未上牌标志
            if(factorCost.getContainNoLicense()!=null&&"1".equals(factorCost.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(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);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor19=new FeeFactorInfoDto();
        factor19.setFactorName("被保人年龄");
        factor19.setMatchType("3");
        factor19.setMatchSequence(19);
        if(checkFactorConfigWithArea(factorCost.getMinInsureAge(),factorCost.getMaxInsureAge(),factor19,factorCost)){
            factor19.setNeedMatch(true);
            factor19.setMinRangeVal((double)factorCost.getMinInsureAge());
            factor19.setMaxRangeVal((double)factorCost.getMaxInsureAge());
        }else{
            //如果方案中未录入，则不校验该项因子
            factor19.setNeedMatch(false);
        }
        resultMqp.put(19,factor19);
        //--------------------因子处理分割线----------------------------------
        FeeFactorInfoDto factor20=new FeeFactorInfoDto();
        factor20.setFactorName("车主年龄");
        factor20.setMatchType("3");
        factor20.setMatchSequence(20);
        if(checkFactorConfigWithArea(factorCost.getMinCarOwnerAge(),factorCost.getMaxCarOwnerAge(),factor20,factorCost)){
            factor20.setNeedMatch(true);
            factor20.setMinRangeVal((double)factorCost.getMinCarOwnerAge());
            factor20.setMaxRangeVal((double)factorCost.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(factorCost.getThirdMedicalAmount()!=null&&factorCost.getThirdMedicalAmount()!=0){
            factor21.setThirdMedicalAmountVal(factorCost.getThirdMedicalAmount()*10000);
        }else{
            factor21.setThirdMedicalAmountVal(null);
            thirdMCheckFlag=false;
        }
        //司机
        if(factorCost.getDriverMedicalAmount()!=null&&factorCost.getDriverMedicalAmount()!=0){
            factor21.setDriverMedicalAmountVal(factorCost.getDriverMedicalAmount()*10000);
        }else{
            factor21.setDriverMedicalAmountVal(null);
            driverMCheckFlag=false;
        }
        //乘客
        if(factorCost.getPassengerMedicalAmount()!=null&&factorCost.getPassengerMedicalAmount()!=0){
            factor21.setPassengerMedicalAmountVal(factorCost.getPassengerMedicalAmount()*10000);
        }else{
            factor21.setPassengerMedicalAmountVal(null);
            passengerMCheckFlag=false;
        }
        //任意
        if(factorCost.getAnyMedicalAmount()!=null&&factorCost.getAnyMedicalAmount()!=0){
            factor21.setAnyMedicalAmountVal(factorCost.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);
        //--------------------因子处理分割线----------------------------------
        return resultMqp;
    }

    /**
     * 判断区间类因子是否需要匹配
     * @param minVal
     * @param maxVal
     * @param factorInfoDto
     * @param productCosts
     * @return
     */
    private boolean checkFactorConfigWithArea(Integer minVal, Integer maxVal,FeeFactorInfoDto factorInfoDto,PtlAgreementProductCosts productCosts) {
        boolean result=false; //默认不需要匹配
        if(minVal!=null&&maxVal!=null){
            if(minVal==0&&maxVal==0){//初始化没有配置的时候，全部默认的0,这种不需要匹配
                result=false;
            }else{
                if(minVal<=maxVal){
                    result=true;
                }else{
                    throw new SystemException("协议ID:"+productCosts.getAgreementId()+" 方案序号:"+productCosts.getId()+" 费用因子:"+factorInfoDto.getFactorName()+"配置有问题，请检查!");
                }
            }
        }else if(minVal!=null && maxVal==null){
            throw new SystemException("协议ID:"+productCosts.getAgreementId()+" 方案序号:"+productCosts.getId()+" 费用因子:"+factorInfoDto.getFactorName()+"配置有问题，请检查!");
        }else if(minVal==null&&maxVal!=null){
            throw new SystemException("协议ID:"+productCosts.getAgreementId()+" 方案序号:"+productCosts.getId()+" 费用因子:"+factorInfoDto.getFactorName()+"配置有问题，请检查!");
        }
        return result;
    }

    /**
     * 判断区间类因子是否需要匹配
     * @param minVal
     * @param maxVal
     * @param factorInfoDto
     * @param productCosts
     * @return
     */
    private boolean checkFactorConfigWithArea(Double minVal, Double maxVal,FeeFactorInfoDto factorInfoDto,PtlAgreementProductCosts productCosts) {
        boolean result=false; //默认不需要匹配
        if(minVal!=null&&maxVal!=null){
            if(minVal==0&&maxVal==0){//初始化没有配置的时候，全部默认的0,这种不需要匹配
                result=false;
            }else{
                if(minVal<=maxVal){
                    result=true;
                }else{
                    throw new SystemException("协议ID:"+productCosts.getAgreementId()+" 方案序号:"+productCosts.getId()+" 费用因子:"+factorInfoDto.getFactorName()+"配置有问题，请检查!");
                }
            }
        }else if(minVal!=null && maxVal==null){
            throw new SystemException("协议ID:"+productCosts.getAgreementId()+" 方案序号:"+productCosts.getId()+" 费用因子:"+factorInfoDto.getFactorName()+"配置有问题，请检查!");
        }else if(minVal==null&&maxVal!=null){
            throw new SystemException("协议ID:"+productCosts.getAgreementId()+" 方案序号:"+productCosts.getId()+" 费用因子:"+factorInfoDto.getFactorName()+"配置有问题，请检查!");
        }
        return result;
    }



    //----------------------------------------------分割线

    public FeeSchemeReqDto getFeeSchemeInfo(BaseQuoteInfoVo quoteInfoVo, QuoteRespVo quoteRespVo, String agreementId, String productId){
        PtlAgreementAttribution ptlAgreementAttribution = ptlAgreementAttributionService.getById(agreementId);
        CarInfoVo carInfoVo = quoteInfoVo.getCarInfo();
        List<KindInfoVo> kindList = quoteInfoVo.getKindList();
        String thirdPartyInsurance = "";
        String driverAmount="";
        String passengerAmount="";
        String thirdMedicalAmount="";
        String driverMedicalAmount="";
        String passengerMedicalAmount="";
        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);
                }
                //三者医保外用
                if("SY_FJ_YBW1".equals(kindInfoVo.getKindCode())){
                    thirdMedicalAmount = String.valueOf(kindInfoVo.getAmount());
                }
                //司机医保外用
                if("SY_FJ_YBW3".equals(kindInfoVo.getKindCode())){
                    driverMedicalAmount = String.valueOf(kindInfoVo.getAmount());
                }
                //乘客医保外用
                if("SY_FJ_YBW2".equals(kindInfoVo.getKindCode())){
                    int quantity = Integer.parseInt(carInfoVo.getSeatCount())-1;
                    passengerMedicalAmount = String.valueOf(kindInfoVo.getUnitAmount()*quantity);
                }
            }
        }
        FeeSchemeReqDto feeSchemeReqDto = new FeeSchemeReqDto();
        String isTransfer = "0";
        String isNewCar = "0";
        String isRenewal = "0";
        String useNature = "家庭自用";
        String carType="客车";
        String isNewEnergy = "0";
        feeSchemeReqDto.setBusType(productId);//"业务类型：单交0330、单商034001、单三034002、交三0330034002、交商0330034001"
        feeSchemeReqDto.setAgreementId(agreementId);//协议ID
        if(carInfoVo.isTransferFlag()){
            isTransfer = "1";
        }
        feeSchemeReqDto.setIsTransfer(isTransfer);//是否过户    1是  0否"

        //新旧车判断逻辑，初登日期小于起保日期加9个月
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate currentDate = LocalDate.now();
        //有交强日期时取交强，没有交强时取商业
        if(StringUtils.isNotEmpty(quoteRespVo.getStartDateJq())){
            try {
                SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
                Date startDate=sdf.parse(quoteRespVo.getStartDateJq());
                String jqStartDate = sdf.format(startDate);
                currentDate=LocalDate.parse(jqStartDate, formatter);
            }catch (Exception e){

            }
        }else if(StringUtils.isNotEmpty(quoteRespVo.getStartDateSy())){
            try {
                SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
                Date startDate=sdf.parse(quoteRespVo.getStartDateSy());
                String jqStartDate = sdf.format(startDate);
                currentDate=LocalDate.parse(jqStartDate, formatter);
            }catch (Exception e){

            }
        }
        if(StringUtils.isNotEmpty(carInfoVo.getRegisterDate())){
            LocalDate registerDate = LocalDate.parse(carInfoVo.getRegisterDate(), formatter).plusMonths(9);
            if(currentDate.isBefore(registerDate)){
                isNewCar = "1";
            }
        }
        List<PtlNewCarJudgeRules> ptlNewCarJudgeRulesList = ptlNewCarJudgeRulesService.getByCompanyId(ptlAgreementAttribution.getInsCompanyId());
        if(ptlNewCarJudgeRulesList!=null &&ptlNewCarJudgeRulesList.size()>0){
            PtlNewCarJudgeRules ptlNewCarJudgeRules = ptlNewCarJudgeRulesList.get(0);
            if("月".equals(ptlNewCarJudgeRules.getUnitTypeCode())){
                LocalDate registerDate = LocalDate.parse(carInfoVo.getRegisterDate(), formatter).plusMonths(Integer.parseInt(ptlNewCarJudgeRules.getUnitTypeValue()));
                if(currentDate.isBefore(registerDate)){
                    isNewCar = "1";
                }
            }else{
                LocalDate registerDate = LocalDate.parse(carInfoVo.getRegisterDate(), formatter).plusDays(Integer.parseInt(ptlNewCarJudgeRules.getUnitTypeValue()));
                if(currentDate.isBefore(registerDate)){
                    isNewCar = "1";
                }
            }
        }
        feeSchemeReqDto.setIsNewCar(isNewCar);//是否新车    1是  0否
        if("1".equals(carInfoVo.getPowertype())||"2".equals(carInfoVo.getPowertype())||"3".equals(carInfoVo.getPowertype())){
            isNewEnergy = "1";
        }
        feeSchemeReqDto.setIsNewEnergy(isNewEnergy);//是否新能源    1是  0否
        feeSchemeReqDto.setIsRenewal("0");//是否续保    1是  0否    续保取值有争议 默认送否 暂时搁置
        //页面要素及中煤交互请求返参没有，先默认写死
        if("A0".equals(carInfoVo.getCimodelclass())){
            carType="客车";
        }
        feeSchemeReqDto.setVehicleCategory(carType);//车辆大类： 客车、货车、特种车、挂车、摩托车、拖拉机
        if("8A".equals(carInfoVo.getCarnature())){
            useNature = "家庭自用";
        }
        feeSchemeReqDto.setUseNature(useNature);//使用性质： 营业出租、营业租赁、营业公交、营业客运、营业货运、营业旅游、家庭自用、非营业机关事业、非营业企业、非营业个人
        feeSchemeReqDto.setSeatNum(String.valueOf(carInfoVo.getSeatCount()));//座位数 大概率准
        feeSchemeReqDto.setPurchasePrice(carInfoVo.getPurchasePrice());//新车购置价  可能再次新车筛选的时候送保司和页面带入有差异
        feeSchemeReqDto.setApprovedLoadCapacity(String.valueOf(carInfoVo.getLimitLoad()));//核定载质量  可能再次新车筛选的时候送保司和页面带入有差异
        feeSchemeReqDto.setJqPremium(String.valueOf(quoteRespVo.getJqPremium()));//交强保费
        feeSchemeReqDto.setSyPremium(String.valueOf(quoteRespVo.getSyPremium()));//商业保费
        feeSchemeReqDto.setSumPayTax(String.valueOf(quoteRespVo.getTaxAmount()));//车船税金额
        feeSchemeReqDto.setThirdPartyInsurance(thirdPartyInsurance);//三者险保额  准
        feeSchemeReqDto.setNoCarPremium(String.valueOf(quoteRespVo.getJyPremium()));//随车产品保费
        feeSchemeReqDto.setSyDiscount(quoteRespVo.getSyAdjustRate());//商业险折扣
        feeSchemeReqDto.setJqDiscount(quoteRespVo.getJqAdjustRate());//交强险折扣
        feeSchemeReqDto.setInsuranceScore(quoteRespVo.getILogPreUdwMess());//保司评分
        feeSchemeReqDto.setExpectedLossRate(String.valueOf(quoteRespVo.getLossRation()));//预期赔付率
        if(carInfoVo.getLicenseNo()!=null&&!"".equals(carInfoVo.getLicenseNo())&&!"暂未上牌".equals(carInfoVo.getLicenseNo())){
            feeSchemeReqDto.setLicenseNo(carInfoVo.getLicenseNo().substring(0,2));//车牌号
        }else{
            feeSchemeReqDto.setLicenseNo("暂未上牌");//车牌号
        }

        feeSchemeReqDto.setDriverAmount(driverAmount);//人员司机险保额  准
        feeSchemeReqDto.setPassengerAmount(passengerAmount);//人员乘客险保额  准
        feeSchemeReqDto.setThirdMedicalAmount(thirdMedicalAmount);//三者医保外用  准
        feeSchemeReqDto.setDriverMedicalAmount(driverMedicalAmount);//司机医保外用 准
        feeSchemeReqDto.setPassengerMedicalAmount(passengerMedicalAmount);//乘客医保外用  准
        feeSchemeReqDto.setInsureAge(quoteInfoVo.getInsuredPersonInfo().getAge());//被保人年龄
        feeSchemeReqDto.setCarOwnerAge(quoteInfoVo.getOwnerInfo().getAge());//车主年龄
        return feeSchemeReqDto;
    }

    public void dealFeeOrderInfo(BaseQuoteInfoVo quoteInfoVo, QuoteRespVo quoteRespVo, String agreementId,String businessNo){
        BigDecimal jqNoTaxPremium = new BigDecimal(0);
        BigDecimal syNoTaxPremium = new BigDecimal(0);
        InsOrders insOrders = insOrdersService.getById(quoteRespVo.getOrderno());
        List<AccidentResponseVo> accidentList = quoteRespVo.getAccident();
        /*BigDecimal accidentActualPremium = new BigDecimal(0);
        for(AccidentResponseVo accidentResponseVo: accidentList){
            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);
        //先通过含税保费计算出不含税保费 公式 总保费/(1+增值税率) 目前增值税率是0.06
        if(insFeeOrder.getJqPremium().doubleValue()>0){
            //默认用含税保费计算
            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()));
            //监管费比例
            if("1".equals(feeSchemeReqDto.getIsNewCar())){
                insFeeOrder.setJqSuperviseCostsProportion(new BigDecimal(feeSchemeResDto.getJqNewCarCostsProportion()));
            }else if("0".equals(feeSchemeReqDto.getIsNewCar())){
                insFeeOrder.setJqSuperviseCostsProportion(new BigDecimal(feeSchemeResDto.getJqOldCarCostsProportion()));
            }else{
                insFeeOrder.setJqSuperviseCostsProportion(new BigDecimal(0));
            }
            //监管费
            insFeeOrder.setJqSuperviseCostsPremiums(getPremium(jqNoTaxPremium,insFeeOrder.getJqSuperviseCostsProportion()));
            //溢出费比例 先搁置放0
            insFeeOrder.setJqSpilloverProportion(new BigDecimal(feeSchemeResDto.getJqSpilloverProportion()));
            //溢出费 先搁置放0
            insFeeOrder.setJqSpilloverPremiums(getPremium(jqNoTaxPremium,insFeeOrder.getJqSpilloverProportion()));
        }
        if(insFeeOrder.getSyPremium().doubleValue()>0){
            //默认用含税保费计算
            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()));
            //监管费比例
            if("1".equals(feeSchemeReqDto.getIsNewCar())){
                insFeeOrder.setSySuperviseCostsProportion(new BigDecimal(feeSchemeResDto.getSyNewCarCostsProportion()));
            }else if("0".equals(feeSchemeReqDto.getIsNewCar())){
                insFeeOrder.setSySuperviseCostsProportion(new BigDecimal(feeSchemeResDto.getSyOldCarCostsProportion()));
            }else{
                insFeeOrder.setSySuperviseCostsProportion(new BigDecimal(0));
            }
            //监管费
            insFeeOrder.setSySuperviseCostsPremiums(getPremium(syNoTaxPremium,insFeeOrder.getSySuperviseCostsProportion()));
            //溢出费比例 先搁置放0
            insFeeOrder.setSySpilloverProportion(new BigDecimal(feeSchemeResDto.getSySpilloverProportion()));
            //溢出费 先搁置放0
            insFeeOrder.setSySpilloverPremiums(getPremium(syNoTaxPremium,insFeeOrder.getSySpilloverProportion()));
        }

        if(jqNoTaxPremium.doubleValue() >0 || syNoTaxPremium.doubleValue() >0){
            BigDecimal totalNoTaxPremium = jqNoTaxPremium.add(syNoTaxPremium);
            SysUser sysUser = sysUserService.findByUserId(insOrders.getUserid());
            /**
             * 机构管理费比例逻辑
             * 当前出单员的机构编码找他的上一级就是五级
             * 机构层级划分方式
             * 99 总公司              一级
             * 9914山西分公司         二级
             * 991401太原中支         三级
             * 99140105小店中支       四级
             * 9914010501 营销服务部  五级
             *            1团队       无机构层级
             */

            //判断出单员归属机构层级
            String parentId = sysUser.getDeptId();
            String comlevel = "";
            do{//循环操作
                SysDept sysDeptTemp = sysDeptService.getById(parentId);
                if(sysDeptTemp!=null&&StringUtils.isNotEmpty(sysDeptTemp.getParentId())){
                    parentId = sysDeptTemp.getParentId();
                }else{
                    break;
                }
                if(StringUtils.isEmpty(sysDeptTemp.getComlevel())){
                    continue;
                }else {
                    comlevel = sysDeptTemp.getComlevel();
                }
                //当机构层级为五级的时候，获取所有的机构费用比例
                if(sysDeptTemp!=null && "5".equals(sysDeptTemp.getComlevel())){
                    //五级机构管理费用比例
                    insFeeOrder.setFifthDeptProportion(new BigDecimal(sysDeptTemp.getManagementFeeFifth()));
                    insFeeOrder.setFifthDeptPremiums(getPremium(totalNoTaxPremium,insFeeOrder.getFifthDeptProportion()));
                    //四级机构管理费用比例
                    insFeeOrder.setForthDeptProportion(new BigDecimal(sysDeptTemp.getManagementFeeForth()));
                    insFeeOrder.setForthDeptPremiums(getPremium(totalNoTaxPremium,insFeeOrder.getForthDeptProportion()));
                    //三级机构管理费用比例
                    insFeeOrder.setThirdDeptProportion(new BigDecimal(sysDeptTemp.getManagementFeeThird()));
                    insFeeOrder.setThirdDeptPremiums(getPremium(totalNoTaxPremium,insFeeOrder.getThirdDeptProportion()));
                    //二级机构管理费用比例
                    insFeeOrder.setSecondDeptProportion(new BigDecimal(sysDeptTemp.getManagementFeeSecond()));
                    insFeeOrder.setSecondDeptPremiums(getPremium(totalNoTaxPremium,insFeeOrder.getSecondDeptProportion()));
                    //一级机构管理费用比例
                    insFeeOrder.setFirstDeptProportion(new BigDecimal(sysDeptTemp.getManagementFee()));
                    insFeeOrder.setFirstDeptPremiums(getPremium(totalNoTaxPremium,insFeeOrder.getFirstDeptProportion()));
                    //取到第一层级时结束
                    break;
                }
            }while (!"1".equals(comlevel));

            //一级分销比例   推荐人
            //二级分销比例
            //三级分销比例
            /**
             * 分销一级、二级、三级存值取团队配置的分销佣金比例，若该团队走三级分销模式，当前出单员出单时，跟单的分销取值方式为：
             * 根据出单员的推荐人向上找三级，若可以找到，则跟单存一、二、三分销比例；
             * 若向上只能找到一级或者二级，则跟单存一级或者一级、二级
             * 比如 A 1 B 2 C 3 D  若D出单 则给 C 3个 B 2个 A 1个；C出单给 B 3个 A 2个
             * 第一步，先判断团队配置的分销模式
             * 第二步，根据分销模式找上级存值相应分销比例
             * 第三步，仅有一个上级的情况分销比例存啥
             */
            List<EsmRetail> esmRetailList = esmRetailService.selectList(" where t.deptid=? and t.status = '1' ", new Object[]{sysUser.getDeptId()});

            if(esmRetailList!=null && esmRetailList.size()>0){
                EsmRetail esmRetail = esmRetailList.get(0);
                if(esmRetail!=null){
                    int cycleIndex = 0;
                    if("3".equals(esmRetail.getRetailtype())){//团队配置了三级分销模式
                        cycleIndex = 3;
                    }else if("2".equals(esmRetail.getRetailtype())){//团队配置了二级分销模式
                        cycleIndex = 2;
                    }else if("1".equals(esmRetail.getRetailtype())){//团队配置了一级分销模式
                        cycleIndex = 1;
                    }else if("0".equals(esmRetail.getRetailtype())){//团队没有配置分销模式
                        cycleIndex = 0;
                    }

                    //利用当前工号，循环向上找推荐人
                    String userId = sysUser.getId();
                    int breakCycle = 99999999;
                    for(int i=0;i<=cycleIndex;i++){
                        EsmUserReferrer userReferrer = esmUserReferrerService.getById(userId);
                        if(userReferrer.getReferrerId().equals(userReferrer.getId())){//团队长，没有上级
                            //跳出循环
                            breakCycle = i;
                            break;
                        }else {
                            userId = userReferrer.getReferrerId();
                        }
                    }
                    //breakCycle是3，当前工号的上级的上级的上级就是团队长
                    //breakCycle是2，当前工号的上级的上级就是团队长
                    //breakCycle是1，当前工号的上级就是团队长
                    //breakCycle是0，当前工号就是团队长

                    if("3".equals(esmRetail.getRetailtype())){//团队配置了三级分销模式
                        if(breakCycle==99999999||breakCycle==3){
                            insFeeOrder.setFirstRetailProportion(new BigDecimal(esmRetail.getDisrate1()));
                            insFeeOrder.setSecondRetailProportion(new BigDecimal(esmRetail.getDisrate2()));
                            insFeeOrder.setThirdRetailProportion(new BigDecimal(esmRetail.getDisrate3()));
                        }else if(breakCycle==2){
                            insFeeOrder.setSecondRetailProportion(new BigDecimal(esmRetail.getDisrate2()));
                            insFeeOrder.setThirdRetailProportion(new BigDecimal(esmRetail.getDisrate3()));
                        }else if(breakCycle==1){
                            insFeeOrder.setThirdRetailProportion(new BigDecimal(esmRetail.getDisrate3()));
                        }
                    }else if("2".equals(esmRetail.getRetailtype())){//团队配置了二级分销模式
                        if(breakCycle==99999999||breakCycle==3 || breakCycle==2){
                            insFeeOrder.setFirstRetailProportion(new BigDecimal(esmRetail.getDisrate1()));
                            insFeeOrder.setSecondRetailProportion(new BigDecimal(esmRetail.getDisrate2()));
                        }else if(breakCycle==1){
                            insFeeOrder.setSecondRetailProportion(new BigDecimal(esmRetail.getDisrate2()));
                        }
                    }else if("1".equals(esmRetail.getRetailtype())){//团队配置了一级分销模式
                        if(breakCycle==99999999||breakCycle==3 || breakCycle==2||breakCycle==1){
                            insFeeOrder.setFirstRetailProportion(new BigDecimal(esmRetail.getDisrate1()));
                        }
                    }
                    insFeeOrder.setFirstRetailPremiums(getPremium(totalNoTaxPremium,insFeeOrder.getFirstRetailProportion()));
                    insFeeOrder.setSecondRetailPremiums(getPremium(totalNoTaxPremium,insFeeOrder.getSecondRetailProportion()));
                    insFeeOrder.setThirdRetailPremiums(getPremium(totalNoTaxPremium,insFeeOrder.getThirdRetailProportion()));

                }
            }
        }
        insFeeOrderService.insertCompanyAndOrders(insFeeOrder);
    }
    public void compareAndUpdateFeeOrderInfo( String insOrderNo,String jqCostsProportionStr,String syCostsProportionStr ,String dealUser){
        InsFeeOrder insFeeOrder = insFeeOrderService.getByInsOrderNo(insOrderNo);
        InsCopyFeeOrder insCopyFeeOrder = new InsCopyFeeOrder(insFeeOrder,insOrderNo,dealUser);
        boolean updateFlag = false;
        if(insFeeOrder.getJqPremium().doubleValue()>0 && StringUtils.isNotEmpty(jqCostsProportionStr)){
            BigDecimal JqCostsProportion = new BigDecimal(jqCostsProportionStr);
            //比较传入的交强总费用比例是否与原费用比例相等，不相等进行更新
            if(JqCostsProportion.compareTo(insFeeOrder.getJqCostsProportion())!=0){
                updateFlag = true;
                //交强总费用比例
                insFeeOrder.setJqCostsProportion(JqCostsProportion);
                //交强险总费用
                insFeeOrder.setJqCostsPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getJqCostsProportion()));

                insCopyFeeOrder.setJqCostsProportion(insFeeOrder.getJqCostsProportion());
                insCopyFeeOrder.setJqCostsPremiums(insFeeOrder.getJqCostsPremiums());
            }
        }
        if(insFeeOrder.getSyPremium().doubleValue()>0 && StringUtils.isNotEmpty(syCostsProportionStr)){
            BigDecimal SyCostsProportion = new BigDecimal(syCostsProportionStr);
            //比较传入的商业总费用比例是否与原费用比例相等，不相等进行更新
            if(SyCostsProportion.compareTo(insFeeOrder.getSyCostsProportion())!=0){
                updateFlag = true;
                //商业总费用比例
                insFeeOrder.setSyCostsProportion(SyCostsProportion);
                //商业险总费用
                insFeeOrder.setSyCostsPremiums(getPremium(insFeeOrder.getSyNoTaxPremium(),insFeeOrder.getSyCostsProportion()));

                insCopyFeeOrder.setSyCostsProportion(insFeeOrder.getSyCostsProportion());
                insCopyFeeOrder.setSyCostsPremiums(insFeeOrder.getSyCostsPremiums());
            }
        }
        if(updateFlag){
            insFeeOrderService.updateById(insFeeOrder);
            insCopyFeeOrderService.insertCompanyAndOrders(insCopyFeeOrder);
        }
    }

    private BigDecimal getPremium(BigDecimal noTaxPremium,BigDecimal costsProportion){
        BigDecimal premium = new BigDecimal(0);
        if(costsProportion!=null && costsProportion.doubleValue()>0){
            premium = noTaxPremium.multiply(costsProportion).divide(new BigDecimal(100),4,BigDecimal.ROUND_HALF_UP);
        }
        return premium;
    }
    private BigDecimal getPremiumForSubtract(BigDecimal former,BigDecimal latter){
        BigDecimal premium = new BigDecimal(0);
        if(former!=null && latter!=null){
            premium = former.subtract(latter);
        }
        return premium;
    }

    public QueryOrderFeeVo queryFeeOrderInfo(String companyId){
        QueryOrderFeeVo queryOrderFeeVo = new QueryOrderFeeVo();
        QueryOrderCommissionVo orderCommissionVo = new QueryOrderCommissionVo();
        OrderFeeVo jqOrderFeeVo = new OrderFeeVo();
        OrderFeeVo syOrderFeeVo = new OrderFeeVo();
        OrderFeeVo fcOrderFeeVo = new OrderFeeVo();
        AdjustFeeDescVo adjustFeeDescVo=new AdjustFeeDescVo();//费用审核时使用
        InsAreaCompany insAreaCompany = insAreaCompanyService.getByIdIsExist(companyId);
        InsFeeOrder insFeeOrder = insFeeOrderService.getByInsOrderNo(insAreaCompany.getId());

        if(insFeeOrder!=null){
            if(insFeeOrder.getJqPremium()!=null && insFeeOrder.getJqPremium().doubleValue()>0  && insFeeOrder.getSyPremium()!=null && insFeeOrder.getSyPremium().doubleValue()==0){//当为单交业务时
                jqOrderFeeVo = packageOrderFeeInfoOne(insFeeOrder);
                jqOrderFeeVo.setCostsPremiums(convertToString(insFeeOrder.getJqCostsPremiums()));
                jqOrderFeeVo.setCostsProportion(convertToString(insFeeOrder.getJqCostsProportion()));
                jqOrderFeeVo.setCostsPremiumsAll(convertToString(insFeeOrder.getJqSuperviseCostsPremiums())+"元 / "+convertToString(insFeeOrder.getJqCostsPremiums().subtract(insFeeOrder.getJqSuperviseCostsPremiums()))+"元 / "+convertToString(insFeeOrder.getJqCostsPremiums())+"元");
                jqOrderFeeVo.setCostsProportionAll(convertToString(insFeeOrder.getJqSuperviseCostsProportion())+" / "+convertToString(insFeeOrder.getJqCostsProportion().subtract(insFeeOrder.getJqSuperviseCostsProportion()))+" / "+convertToString(insFeeOrder.getJqCostsProportion()));
                /*出单员手续费比例=总费用比例-各级管理费-各级分销费-溢出费*/
                orderCommissionVo = getQueryOrderCommission(orderCommissionVo,insFeeOrder,"JQ");

            }else if(insFeeOrder.getSyPremium()!=null && insFeeOrder.getSyPremium().doubleValue()>0  && insFeeOrder.getJqPremium()!=null && insFeeOrder.getJqPremium().doubleValue()==0){//当为单商业务时
                syOrderFeeVo = packageOrderFeeInfoOne(insFeeOrder);
                syOrderFeeVo.setCostsPremiums(convertToString(insFeeOrder.getSyCostsPremiums()));
                syOrderFeeVo.setCostsProportion(convertToString(insFeeOrder.getSyCostsProportion()));
                syOrderFeeVo.setCostsPremiumsAll(convertToString(insFeeOrder.getSySuperviseCostsPremiums())+"元 / "+convertToString(insFeeOrder.getSyCostsPremiums().subtract(insFeeOrder.getSySuperviseCostsPremiums()))+"元 / "+convertToString(insFeeOrder.getSyCostsPremiums())+"元");
                syOrderFeeVo.setCostsProportionAll(convertToString(insFeeOrder.getSySuperviseCostsProportion())+" / "+convertToString(insFeeOrder.getSyCostsProportion().subtract(insFeeOrder.getSySuperviseCostsProportion()))+" / "+convertToString(insFeeOrder.getSyCostsProportion()));
                /*出单员手续费比例=总费用比例-各级管理费-各级分销费-溢出费*/
                orderCommissionVo = getQueryOrderCommission(orderCommissionVo,insFeeOrder,"SY");
            }else if(insFeeOrder.getJqPremium()!=null && insFeeOrder.getJqPremium().doubleValue()>0 && insFeeOrder.getSyPremium()!=null && insFeeOrder.getSyPremium().doubleValue()>0){//当为交商业务时
                QueryOrderFeeVo queryOrderFeeVoTemp = packageOrderFeeInfoAll(insFeeOrder);
                //获取交强险费用明细
                jqOrderFeeVo = queryOrderFeeVoTemp.getJqCoderFeeVo();
                jqOrderFeeVo.setCostsPremiums(convertToString(insFeeOrder.getJqCostsPremiums()));
                jqOrderFeeVo.setCostsProportion(convertToString(insFeeOrder.getJqCostsProportion()));
                jqOrderFeeVo.setCostsPremiumsAll(convertToString(insFeeOrder.getJqSuperviseCostsPremiums())+"元 / "+convertToString(insFeeOrder.getJqCostsPremiums().subtract(insFeeOrder.getJqSuperviseCostsPremiums()))+"元 / "+convertToString(insFeeOrder.getJqCostsPremiums())+"元");
                jqOrderFeeVo.setCostsProportionAll(convertToString(insFeeOrder.getJqSuperviseCostsProportion())+" / "+convertToString(insFeeOrder.getJqCostsProportion().subtract(insFeeOrder.getJqSuperviseCostsProportion()))+" / "+convertToString(insFeeOrder.getJqCostsProportion()));
                //获取商业险费用明细
                syOrderFeeVo = queryOrderFeeVoTemp.getSyCoderFeeVo();
                syOrderFeeVo.setCostsPremiums(convertToString(insFeeOrder.getSyCostsPremiums()));
                syOrderFeeVo.setCostsProportion(convertToString(insFeeOrder.getSyCostsProportion()));
                syOrderFeeVo.setCostsPremiumsAll(convertToString(insFeeOrder.getSySuperviseCostsPremiums())+"元 / "+convertToString(insFeeOrder.getSyCostsPremiums().subtract(insFeeOrder.getSySuperviseCostsPremiums()))+"元 / "+convertToString(insFeeOrder.getSyCostsPremiums())+"元");
                syOrderFeeVo.setCostsProportionAll(convertToString(insFeeOrder.getSySuperviseCostsProportion())+" / "+convertToString(insFeeOrder.getSyCostsProportion().subtract(insFeeOrder.getSySuperviseCostsProportion()))+" / "+convertToString(insFeeOrder.getSyCostsProportion()));
                /*出单员手续费比例=总费用比例-各级管理费-各级分销费-溢出费*/
                orderCommissionVo = getQueryOrderCommission(orderCommissionVo,insFeeOrder,"ALL");
            }
            queryOrderFeeVo.setJqCoderFeeVo(jqOrderFeeVo);
            queryOrderFeeVo.setSyCoderFeeVo(syOrderFeeVo);
            queryOrderFeeVo.setFcCoderFeeVo(fcOrderFeeVo);
            queryOrderFeeVo.setOrderCommissionVo(orderCommissionVo);
            //添加费用审核时 使用参数
            if(insFeeOrder.getJqPremium()!=null && insFeeOrder.getJqPremium().doubleValue()>0 ){
                adjustFeeDescVo.setJqPremium(convertToString(insFeeOrder.getJqNoTaxPremium()));
                adjustFeeDescVo.setJqCommissionRate(convertToString(insFeeOrder.getJqSuperviseCostsProportion()));
                adjustFeeDescVo.setJqCommissionAmount(convertToString(insFeeOrder.getJqSuperviseCostsPremiums()));
                adjustFeeDescVo.setJqOtherFeeRate(convertToString(insFeeOrder.getJqCostsProportion().subtract(insFeeOrder.getJqSuperviseCostsProportion())));
                adjustFeeDescVo.setJqOtherFeeAmount(convertToString(insFeeOrder.getJqCostsPremiums().subtract(insFeeOrder.getJqSuperviseCostsPremiums())));
                adjustFeeDescVo.setJqAllFeeRate(convertToString(insFeeOrder.getJqCostsProportion()));
                adjustFeeDescVo.setJqAllFeeAmount(convertToString(insFeeOrder.getJqCostsPremiums()));
            }
            if(insFeeOrder.getSyPremium()!=null && insFeeOrder.getSyPremium().doubleValue()>0){
                adjustFeeDescVo.setSyPremium(convertToString(insFeeOrder.getSyNoTaxPremium()));
                adjustFeeDescVo.setSyCommissionRate(convertToString(insFeeOrder.getSySuperviseCostsProportion()));
                adjustFeeDescVo.setSyCommissionAmount(convertToString(insFeeOrder.getSySuperviseCostsPremiums()));
                adjustFeeDescVo.setSyOtherFeeRate(convertToString(insFeeOrder.getSyCostsProportion().subtract(insFeeOrder.getSySuperviseCostsProportion())));
                adjustFeeDescVo.setSyOtherFeeAmount(convertToString(insFeeOrder.getSyCostsPremiums().subtract(insFeeOrder.getSySuperviseCostsPremiums())));
                adjustFeeDescVo.setSyAllFeeRate(convertToString(insFeeOrder.getSyCostsProportion()));
                adjustFeeDescVo.setSyAllFeeAmount(convertToString(insFeeOrder.getSyCostsPremiums()));
            }
            queryOrderFeeVo.setAdjustFeeDescVo(adjustFeeDescVo);
        }
        return queryOrderFeeVo;
    }

    private QueryOrderCommissionVo getQueryOrderCommission(QueryOrderCommissionVo orderCommissionVo,InsFeeOrder insFeeOrder,String businessType){
        /**
         *单保交商时，insFeeOrder 存的就是单交商的各级管理费及分销费
         *同保交商时，insFeeOrder 存的金额是交商总金额，需要扣减
         */
        /*出单员手续费比例=总费用比例-各级管理费-各级分销费-溢出费*/
        if("JQ".equals(businessType)){
            BigDecimal costsPremiums = insFeeOrder.getJqCostsPremiums();
            BigDecimal costsProportion = insFeeOrder.getJqCostsProportion();
            BigDecimal totalCostsProportion = getCostsProportion(insFeeOrder);
            BigDecimal totalCostsPremiums = getCostsPremiumsOne(insFeeOrder);
            if(insFeeOrder.getJqSpilloverPremiums()!=null){
                totalCostsPremiums = totalCostsPremiums.add(insFeeOrder.getJqSpilloverPremiums());
            }
            if(insFeeOrder.getJqSpilloverProportion()!=null){
                totalCostsProportion = totalCostsProportion.add(insFeeOrder.getJqSpilloverProportion());
            }
            BigDecimal userCostsPremiums = costsPremiums.subtract(totalCostsPremiums);
            BigDecimal userCostsProportion = costsProportion.subtract(totalCostsProportion);
            orderCommissionVo.setJqFeePremium(userCostsPremiums.toString());
            orderCommissionVo.setJqFeeRate(userCostsProportion.toString());
            orderCommissionVo.setTotalFeePremium(userCostsPremiums.toString());
        }else if("SY".equals(businessType)){
            BigDecimal costsPremiums = insFeeOrder.getSyCostsPremiums();
            BigDecimal costsProportion = insFeeOrder.getSyCostsProportion();
            BigDecimal totalCostsProportion = getCostsProportion(insFeeOrder);
            BigDecimal totalCostsPremiums = getCostsPremiumsOne(insFeeOrder);
            if(insFeeOrder.getSySpilloverPremiums()!=null){
                totalCostsPremiums = totalCostsPremiums.add(insFeeOrder.getSySpilloverPremiums());
            }
            if(insFeeOrder.getSySpilloverProportion()!=null){
                totalCostsProportion = totalCostsProportion.add(insFeeOrder.getSySpilloverProportion());
            }
            BigDecimal userCostsPremiums = costsPremiums.subtract(totalCostsPremiums);
            BigDecimal userCostsProportion = costsProportion.subtract(totalCostsProportion);
            orderCommissionVo.setSyFeePremium(userCostsPremiums.toString());
            orderCommissionVo.setSyFeeRate(userCostsProportion.toString());
            orderCommissionVo.setTotalFeePremium(userCostsPremiums.toString());
        }else if("ALL".equals(businessType)){
            BigDecimal jqCostsPremiums = insFeeOrder.getJqCostsPremiums();
            BigDecimal jqCostsProportion = insFeeOrder.getJqCostsProportion();
            BigDecimal syCostsPremiums = insFeeOrder.getSyCostsPremiums();
            BigDecimal syCostsProportion = insFeeOrder.getSyCostsProportion();
            BigDecimal totalCostsProportion = getCostsProportion(insFeeOrder);
            BigDecimal jqTotalCostsProportion = totalCostsProportion;
            BigDecimal syTotalCostsProportion = totalCostsProportion;
            HashMap<String,BigDecimal> costsPremiumsMap = getCostsPremiumsAll(insFeeOrder);
            BigDecimal jqTotalCostsPremiums = costsPremiumsMap.get("JQ");
            if(insFeeOrder.getJqSpilloverPremiums()!=null){
                jqTotalCostsPremiums = jqTotalCostsPremiums.add(insFeeOrder.getJqSpilloverPremiums());
            }
            if(insFeeOrder.getJqSpilloverProportion()!=null){
                jqTotalCostsProportion = jqTotalCostsProportion.add(insFeeOrder.getJqSpilloverProportion());
            }
            BigDecimal syTotalCostsPremiums = costsPremiumsMap.get("SY");
            if(insFeeOrder.getJqSpilloverPremiums()!=null){
                syTotalCostsPremiums = syTotalCostsPremiums.add(insFeeOrder.getJqSpilloverPremiums());
            }
            if(insFeeOrder.getJqSpilloverProportion()!=null){
                syTotalCostsProportion = syTotalCostsProportion.add(insFeeOrder.getJqSpilloverProportion());
            }
            BigDecimal jqUserCostsPremiums = jqCostsPremiums.subtract(jqTotalCostsPremiums);
            BigDecimal jqUserCostsProportion = jqCostsProportion.subtract(jqTotalCostsProportion);
            BigDecimal syUserCostsPremiums = syCostsPremiums.subtract(syTotalCostsPremiums);
            BigDecimal syUserCostsProportion = syCostsProportion.subtract(syTotalCostsProportion);
            orderCommissionVo.setJqFeePremium(jqUserCostsPremiums.toString());
            orderCommissionVo.setJqFeeRate(jqUserCostsProportion.toString());
            orderCommissionVo.setSyFeePremium(syUserCostsPremiums.toString());
            orderCommissionVo.setSyFeeRate(syUserCostsProportion.toString());
            orderCommissionVo.setTotalFeePremium(jqUserCostsPremiums.add(syUserCostsPremiums).toString());
        }
        return orderCommissionVo;
    }
    private HashMap<String,BigDecimal> getCostsPremiumsAll(InsFeeOrder insFeeOrder){
        HashMap<String,BigDecimal> costsPremiumsMap = new HashMap<>();
        InsFeeOrder jqInsFeeOrderTemp = new InsFeeOrder();
        //先利用交强费重算费用
        jqInsFeeOrderTemp.setFirstDeptPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getFirstDeptProportion()));
        jqInsFeeOrderTemp.setSecondDeptPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getSecondDeptProportion()));
        jqInsFeeOrderTemp.setThirdDeptPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getThirdDeptProportion()));
        jqInsFeeOrderTemp.setForthDeptPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getForthDeptProportion()));
        jqInsFeeOrderTemp.setFifthDeptPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getFifthDeptProportion()));
        jqInsFeeOrderTemp.setFirstRetailPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getFirstRetailProportion()));
        jqInsFeeOrderTemp.setSecondRetailPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getSecondRetailProportion()));
        jqInsFeeOrderTemp.setThirdRetailPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getThirdRetailProportion()));
        BigDecimal jqCostsPremiums = getCostsPremiumsOne(jqInsFeeOrderTemp);
        costsPremiumsMap.put("JQ",jqCostsPremiums);
        //再利用总费-交强费，得出商业费
        InsFeeOrder syInsFeeOrderTemp = new InsFeeOrder();
        syInsFeeOrderTemp.setFirstDeptPremiums(getPremiumForSubtract(insFeeOrder.getFirstDeptPremiums(),jqInsFeeOrderTemp.getFirstDeptPremiums()));
        syInsFeeOrderTemp.setSecondDeptPremiums(getPremiumForSubtract(insFeeOrder.getSecondDeptPremiums(),jqInsFeeOrderTemp.getSecondDeptPremiums()));
        syInsFeeOrderTemp.setThirdDeptPremiums(getPremiumForSubtract(insFeeOrder.getThirdDeptPremiums(),jqInsFeeOrderTemp.getThirdDeptPremiums()));
        syInsFeeOrderTemp.setForthDeptPremiums(getPremiumForSubtract(insFeeOrder.getForthDeptPremiums(),jqInsFeeOrderTemp.getForthDeptPremiums()));
        syInsFeeOrderTemp.setFifthDeptPremiums(getPremiumForSubtract(insFeeOrder.getFifthDeptPremiums(),jqInsFeeOrderTemp.getFifthDeptPremiums()));
        syInsFeeOrderTemp.setFirstRetailPremiums(getPremiumForSubtract(insFeeOrder.getFirstRetailPremiums(),jqInsFeeOrderTemp.getFirstRetailPremiums()));
        syInsFeeOrderTemp.setSecondRetailPremiums(getPremiumForSubtract(insFeeOrder.getSecondRetailPremiums(),jqInsFeeOrderTemp.getSecondRetailPremiums()));
        syInsFeeOrderTemp.setThirdRetailPremiums(getPremiumForSubtract(insFeeOrder.getThirdRetailPremiums(),jqInsFeeOrderTemp.getThirdRetailPremiums()));
        BigDecimal syCostsPremiums = getCostsPremiumsOne(syInsFeeOrderTemp);
        costsPremiumsMap.put("SY",syCostsPremiums);
        return costsPremiumsMap;
    }
    private BigDecimal getCostsProportion(InsFeeOrder insFeeOrder){
        BigDecimal totalCostsProportion = new BigDecimal(0);
        if(insFeeOrder.getFirstDeptProportion()!=null){
            totalCostsProportion = totalCostsProportion.add(insFeeOrder.getFirstDeptProportion());
        }
        if(insFeeOrder.getSecondDeptProportion()!=null){
            totalCostsProportion = totalCostsProportion.add(insFeeOrder.getSecondDeptProportion());
        }
        if(insFeeOrder.getThirdDeptProportion()!=null){
            totalCostsProportion = totalCostsProportion.add(insFeeOrder.getThirdDeptProportion());
        }
        if(insFeeOrder.getForthDeptProportion()!=null){
            totalCostsProportion = totalCostsProportion.add(insFeeOrder.getForthDeptProportion());
        }
        if(insFeeOrder.getFifthDeptProportion()!=null){
            totalCostsProportion = totalCostsProportion.add(insFeeOrder.getFifthDeptProportion());
        }
        if(insFeeOrder.getFirstRetailProportion()!=null){
            totalCostsProportion = totalCostsProportion.add(insFeeOrder.getFirstRetailProportion());
        }
        if(insFeeOrder.getSecondRetailProportion()!=null){
            totalCostsProportion = totalCostsProportion.add(insFeeOrder.getSecondRetailProportion());
        }
        if(insFeeOrder.getThirdRetailProportion()!=null){
            totalCostsProportion = totalCostsProportion.add(insFeeOrder.getThirdRetailProportion());
        }
        return totalCostsProportion;
    }
    private BigDecimal getCostsPremiumsOne(InsFeeOrder insFeeOrder){
        BigDecimal totalCostsPremiums = new BigDecimal(0);
        if(insFeeOrder.getFirstDeptPremiums()!=null){
            totalCostsPremiums = totalCostsPremiums.add(insFeeOrder.getFirstDeptPremiums());
        }
        if(insFeeOrder.getSecondDeptPremiums()!=null){
            totalCostsPremiums = totalCostsPremiums.add(insFeeOrder.getSecondDeptPremiums());
        }
        if(insFeeOrder.getThirdDeptPremiums()!=null){
            totalCostsPremiums = totalCostsPremiums.add(insFeeOrder.getThirdDeptPremiums());
        }
        if(insFeeOrder.getForthDeptPremiums()!=null){
            totalCostsPremiums = totalCostsPremiums.add(insFeeOrder.getForthDeptPremiums());
        }
        if(insFeeOrder.getFifthDeptPremiums()!=null){
            totalCostsPremiums = totalCostsPremiums.add(insFeeOrder.getFifthDeptPremiums());
        }
        if(insFeeOrder.getFirstRetailPremiums()!=null){
            totalCostsPremiums = totalCostsPremiums.add(insFeeOrder.getFirstRetailPremiums());
        }
        if(insFeeOrder.getSecondRetailPremiums()!=null){
            totalCostsPremiums = totalCostsPremiums.add(insFeeOrder.getSecondRetailPremiums());
        }
        if(insFeeOrder.getThirdRetailPremiums()!=null){
            totalCostsPremiums = totalCostsPremiums.add(insFeeOrder.getThirdRetailPremiums());
        }
        return totalCostsPremiums;
    }
    //把取出的费用信息转换为页面需要展示的数据
    public List<QueryOrderFeeResultVo> convertOrderFeeVoData(QueryOrderFeeVo orderFeeVo) {
        List<QueryOrderFeeResultVo> resultList=new ArrayList<>();
        OrderFeeVo jqOrderFeeVo = orderFeeVo.getJqCoderFeeVo();
        OrderFeeVo syOrderFeeVo = orderFeeVo.getSyCoderFeeVo();
        OrderFeeVo fcOrderFeeVo = orderFeeVo.getFcCoderFeeVo();

        //总费用
        QueryOrderFeeResultVo feeResultVo1=new QueryOrderFeeResultVo();
        feeResultVo1.setDescSerialNo("1");
        feeResultVo1.setFeeTypeName("总费用");
        feeResultVo1.setJqFeeRate(jqOrderFeeVo!=null&&jqOrderFeeVo.getCostsProportion()!=null?jqOrderFeeVo.getCostsProportion():"-");
        feeResultVo1.setJqFeeAmount(jqOrderFeeVo!=null&&jqOrderFeeVo.getCostsPremiums()!=null?jqOrderFeeVo.getCostsPremiums():"-");
        feeResultVo1.setSyFeeRate(syOrderFeeVo!=null&&syOrderFeeVo.getCostsProportion()!=null?syOrderFeeVo.getCostsProportion():"-");
        feeResultVo1.setSyFeeAmount(syOrderFeeVo!=null&&syOrderFeeVo.getCostsPremiums()!=null?syOrderFeeVo.getCostsPremiums():"-");
        feeResultVo1.setFcFeeRate(fcOrderFeeVo!=null&&fcOrderFeeVo.getCostsProportion()!=null?fcOrderFeeVo.getCostsProportion():"-");
        feeResultVo1.setFcFeeAmount(fcOrderFeeVo!=null&&fcOrderFeeVo.getCostsPremiums()!=null?fcOrderFeeVo.getCostsPremiums():"-");
        feeResultVo1.setJqFeeRateAll(jqOrderFeeVo!=null&&jqOrderFeeVo.getCostsProportionAll()!=null?jqOrderFeeVo.getCostsProportionAll():"-");
        feeResultVo1.setJqFeeAmountAll(jqOrderFeeVo!=null&&jqOrderFeeVo.getCostsPremiumsAll()!=null?jqOrderFeeVo.getCostsPremiumsAll():"-");
        feeResultVo1.setSyFeeRateAll(syOrderFeeVo!=null&&syOrderFeeVo.getCostsProportionAll()!=null?syOrderFeeVo.getCostsProportionAll():"-");
        feeResultVo1.setSyFeeAmountAll(syOrderFeeVo!=null&&syOrderFeeVo.getCostsPremiumsAll()!=null?syOrderFeeVo.getCostsPremiumsAll():"-");
        feeResultVo1.setFcFeeRateAll(fcOrderFeeVo!=null&&fcOrderFeeVo.getCostsProportionAll()!=null?fcOrderFeeVo.getCostsProportionAll():"-");
        feeResultVo1.setFcFeeAmountAll(fcOrderFeeVo!=null&&fcOrderFeeVo.getCostsPremiumsAll()!=null?fcOrderFeeVo.getCostsPremiumsAll():"-");
        resultList.add(feeResultVo1);
        //一级管理费用
        QueryOrderFeeResultVo feeResultVo2=new QueryOrderFeeResultVo();
        feeResultVo2.setDescSerialNo("2");
        feeResultVo2.setFeeTypeName("一级管理费");
        feeResultVo2.setJqFeeRate(jqOrderFeeVo!=null&&jqOrderFeeVo.getFirstDeptProportion()!=null?jqOrderFeeVo.getFirstDeptProportion():"-");
        feeResultVo2.setJqFeeAmount(jqOrderFeeVo!=null&&jqOrderFeeVo.getFirstDeptPremiums()!=null?jqOrderFeeVo.getFirstDeptPremiums():"-");
        feeResultVo2.setSyFeeRate(syOrderFeeVo!=null&&syOrderFeeVo.getFirstDeptProportion()!=null?syOrderFeeVo.getFirstDeptProportion():"-");
        feeResultVo2.setSyFeeAmount(syOrderFeeVo!=null&&syOrderFeeVo.getFirstDeptPremiums()!=null?syOrderFeeVo.getFirstDeptPremiums():"-");
        feeResultVo2.setFcFeeRate(fcOrderFeeVo!=null&&fcOrderFeeVo.getFirstDeptProportion()!=null?fcOrderFeeVo.getFirstDeptProportion():"-");
        feeResultVo2.setFcFeeAmount(fcOrderFeeVo!=null&&fcOrderFeeVo.getFirstDeptPremiums()!=null?fcOrderFeeVo.getFirstDeptPremiums():"-");
        feeResultVo2.setJqFeeRateAll(feeResultVo2.getJqFeeRate());
        feeResultVo2.setJqFeeAmountAll(feeResultVo2.getJqFeeAmount());
        feeResultVo2.setSyFeeRateAll(feeResultVo2.getSyFeeRate());
        feeResultVo2.setSyFeeAmountAll(feeResultVo2.getSyFeeAmount());
        feeResultVo2.setFcFeeRateAll(feeResultVo2.getFcFeeRate());
        feeResultVo2.setFcFeeAmountAll(feeResultVo2.getFcFeeAmount());
        resultList.add(feeResultVo2);
        //二级管理费用
        QueryOrderFeeResultVo feeResultVo3=new QueryOrderFeeResultVo();
        feeResultVo3.setDescSerialNo("3");
        feeResultVo3.setFeeTypeName("二级管理费");
        feeResultVo3.setJqFeeRate(jqOrderFeeVo!=null&&jqOrderFeeVo.getSecondDeptProportion()!=null?jqOrderFeeVo.getSecondDeptProportion():"-");
        feeResultVo3.setJqFeeAmount(jqOrderFeeVo!=null&&jqOrderFeeVo.getSecondDeptPremiums()!=null?jqOrderFeeVo.getSecondDeptPremiums():"-");
        feeResultVo3.setSyFeeRate(syOrderFeeVo!=null&&syOrderFeeVo.getSecondDeptProportion()!=null?syOrderFeeVo.getSecondDeptProportion():"-");
        feeResultVo3.setSyFeeAmount(syOrderFeeVo!=null&&syOrderFeeVo.getSecondDeptPremiums()!=null?syOrderFeeVo.getSecondDeptPremiums():"-");
        feeResultVo3.setFcFeeRate(fcOrderFeeVo!=null&&fcOrderFeeVo.getSecondDeptProportion()!=null?fcOrderFeeVo.getSecondDeptProportion():"-");
        feeResultVo3.setFcFeeAmount(fcOrderFeeVo!=null&&fcOrderFeeVo.getSecondDeptPremiums()!=null?fcOrderFeeVo.getSecondDeptPremiums():"-");
        feeResultVo3.setJqFeeRateAll(feeResultVo3.getJqFeeRate());
        feeResultVo3.setJqFeeAmountAll(feeResultVo3.getJqFeeAmount());
        feeResultVo3.setSyFeeRateAll(feeResultVo3.getSyFeeRate());
        feeResultVo3.setSyFeeAmountAll(feeResultVo3.getSyFeeAmount());
        feeResultVo3.setFcFeeRateAll(feeResultVo3.getFcFeeRate());
        feeResultVo3.setFcFeeAmountAll(feeResultVo3.getFcFeeAmount());
        resultList.add(feeResultVo3);
        //三级管理费用
        QueryOrderFeeResultVo feeResultVo4=new QueryOrderFeeResultVo();
        feeResultVo4.setDescSerialNo("4");
        feeResultVo4.setFeeTypeName("三级管理费");
        feeResultVo4.setJqFeeRate(jqOrderFeeVo!=null&&jqOrderFeeVo.getThirdDeptProportion()!=null?jqOrderFeeVo.getThirdDeptProportion():"-");
        feeResultVo4.setJqFeeAmount(jqOrderFeeVo!=null&&jqOrderFeeVo.getThirdDeptPremiums()!=null?jqOrderFeeVo.getThirdDeptPremiums():"-");
        feeResultVo4.setSyFeeRate(syOrderFeeVo!=null&&syOrderFeeVo.getThirdDeptProportion()!=null?syOrderFeeVo.getThirdDeptProportion():"-");
        feeResultVo4.setSyFeeAmount(syOrderFeeVo!=null&&syOrderFeeVo.getThirdDeptPremiums()!=null?syOrderFeeVo.getThirdDeptPremiums():"-");
        feeResultVo4.setFcFeeRate(fcOrderFeeVo!=null&&fcOrderFeeVo.getThirdDeptProportion()!=null?fcOrderFeeVo.getThirdDeptProportion():"-");
        feeResultVo4.setFcFeeAmount(fcOrderFeeVo!=null&&fcOrderFeeVo.getThirdDeptPremiums()!=null?fcOrderFeeVo.getThirdDeptPremiums():"-");
        feeResultVo4.setJqFeeRateAll(feeResultVo4.getJqFeeRate());
        feeResultVo4.setJqFeeAmountAll(feeResultVo4.getJqFeeAmount());
        feeResultVo4.setSyFeeRateAll(feeResultVo4.getSyFeeRate());
        feeResultVo4.setSyFeeAmountAll(feeResultVo4.getSyFeeAmount());
        feeResultVo4.setFcFeeRateAll(feeResultVo4.getFcFeeRate());
        feeResultVo4.setFcFeeAmountAll(feeResultVo4.getFcFeeAmount());
        resultList.add(feeResultVo4);
        //四级管理费用
        QueryOrderFeeResultVo feeResultVo5=new QueryOrderFeeResultVo();
        feeResultVo5.setDescSerialNo("5");
        feeResultVo5.setFeeTypeName("四级管理费");
        feeResultVo5.setJqFeeRate(jqOrderFeeVo!=null&&jqOrderFeeVo.getForthDeptProportion()!=null?jqOrderFeeVo.getForthDeptProportion():"-");
        feeResultVo5.setJqFeeAmount(jqOrderFeeVo!=null&&jqOrderFeeVo.getForthDeptPremiums()!=null?jqOrderFeeVo.getForthDeptPremiums():"-");
        feeResultVo5.setSyFeeRate(syOrderFeeVo!=null&&syOrderFeeVo.getForthDeptProportion()!=null?syOrderFeeVo.getForthDeptProportion():"-");
        feeResultVo5.setSyFeeAmount(syOrderFeeVo!=null&&syOrderFeeVo.getForthDeptPremiums()!=null?syOrderFeeVo.getForthDeptPremiums():"-");
        feeResultVo5.setFcFeeRate(fcOrderFeeVo!=null&&fcOrderFeeVo.getForthDeptProportion()!=null?fcOrderFeeVo.getForthDeptProportion():"-");
        feeResultVo5.setFcFeeAmount(fcOrderFeeVo!=null&&fcOrderFeeVo.getForthDeptPremiums()!=null?fcOrderFeeVo.getForthDeptPremiums():"-");
        feeResultVo5.setJqFeeRateAll(feeResultVo5.getJqFeeRate());
        feeResultVo5.setJqFeeAmountAll(feeResultVo5.getJqFeeAmount());
        feeResultVo5.setSyFeeRateAll(feeResultVo5.getSyFeeRate());
        feeResultVo5.setSyFeeAmountAll(feeResultVo5.getSyFeeAmount());
        feeResultVo5.setFcFeeRateAll(feeResultVo5.getFcFeeRate());
        feeResultVo5.setFcFeeAmountAll(feeResultVo5.getFcFeeAmount());
        resultList.add(feeResultVo5);
        //五级管理费用
        QueryOrderFeeResultVo feeResultVo6=new QueryOrderFeeResultVo();
        feeResultVo6.setDescSerialNo("6");
        feeResultVo6.setFeeTypeName("五级管理费");
        feeResultVo6.setJqFeeRate(jqOrderFeeVo!=null&&jqOrderFeeVo.getFifthDeptProportion()!=null?jqOrderFeeVo.getFifthDeptProportion():"-");
        feeResultVo6.setJqFeeAmount(jqOrderFeeVo!=null&&jqOrderFeeVo.getFifthDeptPremiums()!=null?jqOrderFeeVo.getFifthDeptPremiums():"-");
        feeResultVo6.setSyFeeRate(syOrderFeeVo!=null&&syOrderFeeVo.getFifthDeptProportion()!=null?syOrderFeeVo.getFifthDeptProportion():"-");
        feeResultVo6.setSyFeeAmount(syOrderFeeVo!=null&&syOrderFeeVo.getFifthDeptPremiums()!=null?syOrderFeeVo.getFifthDeptPremiums():"-");
        feeResultVo6.setFcFeeRate(fcOrderFeeVo!=null&&fcOrderFeeVo.getFifthDeptProportion()!=null?fcOrderFeeVo.getFifthDeptProportion():"-");
        feeResultVo6.setFcFeeAmount(fcOrderFeeVo!=null&&fcOrderFeeVo.getFifthDeptPremiums()!=null?fcOrderFeeVo.getFifthDeptPremiums():"-");
        feeResultVo6.setJqFeeRateAll(feeResultVo6.getJqFeeRate());
        feeResultVo6.setJqFeeAmountAll(feeResultVo6.getJqFeeAmount());
        feeResultVo6.setSyFeeRateAll(feeResultVo6.getSyFeeRate());
        feeResultVo6.setSyFeeAmountAll(feeResultVo6.getSyFeeAmount());
        feeResultVo6.setFcFeeRateAll(feeResultVo6.getFcFeeRate());
        feeResultVo6.setFcFeeAmountAll(feeResultVo6.getFcFeeAmount());
        resultList.add(feeResultVo6);
        //一级分销费
        QueryOrderFeeResultVo feeResultVo7=new QueryOrderFeeResultVo();
        feeResultVo7.setDescSerialNo("7");
        feeResultVo7.setFeeTypeName("一级分销费");
        feeResultVo7.setJqFeeRate(jqOrderFeeVo!=null&&jqOrderFeeVo.getFirstRetailProportion()!=null?jqOrderFeeVo.getFirstRetailProportion():"-");
        feeResultVo7.setJqFeeAmount(jqOrderFeeVo!=null&&jqOrderFeeVo.getFirstRetailPremiums()!=null?jqOrderFeeVo.getFirstRetailPremiums():"-");
        feeResultVo7.setSyFeeRate(syOrderFeeVo!=null&&syOrderFeeVo.getFirstRetailProportion()!=null?syOrderFeeVo.getFirstRetailProportion():"-");
        feeResultVo7.setSyFeeAmount(syOrderFeeVo!=null&&syOrderFeeVo.getFirstRetailPremiums()!=null?syOrderFeeVo.getFirstRetailPremiums():"-");
        feeResultVo7.setFcFeeRate(fcOrderFeeVo!=null&&fcOrderFeeVo.getFirstRetailProportion()!=null?fcOrderFeeVo.getFirstRetailProportion():"-");
        feeResultVo7.setFcFeeAmount(fcOrderFeeVo!=null&&fcOrderFeeVo.getFirstRetailPremiums()!=null?fcOrderFeeVo.getFirstRetailPremiums():"-");
        feeResultVo7.setJqFeeRateAll(feeResultVo7.getJqFeeRate());
        feeResultVo7.setJqFeeAmountAll(feeResultVo7.getJqFeeAmount());
        feeResultVo7.setSyFeeRateAll(feeResultVo7.getSyFeeRate());
        feeResultVo7.setSyFeeAmountAll(feeResultVo7.getSyFeeAmount());
        feeResultVo7.setFcFeeRateAll(feeResultVo7.getFcFeeRate());
        feeResultVo7.setFcFeeAmountAll(feeResultVo7.getFcFeeAmount());
        resultList.add(feeResultVo7);
        //二级分销费
        QueryOrderFeeResultVo feeResultVo8=new QueryOrderFeeResultVo();
        feeResultVo8.setDescSerialNo("8");
        feeResultVo8.setFeeTypeName("二级分销费");
        feeResultVo8.setJqFeeRate(jqOrderFeeVo!=null&&jqOrderFeeVo.getSecondRetailProportion()!=null?jqOrderFeeVo.getSecondRetailProportion():"-");
        feeResultVo8.setJqFeeAmount(jqOrderFeeVo!=null&&jqOrderFeeVo.getSecondRetailPremiums()!=null?jqOrderFeeVo.getSecondRetailPremiums():"-");
        feeResultVo8.setSyFeeRate(syOrderFeeVo!=null&&syOrderFeeVo.getSecondRetailProportion()!=null?syOrderFeeVo.getSecondRetailProportion():"-");
        feeResultVo8.setSyFeeAmount(syOrderFeeVo!=null&&syOrderFeeVo.getSecondRetailPremiums()!=null?syOrderFeeVo.getSecondRetailPremiums():"-");
        feeResultVo8.setFcFeeRate(fcOrderFeeVo!=null&&fcOrderFeeVo.getSecondRetailProportion()!=null?fcOrderFeeVo.getSecondRetailProportion():"-");
        feeResultVo8.setFcFeeAmount(fcOrderFeeVo!=null&&fcOrderFeeVo.getSecondRetailPremiums()!=null?fcOrderFeeVo.getSecondRetailPremiums():"-");
        feeResultVo8.setJqFeeRateAll(feeResultVo8.getJqFeeRate());
        feeResultVo8.setJqFeeAmountAll(feeResultVo8.getJqFeeAmount());
        feeResultVo8.setSyFeeRateAll(feeResultVo8.getSyFeeRate());
        feeResultVo8.setSyFeeAmountAll(feeResultVo8.getSyFeeAmount());
        feeResultVo8.setFcFeeRateAll(feeResultVo8.getFcFeeRate());
        feeResultVo8.setFcFeeAmountAll(feeResultVo8.getFcFeeAmount());
        resultList.add(feeResultVo8);
        //三级分销费
        QueryOrderFeeResultVo feeResultVo9=new QueryOrderFeeResultVo();
        feeResultVo9.setDescSerialNo("9");
        feeResultVo9.setFeeTypeName("三级分销费");
        feeResultVo9.setJqFeeRate(jqOrderFeeVo!=null&&jqOrderFeeVo.getThirdRetailProportion()!=null?jqOrderFeeVo.getThirdRetailProportion():"-");
        feeResultVo9.setJqFeeAmount(jqOrderFeeVo!=null&&jqOrderFeeVo.getThirdRetailPremiums()!=null?jqOrderFeeVo.getThirdRetailPremiums():"-");
        feeResultVo9.setSyFeeRate(syOrderFeeVo!=null&&syOrderFeeVo.getThirdRetailProportion()!=null?syOrderFeeVo.getThirdRetailProportion():"-");
        feeResultVo9.setSyFeeAmount(syOrderFeeVo!=null&&syOrderFeeVo.getThirdRetailPremiums()!=null?syOrderFeeVo.getThirdRetailPremiums():"-");
        feeResultVo9.setFcFeeRate(fcOrderFeeVo!=null&&fcOrderFeeVo.getThirdRetailProportion()!=null?fcOrderFeeVo.getThirdRetailProportion():"-");
        feeResultVo9.setFcFeeAmount(fcOrderFeeVo!=null&&fcOrderFeeVo.getThirdRetailPremiums()!=null?fcOrderFeeVo.getThirdRetailPremiums():"-");
        feeResultVo9.setJqFeeRateAll(feeResultVo9.getJqFeeRate());
        feeResultVo9.setJqFeeAmountAll(feeResultVo9.getJqFeeAmount());
        feeResultVo9.setSyFeeRateAll(feeResultVo9.getSyFeeRate());
        feeResultVo9.setSyFeeAmountAll(feeResultVo9.getSyFeeAmount());
        feeResultVo9.setFcFeeRateAll(feeResultVo9.getFcFeeRate());
        feeResultVo9.setFcFeeAmountAll(feeResultVo9.getFcFeeAmount());
        resultList.add(feeResultVo9);
        return resultList;
    }

    /**
     * 按照组合单模式获取费用明细
     * @param insFeeOrder
     * @return
     */
    private QueryOrderFeeVo packageOrderFeeInfoAll(InsFeeOrder insFeeOrder){
        QueryOrderFeeVo queryOrderFeeVo = new QueryOrderFeeVo();
        InsFeeOrder jqInsFeeOrderTemp = new InsFeeOrder();
        //先利用交强费重算费用
        jqInsFeeOrderTemp.setFirstDeptPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getFirstDeptProportion()));
        jqInsFeeOrderTemp.setSecondDeptPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getSecondDeptProportion()));
        jqInsFeeOrderTemp.setThirdDeptPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getThirdDeptProportion()));
        jqInsFeeOrderTemp.setForthDeptPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getForthDeptProportion()));
        jqInsFeeOrderTemp.setFifthDeptPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getFifthDeptProportion()));
        jqInsFeeOrderTemp.setFirstRetailPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getFirstRetailProportion()));
        jqInsFeeOrderTemp.setSecondRetailPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getSecondRetailProportion()));
        jqInsFeeOrderTemp.setThirdRetailPremiums(getPremium(insFeeOrder.getJqNoTaxPremium(),insFeeOrder.getThirdRetailProportion()));

        //再利用总费-交强费，得出商业费
        InsFeeOrder syInsFeeOrderTemp = new InsFeeOrder();
        syInsFeeOrderTemp.setFirstDeptPremiums(getPremiumForSubtract(insFeeOrder.getFirstDeptPremiums(),jqInsFeeOrderTemp.getFirstDeptPremiums()));
        syInsFeeOrderTemp.setSecondDeptPremiums(getPremiumForSubtract(insFeeOrder.getSecondDeptPremiums(),jqInsFeeOrderTemp.getSecondDeptPremiums()));
        syInsFeeOrderTemp.setThirdDeptPremiums(getPremiumForSubtract(insFeeOrder.getThirdDeptPremiums(),jqInsFeeOrderTemp.getThirdDeptPremiums()));
        syInsFeeOrderTemp.setForthDeptPremiums(getPremiumForSubtract(insFeeOrder.getForthDeptPremiums(),jqInsFeeOrderTemp.getForthDeptPremiums()));
        syInsFeeOrderTemp.setFifthDeptPremiums(getPremiumForSubtract(insFeeOrder.getFifthDeptPremiums(),jqInsFeeOrderTemp.getFifthDeptPremiums()));
        syInsFeeOrderTemp.setFirstRetailPremiums(getPremiumForSubtract(insFeeOrder.getFirstRetailPremiums(),jqInsFeeOrderTemp.getFirstRetailPremiums()));
        syInsFeeOrderTemp.setSecondRetailPremiums(getPremiumForSubtract(insFeeOrder.getSecondRetailPremiums(),jqInsFeeOrderTemp.getSecondRetailPremiums()));
        syInsFeeOrderTemp.setThirdRetailPremiums(getPremiumForSubtract(insFeeOrder.getThirdRetailPremiums(),jqInsFeeOrderTemp.getThirdRetailPremiums()));

        //交强费转换赋值
        OrderFeeVo jqOrderFeeVo = packageOrderFeeInfoOne(insFeeOrder);
        jqOrderFeeVo.setFirstDeptPremiums(convertToString(jqInsFeeOrderTemp.getFirstDeptPremiums()));
        jqOrderFeeVo.setSecondDeptPremiums(convertToString(jqInsFeeOrderTemp.getSecondDeptPremiums()));
        jqOrderFeeVo.setThirdDeptPremiums(convertToString(jqInsFeeOrderTemp.getThirdDeptPremiums()));
        jqOrderFeeVo.setForthDeptPremiums(convertToString(jqInsFeeOrderTemp.getForthDeptPremiums()));
        jqOrderFeeVo.setFifthDeptPremiums(convertToString(jqInsFeeOrderTemp.getFifthDeptPremiums()));
        jqOrderFeeVo.setFirstRetailPremiums(convertToString(jqInsFeeOrderTemp.getFirstRetailPremiums()));
        jqOrderFeeVo.setSecondRetailPremiums(convertToString(jqInsFeeOrderTemp.getSecondRetailPremiums()));
        jqOrderFeeVo.setThirdRetailPremiums(convertToString(jqInsFeeOrderTemp.getThirdRetailPremiums()));

        //商业费转换赋值
        OrderFeeVo syOrderFeeVo = packageOrderFeeInfoOne(insFeeOrder);
        syOrderFeeVo.setFirstDeptPremiums(convertToString(syInsFeeOrderTemp.getFirstDeptPremiums()));
        syOrderFeeVo.setSecondDeptPremiums(convertToString(syInsFeeOrderTemp.getSecondDeptPremiums()));
        syOrderFeeVo.setThirdDeptPremiums(convertToString(syInsFeeOrderTemp.getThirdDeptPremiums()));
        syOrderFeeVo.setForthDeptPremiums(convertToString(syInsFeeOrderTemp.getForthDeptPremiums()));
        syOrderFeeVo.setFifthDeptPremiums(convertToString(syInsFeeOrderTemp.getFifthDeptPremiums()));
        syOrderFeeVo.setFirstRetailPremiums(convertToString(syInsFeeOrderTemp.getFirstRetailPremiums()));
        syOrderFeeVo.setSecondRetailPremiums(convertToString(syInsFeeOrderTemp.getSecondRetailPremiums()));
        syOrderFeeVo.setThirdRetailPremiums(convertToString(syInsFeeOrderTemp.getThirdRetailPremiums()));

        queryOrderFeeVo.setJqCoderFeeVo(jqOrderFeeVo);
        queryOrderFeeVo.setSyCoderFeeVo(syOrderFeeVo);
        return queryOrderFeeVo;
    }

    /**
     * 按照单险种方式获取费用明细
     * @param insFeeOrder
     * @return
     */
    private OrderFeeVo packageOrderFeeInfoOne(InsFeeOrder insFeeOrder){
        OrderFeeVo orderFeeVo = new OrderFeeVo();
        orderFeeVo.setFirstDeptPremiums(convertToString(insFeeOrder.getFirstDeptPremiums()));
        orderFeeVo.setFirstDeptProportion(convertToString(insFeeOrder.getFirstDeptProportion()));
        orderFeeVo.setSecondDeptPremiums(convertToString(insFeeOrder.getSecondDeptPremiums()));
        orderFeeVo.setSecondDeptProportion(convertToString(insFeeOrder.getSecondDeptProportion()));
        orderFeeVo.setThirdDeptPremiums(convertToString(insFeeOrder.getThirdDeptPremiums()));
        orderFeeVo.setThirdDeptProportion(convertToString(insFeeOrder.getThirdDeptProportion()));
        orderFeeVo.setForthDeptPremiums(convertToString(insFeeOrder.getForthDeptPremiums()));
        orderFeeVo.setForthDeptProportion(convertToString(insFeeOrder.getForthDeptProportion()));
        orderFeeVo.setFifthDeptPremiums(convertToString(insFeeOrder.getFifthDeptPremiums()));
        orderFeeVo.setFifthDeptProportion(convertToString(insFeeOrder.getFifthDeptProportion()));
        orderFeeVo.setFirstRetailPremiums(convertToString(insFeeOrder.getFirstRetailPremiums()));
        orderFeeVo.setFirstRetailProportion(convertToString(insFeeOrder.getFirstRetailProportion()));
        orderFeeVo.setSecondRetailPremiums(convertToString(insFeeOrder.getSecondRetailPremiums()));
        orderFeeVo.setSecondRetailProportion(convertToString(insFeeOrder.getSecondRetailProportion()));
        orderFeeVo.setThirdRetailPremiums(convertToString(insFeeOrder.getThirdRetailPremiums()));
        orderFeeVo.setThirdRetailProportion(convertToString(insFeeOrder.getThirdRetailProportion()));
        return orderFeeVo;
    }

    private String convertToString(BigDecimal b){
        if(b!=null){
            if(b.doubleValue()==0){
                return null;
            }else {
                return b.toString();
            }
        }else{
            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("拒保提示："+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(22);
        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").append(",");
        result.append(feeSchemeReqDto.getBusType());
        return result.toString();
    }
}