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 = ptlAgreementProductCostsService.selectVliadFeeFactor(feeSchemeReqDto.getBusType(), feeSchemeReqDto.getAgreementId()); if (ptlAgreementProductCosts.isEmpty()) { //如果查询不到费用方案信息，则阻断算费流程，进行提示 throw new SystemException("未查询到费用配置，请先配置该协议的费用方案！"); } else { //符合跟单信息的方案列表 List validSchemeList = new ArrayList(); //循环符合的方案列表，再进行细化的因子匹配，获取最终可以匹配到的方案 for (int i = 0; i < ptlAgreementProductCosts.size(); i++) { PtlAgreementProductCosts factorCost = ptlAgreementProductCosts.get(i); //获取处理后的待校验因子 Map 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 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 factorToBeVerified, String productId) { boolean result = false; //默认没有匹配到 boolean isConfigFactor = false;//是否配置了因子校验项 默认否 String[] matchKeys = matchKeyStr.split(","); //循环待校验因子列表 for (Map.Entry 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 getFactorToBeVerified(PtlAgreementProductCosts factorCost) { Map 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 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 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 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 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 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 getCostsPremiumsAll(InsFeeOrder insFeeOrder) { HashMap 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 convertOrderFeeVoData(InsFeeOrderNew insFeeOrderNew){ List 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 convertOrderFeeVoData(QueryOrderFeeVo orderFeeVo) { // List 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 ptlAgreementUndwrtRulesList = ptlAgreementUndwrtRulesService.selectVliadRules(feeSchemeReqDto.getAgreementId()); if (ptlAgreementUndwrtRulesList.isEmpty()) { //没有有效的核保规则，直接抛出 return; } else { //循环有效的规则列表，进行因子匹配，抛出匹配到的因子项 for (PtlAgreementUndwrtRules undwrtRules : ptlAgreementUndwrtRulesList) { //获取处理后的待校验因子 Map 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 getFactorToBeVerifiedForRules(PtlAgreementUndwrtRules rulesFactor) { Map 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 entranceFeeList = new ArrayList<>(); List exportFeeList = new ArrayList<>(); List 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 sumRetail = new BigDecimal(0); if(insFeeOrderNew.getFirstDetailProportion().compareTo(new BigDecimal(0)) > 0){ sumRetail = sumRetail.add(insFeeOrderNew.getFirstDetailProportion()); } if(insFeeOrderNew.getSecondDetailProportion().compareTo(new BigDecimal(0)) > 0){ sumRetail = sumRetail.add(insFeeOrderNew.getSecondDetailProportion()); } if(insFeeOrderNew.getThirdDetailProportion().compareTo(new BigDecimal(0)) > 0){ sumRetail = sumRetail.add(insFeeOrderNew.getThirdDetailProportion()); } //交强总出口费比例 BigDecimal jqExportTotalProportion = jqEntranceFee.getTotalProportion().subtract(sumJqDeptProportion).subtract(sumRetail); //交强出口手续费比例 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 = new BigDecimal(0); if(syEntranceFee.getTotalProportion().compareTo(new BigDecimal(0)) > 0) { syExportTotalProportion = syEntranceFee.getTotalProportion().subtract(sumSyDeptProportion).subtract(sumRetail); } //商业出口手续费比例 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 = new BigDecimal(0); if(nonEntranceFee.getTotalProportion().compareTo(new BigDecimal(0)) > 0) { nonExportTotalProportion = nonEntranceFee.getTotalProportion().subtract(sumSyDeptProportion).subtract(sumRetail); } //非车出口手续费比例 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 converDistrbutionData(InsFeeOrderNew insFeeOrderNew) { ArrayList 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; } }