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 com.ydtech.modules.protocols.entity.po.InsFeeOrderNew;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
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.isEmpty()) {
            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(BigDecimal.valueOf(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(BigDecimal.valueOf(sysDeptTemp.getManagementFeeFifth()));
//                    insFeeOrder.setFifthDeptPremiums(getPremium(totalNoTaxPremium, insFeeOrder.getFifthDeptProportion()));
//                    //四级机构管理费用比例
//                    insFeeOrder.setForthDeptProportion(BigDecimal.valueOf(sysDeptTemp.getManagementFeeForth()));
//                    insFeeOrder.setForthDeptPremiums(getPremium(totalNoTaxPremium, insFeeOrder.getForthDeptProportion()));
//                    //三级机构管理费用比例
//                    insFeeOrder.setThirdDeptProportion(BigDecimal.valueOf(sysDeptTemp.getManagementFeeThird()));
//                    insFeeOrder.setThirdDeptPremiums(getPremium(totalNoTaxPremium, insFeeOrder.getThirdDeptProportion()));
//                    //二级机构管理费用比例
//                    insFeeOrder.setSecondDeptProportion(BigDecimal.valueOf(sysDeptTemp.getManagementFeeSecond()));
//                    insFeeOrder.setSecondDeptPremiums(getPremium(totalNoTaxPremium, insFeeOrder.getSecondDeptProportion()));
//                    //一级机构管理费用比例
//                    insFeeOrder.setFirstDeptProportion(BigDecimal.valueOf(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.isEmpty()) {
//                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(BigDecimal.valueOf(esmRetail.getDisrate1()));
//                            insFeeOrder.setSecondRetailProportion(BigDecimal.valueOf(esmRetail.getDisrate2()));
//                            insFeeOrder.setThirdRetailProportion(BigDecimal.valueOf(esmRetail.getDisrate3()));
//                        } else if (breakCycle == 2) {
//                            insFeeOrder.setSecondRetailProportion(BigDecimal.valueOf(esmRetail.getDisrate2()));
//                            insFeeOrder.setThirdRetailProportion(BigDecimal.valueOf(esmRetail.getDisrate3()));
//                        } else if (breakCycle == 1) {
//                            insFeeOrder.setThirdRetailProportion(BigDecimal.valueOf(esmRetail.getDisrate3()));
//                        }
//                    } else if ("2".equals(esmRetail.getRetailtype())) {//团队配置了二级分销模式
//                        if (breakCycle == 99999999 || breakCycle == 3 || breakCycle == 2) {
//                            insFeeOrder.setFirstRetailProportion(BigDecimal.valueOf(esmRetail.getDisrate1()));
//                            insFeeOrder.setSecondRetailProportion(BigDecimal.valueOf(esmRetail.getDisrate2()));
//                        } else if (breakCycle == 1) {
//                            insFeeOrder.setSecondRetailProportion(BigDecimal.valueOf(esmRetail.getDisrate2()));
//                        }
//                    } else if ("1".equals(esmRetail.getRetailtype())) {//团队配置了一级分销模式
//                        if (breakCycle == 99999999 || breakCycle == 3 || breakCycle == 2 || breakCycle == 1) {
//                            insFeeOrder.setFirstRetailProportion(BigDecimal.valueOf(esmRetail.getDisrate1()));
//                        }
//                    }
//                    insFeeOrder.setFirstRetailPremiums(getPremium(totalNoTaxPremium, insFeeOrder.getFirstRetailProportion()));
//                    insFeeOrder.setSecondRetailPremiums(getPremium(totalNoTaxPremium, insFeeOrder.getSecondRetailProportion()));
//                    insFeeOrder.setThirdRetailPremiums(getPremium(totalNoTaxPremium, insFeeOrder.getThirdRetailProportion()));
//
//                }
//            }
//        }
//        insFeeOrderService.insertCompanyAndOrders(insFeeOrder);
//    }

    @Override
    public QueryOrderFeeVo queryFeeOrderInfo(String companyId) {
        return null;
    }

    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, RoundingMode.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(InsFeeOrderNew insFeeOrderNew){
        List<QueryOrderFeeResultVo> queryOrderFeeResultVos = new ArrayList<>();
        QueryOrderFeeResultVo sumFeeResultVo = new QueryOrderFeeResultVo();
        sumFeeResultVo.setDescSerialNo("1");
        sumFeeResultVo.setFeeTypeName("总费用");
        //设置交强费用比例
        StringBuilder jqFeeRate = new StringBuilder();
        jqFeeRate.append(insFeeOrderNew.getJqSuperviseCostsProportion()).append(" / ")
                .append(insFeeOrderNew.getJqOtherCostsProportion()).append(" / ")
                .append(insFeeOrderNew.getJqInvestmentCostsProportion()).append(" / ")
                .append(insFeeOrderNew.getJqCostsProportion());
        sumFeeResultVo.setJqFeeRateAll(jqFeeRate.toString());

        //设置交强费用
        StringBuilder jqFeePremium = new StringBuilder();
        jqFeePremium.append(insFeeOrderNew.getJqSuperviseCostsPremiums()).append(" / ")
                .append(insFeeOrderNew.getJqOtherCostsPremiums()).append(" / ")
                .append(insFeeOrderNew.getJqInvestmentCostsPremiums()).append(" / ")
                .append(insFeeOrderNew.getJqCostsPremiums());
        sumFeeResultVo.setJqFeeAmountAll(jqFeePremium.toString());

        //设置商业费用比例
        StringBuilder syFeeRate = new StringBuilder();
        syFeeRate.append(insFeeOrderNew.getSySuperviseCostsProportion()).append(" / ")
                .append(insFeeOrderNew.getSyOtherCostsProportion()).append(" / ")
                .append(insFeeOrderNew.getSyInvestmentCostsProportion()).append(" / ")
                .append(insFeeOrderNew.getSyCostsProportion());
        sumFeeResultVo.setSyFeeRateAll(syFeeRate.toString());

        //设置商业费用
        StringBuilder syFeePremium = new StringBuilder();
        syFeePremium.append(insFeeOrderNew.getSySuperviseCostsPremiums()).append(" / ")
            .append(insFeeOrderNew.getSyOtherCostsPremiums()).append(" / ")
            .append(insFeeOrderNew.getSyInvestmentCostsPremiums()).append(" / ")
            .append(insFeeOrderNew.getSyCostsPremiums());
        sumFeeResultVo.setSyFeeAmountAll(syFeePremium.toString());

        //设置非车费用比例
        StringBuilder noFeeRate = new StringBuilder();
        noFeeRate.append(insFeeOrderNew.getNoSuperviseCostsProportion()).append(" / ")
                .append(insFeeOrderNew.getNoOtherCostsProportion()).append(" / ")
                .append(insFeeOrderNew.getNoCostsProportion());
        sumFeeResultVo.setFcFeeRateAll(noFeeRate.toString());

        //设置非车费用
        StringBuilder noFeePremium = new StringBuilder();
        noFeePremium.append(insFeeOrderNew.getNoSuperviseCostsPremiums()).append(" / ")
                .append(insFeeOrderNew.getNoOtherCostsPremiums()).append(" / ")
                .append(insFeeOrderNew.getNoCostsPremiums());
        sumFeeResultVo.setFcFeeAmountAll(noFeePremium.toString());

        queryOrderFeeResultVos.add(sumFeeResultVo);

        //设置一级管理费
        QueryOrderFeeResultVo jqml1FeeResultVo = new QueryOrderFeeResultVo();
        jqml1FeeResultVo.setDescSerialNo("2");
        jqml1FeeResultVo.setFeeTypeName("一级管理费");
        jqml1FeeResultVo.setJqFeeRateAll(insFeeOrderNew.getJqDeptProportionLevel1().toString());
        jqml1FeeResultVo.setJqFeeAmountAll(insFeeOrderNew.getJqDeptPremiumsLevel1().toString());
        jqml1FeeResultVo.setSyFeeRateAll(insFeeOrderNew.getSyDeptProportionLevel1().toString());
        jqml1FeeResultVo.setSyFeeAmountAll(insFeeOrderNew.getSyDeptPremiumsLevel1().toString());
        jqml1FeeResultVo.setFcFeeRateAll(insFeeOrderNew.getNoDeptProportionLevel1().toString());
        jqml1FeeResultVo.setFcFeeAmountAll(insFeeOrderNew.getNoDeptPremiumsLevel1().toString());
        queryOrderFeeResultVos.add(jqml1FeeResultVo);

        //设置二级管理费
        QueryOrderFeeResultVo jqml2FeeResultVo = new QueryOrderFeeResultVo();
        jqml2FeeResultVo.setDescSerialNo("3");
        jqml2FeeResultVo.setFeeTypeName("二级管理费");
        jqml2FeeResultVo.setJqFeeRateAll(insFeeOrderNew.getJqDeptProportionLevel2().toString());
        jqml2FeeResultVo.setJqFeeAmountAll(insFeeOrderNew.getJqDeptPremiumsLevel2().toString());
        jqml2FeeResultVo.setSyFeeRateAll(insFeeOrderNew.getSyDeptProportionLevel2().toString());
        jqml2FeeResultVo.setSyFeeAmountAll(insFeeOrderNew.getSyDeptPremiumsLevel2().toString());
        jqml2FeeResultVo.setFcFeeRateAll(insFeeOrderNew.getNoDeptProportionLevel2().toString());
        jqml2FeeResultVo.setFcFeeAmountAll(insFeeOrderNew.getNoDeptPremiumsLevel2().toString());
        queryOrderFeeResultVos.add(jqml2FeeResultVo);

        //设置三级管理费
        QueryOrderFeeResultVo jqml3FeeResultVo = new QueryOrderFeeResultVo();
        jqml3FeeResultVo.setDescSerialNo("4");
        jqml3FeeResultVo.setFeeTypeName("三级管理费");
        jqml3FeeResultVo.setJqFeeRateAll(insFeeOrderNew.getJqDeptProportionLevel3().toString());
        jqml3FeeResultVo.setJqFeeAmountAll(insFeeOrderNew.getJqDeptPremiumsLevel3().toString());
        jqml3FeeResultVo.setSyFeeRateAll(insFeeOrderNew.getSyDeptProportionLevel3().toString());
        jqml3FeeResultVo.setSyFeeAmountAll(insFeeOrderNew.getSyDeptPremiumsLevel3().toString());
        jqml3FeeResultVo.setFcFeeRateAll(insFeeOrderNew.getNoDeptProportionLevel3().toString());
        jqml3FeeResultVo.setFcFeeAmountAll(insFeeOrderNew.getNoDeptPremiumsLevel3().toString());
        queryOrderFeeResultVos.add(jqml3FeeResultVo);

        //设置四级管理费
        QueryOrderFeeResultVo jqml4FeeResultVo = new QueryOrderFeeResultVo();
        jqml4FeeResultVo.setDescSerialNo("5");
        jqml4FeeResultVo.setFeeTypeName("四级管理费");
        jqml4FeeResultVo.setJqFeeRateAll(insFeeOrderNew.getJqDeptProportionLevel4().toString());
        jqml4FeeResultVo.setJqFeeAmountAll(insFeeOrderNew.getJqDeptPremiumsLevel4().toString());
        jqml4FeeResultVo.setSyFeeRateAll(insFeeOrderNew.getSyDeptProportionLevel4().toString());
        jqml4FeeResultVo.setSyFeeAmountAll(insFeeOrderNew.getSyDeptPremiumsLevel4().toString());
        jqml4FeeResultVo.setFcFeeRateAll(insFeeOrderNew.getNoDeptProportionLevel4().toString());
        jqml4FeeResultVo.setFcFeeAmountAll(insFeeOrderNew.getNoDeptPremiumsLevel4().toString());
        queryOrderFeeResultVos.add(jqml4FeeResultVo);

        //设置五级管理费
        QueryOrderFeeResultVo jqml5FeeResultVo = new QueryOrderFeeResultVo();
        jqml5FeeResultVo.setDescSerialNo("6");
        jqml5FeeResultVo.setFeeTypeName("五级管理费");
        jqml5FeeResultVo.setJqFeeRateAll(insFeeOrderNew.getJqDeptProportionLevel5().toString());
        jqml5FeeResultVo.setJqFeeAmountAll(insFeeOrderNew.getJqDeptPremiumsLevel5().toString());
        jqml5FeeResultVo.setSyFeeRateAll(insFeeOrderNew.getSyDeptProportionLevel5().toString());
        jqml5FeeResultVo.setSyFeeAmountAll(insFeeOrderNew.getSyDeptPremiumsLevel5().toString());
        jqml5FeeResultVo.setFcFeeRateAll(insFeeOrderNew.getNoDeptProportionLevel5().toString());
        jqml5FeeResultVo.setFcFeeAmountAll(insFeeOrderNew.getNoDeptPremiumsLevel5().toString());
        queryOrderFeeResultVos.add(jqml5FeeResultVo);

        //设置一级分销费用
        QueryOrderFeeResultVo detailLevel1FeeResultVo = new QueryOrderFeeResultVo();
        detailLevel1FeeResultVo.setDescSerialNo("7");
        detailLevel1FeeResultVo.setFeeTypeName("一级分销费");
         detailLevel1FeeResultVo.setJqFeeRateAll(insFeeOrderNew.getFirstDetailProportion().toString());
        detailLevel1FeeResultVo.setSyFeeRateAll(insFeeOrderNew.getFirstDetailProportion().toString());
        detailLevel1FeeResultVo.setFcFeeRateAll(insFeeOrderNew.getFirstDetailProportion().toString());
        BigDecimal jqDetailFeePremium = insFeeOrderNew.getJqPremium().multiply(insFeeOrderNew.getFirstDetailProportion().divide(new BigDecimal("100")));
        detailLevel1FeeResultVo.setJqFeeAmountAll(jqDetailFeePremium.setScale(2,BigDecimal.ROUND_DOWN).toString());
        BigDecimal syDetailFeePremium = insFeeOrderNew.getSyPremium().multiply(insFeeOrderNew.getFirstDetailProportion().divide(new BigDecimal("100")));
        detailLevel1FeeResultVo.setSyFeeAmountAll(syDetailFeePremium.setScale(2,BigDecimal.ROUND_DOWN).toString());
        BigDecimal fcDetailFeePremium = insFeeOrderNew.getNoPremium().multiply(insFeeOrderNew.getFirstDetailProportion().divide(new BigDecimal("100")));
        detailLevel1FeeResultVo.setFcFeeAmountAll(fcDetailFeePremium.setScale(2,BigDecimal.ROUND_DOWN).toString());
        queryOrderFeeResultVos.add(detailLevel1FeeResultVo);

        //设置二级分销费用
        QueryOrderFeeResultVo detailLevel2FeeResultVo = new QueryOrderFeeResultVo();
        detailLevel2FeeResultVo.setDescSerialNo("8");
        detailLevel2FeeResultVo.setFeeTypeName("二级分销费");
        detailLevel2FeeResultVo.setJqFeeRateAll(insFeeOrderNew.getSecondDetailProportion().toString());
        detailLevel2FeeResultVo.setSyFeeRateAll(insFeeOrderNew.getSecondDetailProportion().toString());
        detailLevel2FeeResultVo.setFcFeeRateAll(insFeeOrderNew.getSecondDetailProportion().toString());
        BigDecimal jqDetailFeePremium2 = insFeeOrderNew.getJqPremium().multiply(insFeeOrderNew.getSecondDetailProportion().divide(new BigDecimal("100")));
        detailLevel2FeeResultVo.setJqFeeAmountAll(jqDetailFeePremium2.setScale(2,BigDecimal.ROUND_DOWN).toString());
        BigDecimal syDetailFeePremium2 = insFeeOrderNew.getSyPremium().multiply(insFeeOrderNew.getSecondDetailProportion().divide(new BigDecimal("100")));
        detailLevel2FeeResultVo.setSyFeeAmountAll(syDetailFeePremium2.setScale(2,BigDecimal.ROUND_DOWN).toString());
        BigDecimal fcDetailFeePremium2 = insFeeOrderNew.getNoPremium().multiply(insFeeOrderNew.getSecondDetailProportion().divide(new BigDecimal("100")));
        detailLevel2FeeResultVo.setFcFeeAmountAll(fcDetailFeePremium2.setScale(2,BigDecimal.ROUND_DOWN).toString());
        queryOrderFeeResultVos.add(detailLevel2FeeResultVo);

        //设置三级分销费用
        QueryOrderFeeResultVo detailLevel3FeeResultVo = new QueryOrderFeeResultVo();
        detailLevel3FeeResultVo.setDescSerialNo("9");
        detailLevel3FeeResultVo.setFeeTypeName("三级分销费");
        detailLevel3FeeResultVo.setJqFeeRateAll(insFeeOrderNew.getThirdDetailProportion().toString());
        detailLevel3FeeResultVo.setSyFeeRateAll(insFeeOrderNew.getThirdDetailProportion().toString());
        detailLevel3FeeResultVo.setFcFeeRateAll(insFeeOrderNew.getThirdDetailProportion().toString());
        BigDecimal jqDetailFeePremium3 = insFeeOrderNew.getJqPremium().multiply(insFeeOrderNew.getThirdDetailProportion().divide(new BigDecimal("100")));
        detailLevel3FeeResultVo.setJqFeeAmountAll(jqDetailFeePremium3.setScale(2, BigDecimal.ROUND_DOWN).toString());
        BigDecimal syDetailFeePremium3 = insFeeOrderNew.getSyPremium().multiply(insFeeOrderNew.getThirdDetailProportion().divide(new BigDecimal("100")));
        detailLevel3FeeResultVo.setSyFeeAmountAll(syDetailFeePremium3.setScale(2,BigDecimal.ROUND_DOWN).toString());
        BigDecimal fcDetailFeePremium3 = insFeeOrderNew.getNoPremium().multiply(insFeeOrderNew.getThirdDetailProportion().divide(new BigDecimal("100")));
        detailLevel3FeeResultVo.setFcFeeAmountAll(fcDetailFeePremium3.setScale(2,BigDecimal.ROUND_DOWN).toString());
        queryOrderFeeResultVos.add(detailLevel3FeeResultVo);

            return queryOrderFeeResultVos;
    }

    //把取出的费用信息转换为页面需要展示的数据
//    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 (PtlAgreementUndwrtRules undwrtRules : ptlAgreementUndwrtRulesList) {
                //获取处理后的待校验因子
                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();
    }

    public FeeOrderNewVo newConvertOrderFeeVoData(InsFeeOrderNew insFeeOrderNew) {
        FeeOrderNewVo feeOrderNewVo = new FeeOrderNewVo();
        List<FeeOrderNewVo.EntranceFee> entranceFeeList = new ArrayList<>();
        List<FeeOrderNewVo.ExportFee> exportFeeList = new ArrayList<>();
        List<FeeOrderNewVo.DeptManagerFee> deptManagerFeeList = new ArrayList<>();

        FeeOrderNewVo.EntranceFee jqEntranceFee = new FeeOrderNewVo.EntranceFee();
        FeeOrderNewVo.ExportFee jqExportFee = new  FeeOrderNewVo.ExportFee();
        FeeOrderNewVo.DeptManagerFee jqDeptManagerFee = new FeeOrderNewVo.DeptManagerFee();

        FeeOrderNewVo.EntranceFee syEntranceFee = new FeeOrderNewVo.EntranceFee();
        FeeOrderNewVo.ExportFee syExportFee = new  FeeOrderNewVo.ExportFee();
        FeeOrderNewVo.DeptManagerFee syDeptManagerFee = new FeeOrderNewVo.DeptManagerFee();

        FeeOrderNewVo.EntranceFee nonEntranceFee = new FeeOrderNewVo.EntranceFee();
        FeeOrderNewVo.ExportFee nonExportFee = new  FeeOrderNewVo.ExportFee();
        FeeOrderNewVo.DeptManagerFee nonDeptManagerFee = new FeeOrderNewVo.DeptManagerFee();

        //入口费用
        jqEntranceFee.setInsuranceType("交强险");  // 险种
        jqEntranceFee.setPremium(insFeeOrderNew.getJqPremium());  //保费
        jqEntranceFee.setTotalAmount(insFeeOrderNew.getJqCostsPremiums());   //总费用
        jqEntranceFee.setTotalProportion(insFeeOrderNew.getJqCostsProportion()); //总比例
        jqEntranceFee.setSySuperviseCostsPremiums(insFeeOrderNew.getJqSuperviseCostsPremiums());   //手续费
        jqEntranceFee.setOtherCostsProportion(insFeeOrderNew.getJqOtherCostsProportion());   // 跟单比例
        jqEntranceFee.setOtherCostsPremiums(insFeeOrderNew.getJqOtherCostsPremiums());      // 跟单费
        jqEntranceFee.setSuperviseCosts(insFeeOrderNew.getJqSuperviseCostsProportion());  // 手续费比例
        entranceFeeList.add(jqEntranceFee);


        // 机构管理费
        jqDeptManagerFee.setInsuranceType("交强险");
        jqDeptManagerFee.setDeptProportionLevelOne(insFeeOrderNew.getJqDeptProportionLevel1());
        jqDeptManagerFee.setDeptPremiumsLevelOne(insFeeOrderNew.getJqDeptPremiumsLevel1());
        jqDeptManagerFee.setDeptProportionLevelTwo(insFeeOrderNew.getJqDeptProportionLevel2());
        jqDeptManagerFee.setDeptPremiumsLevelTwo(insFeeOrderNew.getJqDeptPremiumsLevel2());
        jqDeptManagerFee.setDeptProportionLevelThree(insFeeOrderNew.getJqDeptProportionLevel3());
        jqDeptManagerFee.setDeptPremiumsLevelThree(insFeeOrderNew.getJqDeptPremiumsLevel3());
        jqDeptManagerFee.setDeptProportionLevelFoure(insFeeOrderNew.getJqDeptProportionLevel4());
        jqDeptManagerFee.setDeptPremiumsLevelFoure(insFeeOrderNew.getJqDeptPremiumsLevel4());
        jqDeptManagerFee.setDeptProportionLevelFive(insFeeOrderNew.getJqDeptProportionLevel5());
        jqDeptManagerFee.setDeptPremiumsLevelFive(insFeeOrderNew.getJqDeptPremiumsLevel5());
        deptManagerFeeList.add(jqDeptManagerFee);

        //出口费用
        jqExportFee.setInsuranceType("交强险");  // 险种
        BigDecimal sumJqDeptProportion = insFeeOrderNew.getJqDeptProportionLevel1()
                .add(insFeeOrderNew.getJqDeptProportionLevel2())
                .add(insFeeOrderNew.getJqDeptProportionLevel3())
                .add(insFeeOrderNew.getJqDeptProportionLevel4())
                .add(insFeeOrderNew.getJqDeptProportionLevel5());

        //交强总出口费比例
        BigDecimal jqExportTotalProportion = jqEntranceFee.getTotalProportion().subtract(sumJqDeptProportion);

        //交强出口手续费比例
        BigDecimal jqExportSuperviseCosts =
                jqExportTotalProportion.compareTo(jqEntranceFee.getSuperviseCosts()) > 0 ? jqEntranceFee.getSuperviseCosts() : jqExportTotalProportion;

        //交强出口其他费比例
        BigDecimal jqOtherCostsProportion =
                jqExportTotalProportion.compareTo(jqEntranceFee.getSuperviseCosts()) > 0 ? jqExportTotalProportion.subtract(jqExportSuperviseCosts) : new BigDecimal(0);

        jqExportFee.setSuperviseCosts(jqExportSuperviseCosts);
        jqExportFee.setSuperviseCostsPremiums(insFeeOrderNew.getJqPremium().multiply(jqExportSuperviseCosts.divide(new BigDecimal(100))).setScale(2,BigDecimal.ROUND_DOWN));
        jqExportFee.setOtherCostsProportion(jqOtherCostsProportion);
        jqExportFee.setOtherCostsPremiums(insFeeOrderNew.getJqPremium().multiply(jqOtherCostsProportion.divide(new BigDecimal(100))).setScale(2,BigDecimal.ROUND_DOWN));
        jqExportFee.setTotalProportion(jqExportFee.getSuperviseCosts().add(jqExportFee.getOtherCostsProportion()));
        jqExportFee.setTotalAmount(jqExportFee.getSuperviseCostsPremiums().add(jqExportFee.getOtherCostsPremiums()));
        exportFeeList.add(jqExportFee);




        //商业入口
        syEntranceFee.setInsuranceType("商业险");  // 险种
        syEntranceFee.setPremium(insFeeOrderNew.getSyPremium());  //保费
        syEntranceFee.setTotalProportion(insFeeOrderNew.getSyCostsProportion()); //总保费
        syEntranceFee.setTotalAmount(insFeeOrderNew.getSyCostsPremiums());   //总费用
        syEntranceFee.setSySuperviseCostsPremiums(insFeeOrderNew.getSySuperviseCostsPremiums());   //手续费
        syEntranceFee.setOtherCostsProportion(insFeeOrderNew.getSyOtherCostsProportion());   // 跟单比例
        syEntranceFee.setOtherCostsPremiums(insFeeOrderNew.getSyOtherCostsPremiums());      // 跟单费
        syEntranceFee.setSuperviseCosts(insFeeOrderNew.getSySuperviseCostsProportion());  // 手续费比例
        entranceFeeList.add(syEntranceFee);

        // 商业管理费
        syDeptManagerFee.setInsuranceType("商业险");
        syDeptManagerFee.setDeptProportionLevelOne(insFeeOrderNew.getSyDeptProportionLevel1());
        syDeptManagerFee.setDeptPremiumsLevelOne(insFeeOrderNew.getSyDeptPremiumsLevel1());
        syDeptManagerFee.setDeptProportionLevelTwo(insFeeOrderNew.getSyDeptProportionLevel2());
        syDeptManagerFee.setDeptPremiumsLevelTwo(insFeeOrderNew.getSyDeptPremiumsLevel2());
        syDeptManagerFee.setDeptProportionLevelThree(insFeeOrderNew.getSyDeptProportionLevel3());
        syDeptManagerFee.setDeptPremiumsLevelThree(insFeeOrderNew.getSyDeptPremiumsLevel3());
        syDeptManagerFee.setDeptProportionLevelFoure(insFeeOrderNew.getSyDeptProportionLevel4());
        syDeptManagerFee.setDeptPremiumsLevelFoure(insFeeOrderNew.getSyDeptPremiumsLevel4());
        syDeptManagerFee.setDeptProportionLevelFive(insFeeOrderNew.getSyDeptProportionLevel5());
        syDeptManagerFee.setDeptPremiumsLevelFive(insFeeOrderNew.getSyDeptPremiumsLevel5());
        deptManagerFeeList.add(syDeptManagerFee);

        //商业出口
        syExportFee.setInsuranceType("商业险");  // 险种
        BigDecimal sumSyDeptProportion = insFeeOrderNew.getSyDeptProportionLevel1()
                .add(insFeeOrderNew.getSyDeptProportionLevel2())
                .add(insFeeOrderNew.getSyDeptProportionLevel3())
                .add(insFeeOrderNew.getSyDeptProportionLevel4())
                .add(insFeeOrderNew.getSyDeptProportionLevel5());

        //商业总出口费比例
        BigDecimal syExportTotalProportion = syEntranceFee.getTotalProportion().subtract(sumSyDeptProportion);

        //商业出口手续费比例
        BigDecimal syExportSuperviseCosts =
                syExportTotalProportion.compareTo(syEntranceFee.getSuperviseCosts()) > 0 ? syEntranceFee.getSuperviseCosts() : syExportTotalProportion;

        //商业出口其他费比例
        BigDecimal syOtherCostsProportion =
                syExportTotalProportion.compareTo(syEntranceFee.getSuperviseCosts()) > 0 ? syExportTotalProportion.subtract(syExportSuperviseCosts) : new BigDecimal(0);

        syExportFee.setSuperviseCosts(syExportSuperviseCosts);
        syExportFee.setSuperviseCostsPremiums(insFeeOrderNew.getSyPremium().multiply(syExportSuperviseCosts.divide(new BigDecimal(100))).setScale(2,BigDecimal.ROUND_DOWN));
        syExportFee.setOtherCostsProportion(syOtherCostsProportion);
        syExportFee.setOtherCostsPremiums(insFeeOrderNew.getSyPremium().multiply(syOtherCostsProportion.divide(new BigDecimal(100))).setScale(2,BigDecimal.ROUND_DOWN));
        syExportFee.setTotalProportion(syExportFee.getSuperviseCosts().add(syExportFee.getOtherCostsProportion()));
        syExportFee.setTotalAmount(syExportFee.getSuperviseCostsPremiums().add(syExportFee.getOtherCostsPremiums()));
        exportFeeList.add(syExportFee);




        //非车入口
        nonEntranceFee.setInsuranceType("非车险");  // 险种
        nonEntranceFee.setPremium(insFeeOrderNew.getNoPremium());  //保费
        nonEntranceFee.setTotalProportion(insFeeOrderNew.getNoCostsProportion()); //总保费
        nonEntranceFee.setTotalAmount(insFeeOrderNew.getNoCostsPremiums());   //总费用
        nonEntranceFee.setSySuperviseCostsPremiums(insFeeOrderNew.getNoSuperviseCostsPremiums());   //手续费
        nonEntranceFee.setOtherCostsProportion(insFeeOrderNew.getNoOtherCostsProportion());   // 跟单比例
        nonEntranceFee.setOtherCostsPremiums(insFeeOrderNew.getNoOtherCostsPremiums());      // 跟单费
        nonEntranceFee.setSuperviseCosts(insFeeOrderNew.getNoSuperviseCostsProportion());  // 手续费比例
        entranceFeeList.add(nonEntranceFee);

        // 五级管理费
        nonDeptManagerFee.setInsuranceType("非车险");
        nonDeptManagerFee.setDeptProportionLevelOne(insFeeOrderNew.getNoDeptProportionLevel1());
        nonDeptManagerFee.setDeptPremiumsLevelOne(insFeeOrderNew.getNoDeptPremiumsLevel1());
        nonDeptManagerFee.setDeptProportionLevelTwo(insFeeOrderNew.getNoDeptProportionLevel2());
        nonDeptManagerFee.setDeptPremiumsLevelTwo(insFeeOrderNew.getNoDeptPremiumsLevel2());
        nonDeptManagerFee.setDeptProportionLevelThree(insFeeOrderNew.getNoDeptProportionLevel3());
        nonDeptManagerFee.setDeptPremiumsLevelThree(insFeeOrderNew.getNoDeptPremiumsLevel3());
        nonDeptManagerFee.setDeptProportionLevelFoure(insFeeOrderNew.getNoDeptProportionLevel4());
        nonDeptManagerFee.setDeptPremiumsLevelFoure(insFeeOrderNew.getNoDeptPremiumsLevel4());
        nonDeptManagerFee.setDeptProportionLevelFive(insFeeOrderNew.getNoDeptProportionLevel5());
        nonDeptManagerFee.setDeptPremiumsLevelFive(insFeeOrderNew.getNoDeptPremiumsLevel5());
        deptManagerFeeList.add(nonDeptManagerFee);


        //出口费用
        nonExportFee.setInsuranceType("非车险");  // 险种
        BigDecimal sumNonDeptProportion = insFeeOrderNew.getNoDeptProportionLevel1()
                .add(insFeeOrderNew.getNoDeptProportionLevel2())
                .add(insFeeOrderNew.getNoDeptProportionLevel3())
                .add(insFeeOrderNew.getNoDeptProportionLevel4())
                .add(insFeeOrderNew.getNoDeptProportionLevel5());

        //非车总出口费比例
        BigDecimal nonExportTotalProportion = nonEntranceFee.getTotalProportion().subtract(sumNonDeptProportion);

        //非车出口手续费比例
        BigDecimal nonExportSuperviseCosts =
                nonExportTotalProportion.compareTo(nonEntranceFee.getSuperviseCosts()) > 0 ? nonEntranceFee.getSuperviseCosts() : nonExportTotalProportion;

        //非车出口其他费比例
        BigDecimal nonOtherCostsProportion =
                nonExportTotalProportion.compareTo(nonEntranceFee.getSuperviseCosts()) > 0 ? nonExportTotalProportion.subtract(nonExportSuperviseCosts) : new BigDecimal(0);

        nonExportFee.setSuperviseCosts(nonExportSuperviseCosts);
        nonExportFee.setSuperviseCostsPremiums(insFeeOrderNew.getNoPremium().multiply(nonExportSuperviseCosts.divide(new BigDecimal(100))).setScale(2,BigDecimal.ROUND_DOWN));
        nonExportFee.setOtherCostsProportion(nonOtherCostsProportion);
        nonExportFee.setOtherCostsPremiums(insFeeOrderNew.getNoPremium().multiply(nonOtherCostsProportion.divide(new BigDecimal(100))).setScale(2,BigDecimal.ROUND_DOWN));
        nonExportFee.setTotalProportion(nonExportFee.getSuperviseCosts().add(nonExportFee.getOtherCostsProportion()));
        nonExportFee.setTotalAmount(nonExportFee.getSuperviseCostsPremiums().add(nonExportFee.getOtherCostsPremiums()));
        exportFeeList.add(nonExportFee);

        feeOrderNewVo.setEntranceFee(entranceFeeList);
        feeOrderNewVo.setExportFee(exportFeeList);
        feeOrderNewVo.setDeptManagerFee(deptManagerFeeList);
        return feeOrderNewVo;
    }

    public List<DistributionLevelVo> converDistrbutionData(InsFeeOrderNew insFeeOrderNew) {
        ArrayList<DistributionLevelVo> resultList = new ArrayList<>();
        DistributionLevelVo  levelOne  =  new DistributionLevelVo();
        levelOne.setDistributionLevel("一级分销");
        String oneUserName=  this.getUserName(insFeeOrderNew.getFirstLevelUserId());
        levelOne.setUserName(oneUserName);  //分销人
        levelOne.setDistributionRatio(insFeeOrderNew.getFirstDetailProportion());  // 分销比例
        levelOne.setAmount(insFeeOrderNew.getFirstDetailPremiums());   // 分销金额
        resultList.add(levelOne);


        DistributionLevelVo levelTwo = new DistributionLevelVo();
        levelTwo.setDistributionLevel("二级分销");
        String twoUserName=  this.getUserName(insFeeOrderNew.getTwoLevelUserId());
        levelTwo.setUserName(twoUserName);  //分销人
        levelTwo.setDistributionRatio(insFeeOrderNew.getSecondDetailProportion());  // 分销比例
        levelTwo.setAmount(insFeeOrderNew.getSecondDetailPremiums());   // 分销金额
        resultList.add(levelTwo);


        DistributionLevelVo levelThree = new DistributionLevelVo();
        levelThree.setDistributionLevel("三级分销");
        String threeUserName=  this.getUserName(insFeeOrderNew.getThreeLevelUserId());
        levelThree.setUserName(threeUserName);  //分销人
        levelThree.setDistributionRatio(insFeeOrderNew.getThirdDetailProportion());  // 分销比例
        levelThree.setAmount(insFeeOrderNew.getThirdDetailPremiums());   // 分销金额
        resultList.add(levelThree);
        return resultList;
    }

    private String getUserName(String firstLevelUserId) {
        if(StringUtils.isNotEmpty(firstLevelUserId)){
            SysUser sysUser = sysUserService.getBaseMapper().selectById(firstLevelUserId);
            if(ObjectUtils.isNotEmpty(sysUser)){
                return sysUser.getName() + "(" + sysUser.getId() + ")";
            }
        }
        return null;
    }
}