liebao-cloud/lb-app/src/main/java/com/ydd/app/service/impl/ApiOrderValuationServiceImpl.java

package com.ydd.app.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ydd.api.DeliveryService;
import com.ydd.app.OrderEntityUtils;
import com.ydd.app.QueryAmountEntityUtils;
import com.ydd.app.dto.AddressReq;
import com.ydd.app.dto.OrderReq;
import com.ydd.app.dto.ValuationRes;
import com.ydd.app.dto.ValuationResultData;
import com.ydd.app.service.ApiDadaValuationService;
import com.ydd.app.service.ApiOrderValuationService;
import com.ydd.app.service.ApiProductService;
import com.ydd.common.constant.BillingConstant;
import com.ydd.common.enums.DeliveryTypeEnums;
import com.ydd.common.utils.DateUtils;
import com.ydd.common.utils.SnCodeUtils;
import com.ydd.common.utils.StringUtils;
import com.ydd.ecloud.core.utils.BigDecimalUtils;
import com.ydd.ecloud.core.utils.JsonMapper;
import com.ydd.module.domain.*;
import com.ydd.module.dto.*;
import com.ydd.module.enums.*;
import com.ydd.module.expection.CustomAppException;
import com.ydd.module.service.*;
import com.ydd.module.utils.CommonUtils;
import com.ydd.system.domain.SysConfig;
import com.ydd.system.service.ISysConfigService;
import com.ydd.third.common.config.DeliveryConfig;
import com.ydd.third.common.utils.CoordinateUtils;
import com.ydd.third.common.vo.ResObject;
import com.ydd.third.common.vo.shop.AmountResultVo;
import com.ydd.third.common.vo.shop.QueryAmount;
import com.ydd.third.common.vo.vo.order.OrderResultVo;
import com.ydd.third.common.vo.vo.order.OrderVo;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.compress.utils.Lists;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author 叶君翔
 * @date 2021/11/12 11:20
 */
@Slf4j
@Service
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class ApiOrderValuationServiceImpl implements ApiOrderValuationService {

    private final ApiProductService apiProductService;

    private final IOrderService iOrderService;

    private final IMemberService iMemberService;
    private final IMerchantService iMerchantService;
    private final IDadaDspService iDadaDspService;

    private final DeliveryService client;

    private final IDspDeliveryService iDspDeliveryService;

    private final IWaimaiOrderDetailService iWaimaiOrderDetailService;

    private final IWaimaiOrderService iWaimaiOrderService;

    private final IDspWaimaiService iDspWaimaiService;

    private final DeliveryConfig deliveryConfig;

    private final IMemberConfigService iMemberConfigService;

    private final ISysConfigService iSysConfigService;

    private final IShopDeliveryService iShopDeliveryService;
    private final IShopDeliveryBindService iShopDeliveryBindService;

    private final IShopService iShopService;
    private final IShopWaimaiService iShopWaimaiService;

    private final IPackageDiscountDetailService iPackageDiscountDetailService;
    private final IPackageCommissionDetailService iPackageCommissionDetailService;
    private final IPackageDeliveryService iPackageDeliveryService;
    private final IPackageCityConfigService iPackageCityConfigService;
    private final ApiDadaValuationService dadaValuationService;

    @Override
    public ValuationResultData orderValuation(Member member, OrderReq orderReq, Integer type) {
        log.info("<===========>订单计价参数: loginId:{}, type: {}, orderReq: {} ", member.getId(), type, JsonMapper.nonEmptyMapper().toJson(orderReq));
        try {
            Member loginMember = member;
            if (member.getMemberType().equals(MemberTypeEnum.SHOP.type)) {
                member = iMemberService.getOne(new QueryWrapper<Member>().eq("member_type", MemberTypeEnum.MERCHANT.type).eq("merchant_id", member.getMerchantId()));
            }
            AddressReq sendAddress = orderReq.getSendAddress();
            AddressReq receiveAddress = orderReq.getReceiptAddress();
            if (sendAddress == null || receiveAddress == null) {
                throw new CustomAppException(ExceptionEnum.ADDRESS_NOT_EXISTS);
            }
            Product product = apiProductService.findById(orderReq.getProductId());
            if (product == null) {
                throw new CustomAppException(ExceptionEnum.PRODUCT_NOT_EXISTS);
            }
            Long shopId = orderReq.getShopId();
            // 计价类型 0-普通计价 1-达达收付配送商计价 2-达达非收付配送商计价
            int valuationType = 0;
            Long dadaDspId = null;
            if (member.getMerchantId() != null) {
                Merchant merchant = iMerchantService.getById(member.getMerchantId());
                if (merchant != null && merchant.getDadaDspId() != null) {
                    DadaDsp dadaDsp = iDadaDspService.getById(merchant.getDadaDspId());
                    if (dadaDsp != null) {
                        dadaDspId = dadaDsp.getId();
                        if (DadaDspRoleEnum.SELF_DELIVERY.type.equals(dadaDsp.getDspRole())) {
                            valuationType = 2;
                        } else {
                            valuationType = 1;
                        }
                    }
                }
            }
            orderReq.setOrderNo(SnCodeUtils.createSn());
            String takeRemark = "";
            if (orderReq.getOrderId() != null) {
                orderReq.setShopId(null);
                Order order = iOrderService.getById(orderReq.getOrderId());
                orderReq.setWaimaiOrderId(order.getWaimaiOrderId());
                if (order.getDeliveryStatus() >= DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status && !DeliveryStatusEnum.FINISH.status.equals(order.getDeliveryStatus())) {
                    log.info("该配送状态的订单不支持计价操作, orderId: {}, deliveryStatus: {}", order.getId(), order.getDeliveryStatus());
                    return null;
                }
                // 非再来一单
                if (!DeliveryStatusEnum.CANCEL.status.equals(order.getDeliveryStatus())
                        && !DeliveryStatusEnum.FINISH.status.equals(order.getDeliveryStatus())
                        && !DeliveryStatusEnum.ABNORMAL.status.equals(order.getDeliveryStatus())) {
                    orderReq.setOrderNo(order.getOrderSn());
                }
                shopId = order.getShopId();
                takeRemark = order.getTakeRemark();
            }
            // 0-门店发单 1-非门店发单 在商户所属门店附近100米使用个人地址发单，也按照门店发单处理
            int defaultShop = 0;
            if (loginMember.getShopId() != null && orderReq.getShopId() == null) {
                List<Shop> shops = Lists.newArrayList();
                if (member.getMemberType().equals(MemberTypeEnum.SHOP.type)) {
                    Shop shop = iShopService.getById(loginMember.getShopId());
                    shops.add(shop);
                } else {
                    shops = iShopService.list(new QueryWrapper<Shop>()
                            .eq("merchant_id", loginMember.getMerchantId())
                            .eq("deleted", 0)
                            .eq("status", 1));
                }
                int num = 0;
                for (Shop shop : shops) {
                    double distance = CoordinateUtils.getDistance(Double.parseDouble(sendAddress.getLng()), Double.parseDouble(sendAddress.getLat()), Double.parseDouble(shop.getLng()), Double.parseDouble(shop.getLat()));
                    if (distance > BillingConstant.SHOP_BILLING_DISTANCE) { //暂定小于一百米 是门店发单
                        num ++;
                    } else {
                        // 个人发单,发件地址附近100米内的门店作为发单门店
                        shopId = shop.getId();
                    }
                }
                if (num == shops.size()) {
                    defaultShop = 1;
                }
            }

            if (StringUtils.isNotBlank(orderReq.getTakeTime()) && DateUtils.addHours(new Date(), 2).compareTo(DateUtils.dateTime(DateUtils.YYYY_MM_DD_HH_MM_SS, orderReq.getTakeTime())) > 0) {
                orderReq.setTakeTime("");
                orderReq.setTakeType(0);
            }
            List<WaimaiOrderDetail> waiMaiOrderDetails = new ArrayList<>();
            orderReq.setWaimaiOrderDetails(waiMaiOrderDetails);
            if (orderReq.getWaimaiOrderId() != null) {
                // 设置外卖单相关信息
                shopId = this.setWaimaiOrderInfo(orderReq, takeRemark, shopId);
            } else {
                // 普通单设置订单来源以及流水号
                this.setOrderSource(orderReq);
            }
            orderReq.setProduct(product);
            ValuationRes res;
            if (valuationType == 0) {
                res = this.normalValuation(shopId, loginMember, member, defaultShop, orderReq, type);
                return ValuationResultData.success(res);
            } else {
                return dadaValuationService.dadaValuation(shopId, loginMember, member, orderReq, valuationType, dadaDspId);
            }
        } catch (Exception e) {
            log.error("发起计价异常", e);
            return null;
        }
    }

    private void setOrderSource(OrderReq orderReq) {
        Integer platformType = orderReq.getPlatformType();
        if (platformType != null && platformType > 0) {
            orderReq.setPoiSeq(orderReq.getDaySeq());
            // 美团、美团闪购
            if (platformType == 1 || platformType == 5) {
                orderReq.setOrderSource("101");
            } else if (platformType == 2) {
                // 饿了么
                orderReq.setOrderSource("102");
            } else if (platformType == 3) {
                // 饿百零售
                orderReq.setOrderSource("103");
            }else if (platformType == 6) {
            // 京东到家
            orderReq.setOrderSource("104");
            }
        }
    }

    // 普通计价模式
    private ValuationRes normalValuation(Long shopId, Member loginMember, Member member, Integer defaultShop, OrderReq orderReq, Integer type) {
        ValuationRes res = new ValuationRes();
        List<ValuationRes> list = new ArrayList<>();
        List<ValuationRes> supports = new ArrayList<>();
        // 门店用户使用首页个人发单, 则使用用户默认的shopId进行包查询
        Long packageShopId = shopId == null ? loginMember.getShopId() : shopId;

        // 获取最匹配的运力包(门店 > 城市 > 全国)
        Long deliveryPackageId = iPackageCityConfigService.getPackageId(packageShopId, loginMember, orderReq.getSendAddress().getCityCode(), PackageCityConfigPackageTypeEnum.DELIVERY.type);
        List<Integer> types = Lists.newArrayList();
        PackageDeliveryDto packageDeliveryDto = null;
        if (deliveryPackageId != null) {
            packageDeliveryDto = iPackageDeliveryService.getDeliveryDtoByPackageIdAndDeliveryType(deliveryPackageId);
            List<PackageDeliveryDetailDto> deliveryDetailDtoList = packageDeliveryDto.getPackageDeliveryDetailDtoList();
            if (CollectionUtils.isNotEmpty(deliveryDetailDtoList)) {
                types = deliveryDetailDtoList.stream().map(PackageDeliveryDetailDto::getDeliveryType).collect(Collectors.toList());
            }
        }
        List<DeliveryInfo> deliveryInfos = iDspDeliveryService.findList(loginMember, shopId, orderReq.getTransport(), types, defaultShop);
        if (CollectionUtils.isEmpty(deliveryInfos)) {
            log.warn("无可用发单运力！");
            return res;
        }
        if (shopId != null) {
            Shop shop = iShopService.getById(shopId);
            orderReq.setShopName(shop.getName());
        }

        List<Integer> deliveryTypes = deliveryInfos.stream().map(DspDelivery::getType).collect(Collectors.toList());
        // 获取最匹配的优惠包(门店 > 代理商 > 全国)
        Long discountPackageId = iPackageCityConfigService.getPackageId(packageShopId, loginMember, orderReq.getSendAddress().getCityCode(), PackageCityConfigPackageTypeEnum.DISCOUNT.type);
        Map<Integer, List<PackageDiscountDetailDto>> packageDiscountMap = new HashMap<>();
        if (discountPackageId != null) {
            List<PackageDiscountDetailDto> discountDetailDtoList = iPackageDiscountDetailService.getDiscountListByPackageIdAndDeliveryType(discountPackageId, deliveryTypes);
            packageDiscountMap = discountDetailDtoList.stream().collect(Collectors.groupingBy(PackageDiscountDetailDto::getDeliveryType));
        }
        // 获取最匹配的佣金包(门店 > 代理商 > 全国)
        Long commissionPackageId = iPackageCityConfigService.getPackageId(packageShopId, loginMember, orderReq.getSendAddress().getCityCode(), PackageCityConfigPackageTypeEnum.COMMISSION.type);
        Map<Integer, List<PackageCommissionDetailDto>> packageCommissionMap = new HashMap<>();
        if (commissionPackageId != null) {
            List<PackageCommissionDetailDto> commissionDetailDtoList = iPackageCommissionDetailService.getCommissionListByPackageIdAndDeliveryType(commissionPackageId, deliveryTypes);
            packageCommissionMap = commissionDetailDtoList.stream().collect(Collectors.groupingBy(PackageCommissionDetailDto::getDeliveryType));
        }
        // type = 2为自动配送, 等APP改版后可以拿掉
        if (type == 2 && orderReq.getPreDeliveryIds()!=null) {
            List<String> deliveryIds = Arrays.asList(orderReq.getPreDeliveryIds().split(","));
            deliveryInfos = deliveryInfos.stream().filter(a -> deliveryIds.contains(a.getId().toString())).collect(Collectors.toList());
            log.info("<===========>计价运力" + JsonMapper.nonEmptyMapper().toJson(deliveryInfos));
        }
        log.info("运力包: {}, 优惠包:{}, 佣金包: {}", deliveryPackageId, discountPackageId, commissionPackageId);
        for (DeliveryInfo info : deliveryInfos) {
            // 计价
            ValuationRes valuationRes = this.queryOrderDeliverFee(orderReq, info, member.getMerchantId(), shopId, defaultShop);
            if (valuationRes == null) {
                continue;
            }
            valuationRes.setPreferredDelivery(info.getPreferredDelivery());
            valuationRes.setOriginalMoney(valuationRes.getDeliveryAmount());
            // 设置排序
            if (packageDeliveryDto != null && PackageDeliveryTypeEnum.CUSTOM.type.equals(packageDeliveryDto.getType())) {
                this.setBillingSort(packageDeliveryDto, valuationRes);
            }
            // 设置优惠
            if (packageDiscountMap.size() > 0) {
                this.setDiscountInfo(packageDiscountMap.get(info.getType()), valuationRes);
            }
            // 设置佣金
            if (packageCommissionMap.size() > 0) {
                this.setCommissionInfo(packageCommissionMap.get(info.getType()), valuationRes);
            }
            valuationRes.setIsMerchant(info.getIsMerchant());
            if (valuationRes.getIsMine() == 0) {
                // 校验余额是否充足
                if (member.getAmount().compareTo(valuationRes.getDeliveryAmount()) >= 0) {
                    valuationRes.setIsEnough(StatusEnum.SHOW.status);
                }
            }
            list.add(valuationRes);
        }

        // 默认价格优先
        list.sort(Comparator.comparing(ValuationRes::getDeliveryAmount));
        // Res数据组装
        this.setValuationRes(list, res, loginMember, orderReq.getTransport());
        // 运力包发单类型为自定义, 则先按照sort排，再按价格排
        if (packageDeliveryDto != null && PackageDeliveryTypeEnum.CUSTOM.type.equals(packageDeliveryDto.getType())) {
            Collections.sort(list);
        }

        // 处理发单运力
        List<ValuationRes> billList = this.handleBillList(loginMember.getId(), list);
        // 设置发单时长
        if (packageDeliveryDto != null) {
            billList = this.setBillingDuration(packageDeliveryDto, billList);
        }
        res.setOptionals(billList);
        res.setSupports(supports);
        return res;
    }

    private List<ValuationRes> handleBillList(Long loginId, List<ValuationRes> list) {
        // 查询下单设置推荐屏蔽运力
        List<ValuationRes> billList = new ArrayList<>();
        MemberConfig config = iMemberConfigService.getOne(new QueryWrapper<MemberConfig>().eq("member_id",loginId));
        if (config != null) {
            if (StringUtils.isNotEmpty(config.getBillDeliveryIds())) {
                List<String> billDeliveryIds = Arrays.asList(config.getBillDeliveryIds().split(","));
                // 过滤出商家设置的推荐运力, 计价页面靠前显示
                billList = list.stream().filter(a -> billDeliveryIds.contains(a.getDeliveryId().toString())).collect(Collectors.toList());
            }
            if (StringUtils.isNotEmpty(config.getShieldDeliveryIds())) {
                List<String> shieldDeliveryIds = Arrays.asList(config.getShieldDeliveryIds().split(","));
                // 过滤掉商家设置的屏蔽运力
                list = list.stream().filter(a -> !shieldDeliveryIds.contains(a.getDeliveryId().toString())).collect(Collectors.toList());
            }
        }
        list.removeAll(billList);
        billList.addAll(list);

        // 闪送距离替换
        Optional<ValuationRes> optional = billList.stream().filter(item -> !item.getDeliveryType().equals(DeliveryTypeEnums.SHAN_SONG.getType())).findFirst();
        if (optional.isPresent()) {
            String desc = optional.get().getDesc();
            for (ValuationRes res1 : billList) {
                if (DeliveryTypeEnums.SHAN_SONG.getType().equals(res1.getDeliveryType())) {
                    res1.setDesc(desc);
                    break;
                }
            }
        }
        return billList;
    }

    private void setValuationRes(List<ValuationRes> list, ValuationRes res, Member loginMember, Integer transport) {
        // 获取聚合配送的预估价，选最低价格展示
        if (CollectionUtils.isNotEmpty(list)) {
            res.setDeliveryId(list.get(0).getDeliveryId());
            res.setDesc("全网运力推单");
            res.setDeliveryAmount(list.get(0).getDeliveryAmount());
            res.setName("聚合配送");
            res.setIsEnough(list.get(0).getIsEnough());
            res.setLogo("https://ecloud-cdn.51sssd.com/20210317/e24a425797f54f64b808b95beae37285.png");
        }
        // 新用户只要没有产生支付成功的订单数据 算首单 取消新人首单立减
//        int successOrderCount;
//        if (loginMember.getShopId() != null) {
//            successOrderCount = iOrderService.count(new QueryWrapper<Order>().eq("shop_id", loginMember.getShopId()).eq("status", PayStatusEnum.PAYED.status));
//        } else {
//            successOrderCount = iOrderService.count(new QueryWrapper<Order>().eq("member_id", loginMember.getId()).eq("status", PayStatusEnum.PAYED.status));
//        }
//        if (successOrderCount == 0 && transport == 0) {
//            String configValue = iSysConfigService.selectConfigByKey("NEW_COMERS");
//           res.setFirstCoupon(configValue);
//        }
    }

    private void setBillingSort(PackageDeliveryDto packageDeliveryDto, ValuationRes valuationRes) {
        List<PackageDeliveryDetailDto> deliveryDetailDtoList = packageDeliveryDto.getPackageDeliveryDetailDtoList();
        if (CollectionUtils.isNotEmpty(deliveryDetailDtoList)) {
            Optional<PackageDeliveryDetailDto> optional = deliveryDetailDtoList.stream().filter(item -> valuationRes.getDeliveryType().equals(item.getDeliveryType())).findFirst();
            if (optional.isPresent()) {
                PackageDeliveryDetailDto packageDeliveryDetailDto = optional.get();
                valuationRes.setSort((packageDeliveryDetailDto.getSort() == null || packageDeliveryDetailDto.getSort() == 0) ? BillingConstant.DEFAULT_BILL_SORT : packageDeliveryDetailDto.getSort());
            }
        }
    }

    private List<ValuationRes> setBillingDuration(PackageDeliveryDto packageDeliveryDto, List<ValuationRes> billList) {
        String billDurationStr = packageDeliveryDto.getBillDurationStr();
        List<PackageDeliveryDetailDto> deliveryDetailList = packageDeliveryDto.getPackageDeliveryDetailDtoList();
        if (StringUtils.isNotEmpty(billDurationStr) && CollectionUtils.isNotEmpty(deliveryDetailList)) {
            String[] split = billDurationStr.split(",");
            if (PackageDeliveryTypeEnum.CUSTOM.type.equals(packageDeliveryDto.getType())) {
                deliveryDetailList = deliveryDetailList.stream().filter(item -> item.getSort() != null && item.getSort() > 0).collect(Collectors.toList());
                deliveryDetailList.sort(Comparator.comparing(PackageDeliveryDetailDto::getSort));
                for (int i = 0; i < deliveryDetailList.size(); i++) {
                    PackageDeliveryDetailDto packageDeliveryDetailDto = deliveryDetailList.get(i);
                    if (i < split.length) {
                        packageDeliveryDetailDto.setBillDuration(Integer.parseInt(split[i]));
                    }
                }
                for (ValuationRes valuationRes : billList) {
                    int billDuration = BillingConstant.DEFAULT_BILL_DURATION;
                    Optional<PackageDeliveryDetailDto> optional = deliveryDetailList.stream().filter(item -> item.getDeliveryType().equals(valuationRes.getDeliveryType())).findAny();
                    if (optional.isPresent()) {
                        PackageDeliveryDetailDto packageDeliveryDetailDto = optional.get();
                        billDuration = packageDeliveryDetailDto.getBillDuration();
                    }
                    valuationRes.setBillDuration(billDuration == 0 ? BillingConstant.DEFAULT_BILL_DURATION : billDuration);
                }
            } else {
                for (int i = 0; i < billList.size(); i++) {
                    ValuationRes valuationRes = billList.get(i);
                    int billDuration = BillingConstant.DEFAULT_BILL_DURATION;
                    if (i < split.length) {
                        billDuration = Integer.parseInt(split[i]);
                    }
                    valuationRes.setBillDuration(billDuration);
                }
            }
        } else {
            billList = billList.stream().map(valuationRes -> valuationRes.setBillDuration(BillingConstant.DEFAULT_BILL_DURATION)).collect(Collectors.toList());
        }
        return billList;
    }

    private void setCommissionInfo(List<PackageCommissionDetailDto> packageCommissionDetailDtoList, ValuationRes valuationRes) {
        BigDecimal commission = BigDecimal.ZERO;
        if (valuationRes.getIsMine() == 1 || DeliveryTypeEnums.HUO_LA_LA.getType().equals(valuationRes.getDeliveryType())) {
            valuationRes.setCommission(commission);
            return;
        }
        if (CollectionUtils.isNotEmpty(packageCommissionDetailDtoList) && packageCommissionDetailDtoList.size() > 0) {
            PackageCommissionDetailDto packageCommissionDetailDto = packageCommissionDetailDtoList.get(0);
            if (PackageCommissionTypeEnum.RATE.type.equals(packageCommissionDetailDto.getCommissionType())) {
                if (packageCommissionDetailDto.getValue() != null) {
                    commission = packageCommissionDetailDto.getValue().multiply(valuationRes.getDeliveryAmount())
                            .divide(new BigDecimal("100"), BigDecimal.ROUND_HALF_UP).setScale(6, BigDecimal.ROUND_HALF_UP);
                }
            } else if (PackageDiscountDetailTypeEnum.GRADIENT.type.equals(packageCommissionDetailDto.getCommissionType())) {
                for (PackageCommissionDetailDto item : packageCommissionDetailDtoList) {
                    boolean inRange = BigDecimalUtils.inRange(item.getLeftValue(), item.getRightValue(), valuationRes.getDeliveryAmount());
                    if (inRange) {
                        if (item.getValue() != null) {
                            commission = item.getValue();
                        }
                        break;
                    }
                }
            }
        }
        valuationRes.setCommission(commission);
        valuationRes.setDeliveryAmount(commission.add(valuationRes.getDeliveryAmount()));
    }

    private void setDiscountInfo(List<PackageDiscountDetailDto> discountDetailDtoList, ValuationRes valuationRes) {
        if (valuationRes.getIsMine() == 1) {
            return;
        }
        if (CollectionUtils.isNotEmpty(discountDetailDtoList) && discountDetailDtoList.size() > 0) {
            PackageDiscountDetailDto discountDetailDto = discountDetailDtoList.get(0);
            if (PackageDiscountDetailTypeEnum.ZHE_KOU.type.equals(discountDetailDto.getType())) {
                if (discountDetailDto.getValue() != null) {
                    BigDecimal discountValue = discountDetailDto.getValue().multiply(valuationRes.getDeliveryAmount())
                            .divide(BigDecimal.TEN, BigDecimal.ROUND_HALF_UP).setScale(6, BigDecimal.ROUND_HALF_UP);
                    double abs = Math.abs(valuationRes.getDeliveryAmount().subtract(discountValue).doubleValue());
                    if (discountDetailDto.getMaxValue() != null) {
                        abs = Math.min(abs, discountDetailDto.getMaxValue().doubleValue());
                    }
                    // 判断是优惠还是提价
                    boolean positiveNum = discountValue.subtract(valuationRes.getDeliveryAmount()).compareTo(BigDecimal.ZERO) >= 0;
                    if (positiveNum) {
                        valuationRes.setDeliveryAmount(valuationRes.getDeliveryAmount().add(new BigDecimal(abs)));
                    } else {
                        valuationRes.setDeliveryAmount(valuationRes.getDeliveryAmount().subtract(new BigDecimal(abs)));
                    }
                    valuationRes.setZk(discountDetailDto.getValue());
                }
            } else if (PackageDiscountDetailTypeEnum.GRADIENT.type.equals(discountDetailDto.getType())) {
                for (PackageDiscountDetailDto item : discountDetailDtoList) {
                    boolean inRange = BigDecimalUtils.inRange(item.getLeftValue(), item.getRightValue(), valuationRes.getDeliveryAmount());
                    if (inRange) {
                        if (item.getValue() != null) {
                            BigDecimal discountAmount = valuationRes.getDeliveryAmount().subtract(item.getValue());
                            valuationRes.setDeliveryAmount(discountAmount.compareTo(BigDecimal.ZERO) > 0 ? discountAmount : BigDecimal.ZERO);
                            valuationRes.setMj(item.getValue());
                        }
                        break;
                    }
                }
            }
        }
    }

    private Long setWaimaiOrderInfo(OrderReq orderReq, String takeRemark, Long shopId) {
        WaimaiOrder waimaiOrder = iWaimaiOrderService.findById(orderReq.getWaimaiOrderId());
        if (waimaiOrder.getOrderType().equals(WaimaiOrderTypeEnum.MEI_TUAN.getType())) {
            orderReq.setOrderSource("101");
            orderReq.setOrderingSourceNo(waimaiOrder.getOutOrderId());
            orderReq.setZbOrderingSourceNo(waimaiOrder.getOutOrderId());
            // 查询美团跑腿的token
           // DspWaimai waiMai = iDspWaimaiService.findOne(WaimaiTypeEnums.MEI_TUAN.getType());
            List<WaimaiDto> waiMai = iDspWaimaiService.findList();
            if (CollectionUtils.isNotEmpty(waiMai)){
                for(WaimaiDto dto:waiMai){
                    if(WaimaiOrderTypeEnum.MEI_TUAN.getType().equals(dto.getType())){
                        ShopWaimai shopWaimai = iShopWaimaiService.findByThirdShopId(shopId, dto.getWaimaiId(),waimaiOrder.getThirdShopId());
                        if (shopWaimai != null){
                            orderReq.setZbToken(shopWaimai.getAuthToken());
                        }
                    }else if(WaimaiOrderTypeEnum.MEI_TUAN_SG.getType().equals(dto.getType())){
                        ShopWaimai shopWaimai = iShopWaimaiService.findByThirdShopId(shopId, dto.getWaimaiId(),waimaiOrder.getThirdShopId());
                        if (shopWaimai != null){
                            orderReq.setZbToken(shopWaimai.getAuthToken());
                        }
                    }
                }
            }

        } else if (waimaiOrder.getOrderType().equals(WaimaiOrderTypeEnum.E_LE_ME.getType())) {
            orderReq.setOrderSource("102");
        }else if (waimaiOrder.getOrderType().equals(WaimaiOrderTypeEnum.E_LE_ME_RETAIL.getType())) {
            orderReq.setOrderSource("103");
        }else if (waimaiOrder.getOrderType().equals(WaimaiOrderTypeEnum.MEI_TUAN_SG.getType())) {
            orderReq.setOrderSource("101");
        }else if (waimaiOrder.getOrderType().equals(WaimaiOrderTypeEnum.JD_HOME.getType())) {
            orderReq.setOrderSource("104");
        }
        orderReq.setTakeRemark(takeRemark);
        orderReq.setWaiMaiRemark(waimaiOrder.getCaution());
        orderReq.setMtMoney(waimaiOrder.getTotalPrice());
        orderReq.setPoiSeq(waimaiOrder.getDaySeq());
        orderReq.setWaimaiOrderDetails(iWaimaiOrderDetailService.findList(orderReq.getWaimaiOrderId()));
        return waimaiOrder.getShopId();
    }

    private ValuationRes queryOrderDeliverFee(OrderReq orderReq, DeliveryInfo delivery, Long merchantId, Long shopId, Integer defaultShop) {
        if (DeliveryTypeEnums.SHUN_FENG.getType().equals(delivery.getType()) && "0".equals(orderReq.getProduct().getSfProductType())) {
            return null;
        }
        // 顺丰个人地址发单(发单地址距离门店100米内,算门店发单)且是自运力, 走猎豹平台计价
        if (DeliveryTypeEnums.SHUN_FENG.getType().equals(delivery.getType()) && DefaultShopEnum.SHOW.status.equals(defaultShop) && delivery.getIsMine() == 1) {
            delivery.setIsMine(0);
            delivery.setThirdShopId(null);
        }
        orderReq.setOrderSn(SnCodeUtils.createSn());
        orderReq.setAmount(orderReq.getProductAmount());
        OrderVo orderVo = OrderEntityUtils.createOrderVo(orderReq, delivery, deliveryConfig.isTest());
        orderVo.setIsMine(delivery.getIsMine());
        if (DeliveryTypeEnums.FENG_NIAO.getType().equals(delivery.getType()) || DeliveryTypeEnums.MEI_TUAN.getType().equals(delivery.getType())
                || DeliveryTypeEnums.FENG_NIAO_PT.getType().equals(delivery.getType())) {
            ShopDelivery shopDelivery = iShopDeliveryService.findOne(shopId, delivery.getId());
            if (shopDelivery == null || !BindStatusEnum.BIND.status.equals(shopDelivery.getBindStatus())) {
                return null;
            }
        }

        if ((DeliveryTypeEnums.FENG_NIAO.getType().equals(delivery.getType())
                || DeliveryTypeEnums.MEI_TUAN.getType().equals(delivery.getType())
                 ||DeliveryTypeEnums.FENG_NIAO_PT.getType().equals(delivery.getType()))
                && DefaultShopEnum.SHOW.status.equals(defaultShop)) {
            return null;
        }

        if ((DeliveryTypeEnums.FENG_NIAO.getType().equals(delivery.getType())||DeliveryTypeEnums.FENG_NIAO_PT.getType().equals(delivery.getType())) && shopId == null) {
            return null;
        }
        // 美团跑腿未绑定不参与计价
        if ((DeliveryTypeEnums.MEI_TUAN_ZB.getType().equals(delivery.getType()) ||DeliveryTypeEnums.MEI_TUAN_SG_ZB.getType().equals(delivery.getType()))&& delivery.getIsMine() == 0){
            return null;
        }
        if ((DeliveryTypeEnums.MEI_TUAN_ZB.getType().equals(delivery.getType()) ||DeliveryTypeEnums.MEI_TUAN_SG_ZB.getType().equals(delivery.getType()))){
            SysConfig sysConfig = iSysConfigService.selectSysConfigByKey("MT_PT");
            if (sysConfig.getConfigValue().equals("yes") && shopId != 1626){
                return null;
            }
        }
        ResObject<OrderResultVo> resObject = client.queryOrderDeliverFee(orderVo);
        if (resObject.getCode() == 0) {
            ValuationRes res = new ValuationRes();
            transResObject(res, delivery, resObject, orderReq, orderVo);
            // 判断是否是自己平台，查询金额是否充足
            if (delivery.getIsMine() == 1 && !delivery.getType().equals(DeliveryTypeEnums.KUAI_FU.getType())
                    && !delivery.getType().equals(DeliveryTypeEnums.MEI_TUAN_ZB.getType())
                    && !DeliveryTypeEnums.MEI_TUAN_ZB.getType().equals(delivery.getType())) {
                QueryAmount queryAmount = QueryAmountEntityUtils.queryAmount(delivery, merchantId, delivery.getIsMine());
                ResObject<AmountResultVo> amountRes = client.queryAmount(queryAmount);
                if (amountRes.getCode() == 0) {
                    // 更新余额
                    AmountResultVo vo = amountRes.getData();
                    this.updateAmount(delivery, merchantId, shopId, vo.getBalanceAmount());
                    if (vo.getBalanceAmount().compareTo(res.getDeliveryAmount()) >= 0) {
                        res.setIsEnough(StatusEnum.SHOW.status);
                        res.setIsMine(1);
                    } else {
                        //uupt需重新计价
                        res.setIsMine(0);
                        orderVo.setIsMine(0);
                        if (DeliveryTypeEnums.UUPT.getName().equals(orderVo.getLbClient())||DeliveryTypeEnums.SHAN_SONG.getName().equals(orderVo.getLbClient())) {
                            orderVo.setOpenId("");
                            resObject = client.queryOrderDeliverFee(orderVo);
                            if (resObject.getCode() == 0) {
                                transResObject(res, delivery, resObject, orderReq, orderVo);
                            }else{
                                res = null;
                            }

                        }
                        if (DeliveryTypeEnums.DADA.getType().equals(delivery.getType()) || DeliveryTypeEnums.DADA_YZ.getType().equals(delivery.getType())){
                            // 达达/优质余额不足，重新计价
                            log.info("余额不足----" + DeliveryTypeEnums.getNameByType(delivery.getType()) + "余额不足，重新计价");
                            ShopDelivery sd = iShopDeliveryService.getOne(new QueryWrapper<ShopDelivery>().eq("merchant_id", merchantId).eq("delivery_id", delivery.getId())
                                    .eq("deleted", IsDeleteEnum.NORMAL.status).eq("shop_id", shopId).eq("bind_status",1));
                            if (sd != null && sd.getThirdShopId() != null) {
                                orderVo.setShopNo(sd.getThirdShopId());
                                delivery.setShopId(sd.getThirdShopId());
                            } else {
                                // 如果默认店铺被删了，则取列表第一个
                                List<ShopDelivery> deliveries = iShopDeliveryService.list(new QueryWrapper<ShopDelivery>().eq("merchant_id", merchantId).eq("delivery_id", delivery.getId())
                                        .eq("deleted", IsDeleteEnum.NORMAL.status).isNotNull("third_shop_id"));
                                if (CollectionUtils.isNotEmpty(deliveries)){
                                    orderVo.setShopNo(deliveries.get(0).getThirdShopId());
                                    delivery.setShopId(deliveries.get(0).getThirdShopId());
                                }
                            }
                            orderVo.setMerchantId(null);
                            resObject = client.queryOrderDeliverFee(orderVo);
                            if (resObject.getCode() == 0) {
                                transResObject(res, delivery, resObject, orderReq, orderVo);
                            }else{
                                res = null;
                            }
                        }
                        // 顺丰自运力余额不足，转猎豹平台重写计价
                        if (DeliveryTypeEnums.SHUN_FENG.getName().equals(orderVo.getLbClient())) {
                            delivery.setIsMine(0);
                            delivery.setThirdShopId(null);
                            OrderVo reOrderVo = OrderEntityUtils.createOrderVo(orderReq, delivery, deliveryConfig.isTest());
                            reOrderVo.setIsMine(delivery.getIsMine());
                            resObject = client.queryOrderDeliverFee(reOrderVo);
                            if (resObject.getCode() == 0) {
                                transResObject(res, delivery, resObject, orderReq, orderVo);
                            }else{
                                res = null;
                            }
                        }

                    }
                }
            } else if (delivery.getIsMine() == 1 && delivery.getType().equals(DeliveryTypeEnums.KUAI_FU.getType())) {
                if (!resObject.getData().getFeStatus().equals("1")) {

                    res.setIsMine(0);
                    orderVo.setIsMine(0);
                    orderVo.setAccessToken(null);
                    orderVo.setOpenId(null);
                    resObject = client.queryOrderDeliverFee(orderVo);
                    if (resObject.getCode() == 0) {
                        transResObject(res, delivery, resObject, orderReq, orderVo);
                    }else{
                        res = null;
                    }
                }
            }
            return res;
        }
        return null;
    }

    private void updateAmount(DeliveryInfo delivery, Long merchantId, Long shopId, BigDecimal balanceAmount) {
        if (DeliveryTypeEnums.DADA.getType().equals(delivery.getType())
                || DeliveryTypeEnums.DADA_YZ.getType().equals(delivery.getType())
                || DeliveryTypeEnums.FENG_NIAO.getType().equals(delivery.getType())
                || DeliveryTypeEnums.SHUN_FENG.getType().equals(delivery.getType())
                || DeliveryTypeEnums.MEI_TUAN_ZB.getType().equals(delivery.getType())) {
            ShopDeliveryBind shopDeliveryBind = iShopDeliveryBindService.getOne(new QueryWrapper<ShopDeliveryBind>()
                    .eq("merchant_id", merchantId).eq("shop_id", shopId).eq("delivery_id", delivery.getId())
                    .eq("deleted", IsDeleteEnum.NORMAL.status).eq("bind_status", 1));
            // 门店模式变更余额
            if (shopDeliveryBind != null) {
                iShopDeliveryBindService.updateShopAmount(shopDeliveryBind.getMerchantId(), shopDeliveryBind.getDeliveryId(), shopDeliveryBind.getThirdShopId(), balanceAmount);
            }
        } else {
            ShopDeliveryBind shopDeliveryBind = iShopDeliveryBindService.getOne(new QueryWrapper<ShopDeliveryBind>()
                    .eq("merchant_id", merchantId).eq("delivery_id", delivery.getId())
                    .eq("deleted", IsDeleteEnum.NORMAL.status).isNull("shop_id")
                    .eq("bind_status", 1));
            // 商户模式变更余额
            if (shopDeliveryBind != null) {
                iShopDeliveryBindService.updateMerchantAmount(shopDeliveryBind.getId(), balanceAmount);
            }
        }
    }

    private void transResObject(ValuationRes res, DeliveryInfo delivery, ResObject<OrderResultVo> resObject, OrderReq orderReq, OrderVo orderVo) {
        res.setDeliveryId(delivery.getId());
        res.setName(delivery.getName());
        res.setLogo(delivery.getLogo());
        res.setDesc(CommonUtils.change2Km((int) resObject.getData().getDistance()));
        res.setDeliveryAmount(resObject.getData().getDeliverFee());
        res.setIsEnough(StatusEnum.STOP.status);
        res.setTotalMoney(resObject.getData().getTotalMoney());
        res.setNeedPaymoney(resObject.getData().getNeedPaymoney());
        res.setPriceToken(resObject.getData().getPriceToken());
        // res.setDeliveryInfo(delivery);
        res.setOrderSn(orderReq.getOrderSn());
        res.setIsMine(orderVo.getIsMine());
        res.setOrderNo(orderReq.getOrderNo());
        res.setCityId(resObject.getData().getCityId());
        res.setCityInfoRevision(resObject.getData().getCityInfoRevision());
        res.setOrderVehicleId(resObject.getData().getOrderVehicleId());
        res.setTotalPriceFen(resObject.getData().getHllAmount());
        res.setOrderNumber(resObject.getData().getDeliveryOrderNo());//闪送订单号
        res.setShopId(delivery.getShopId());
        res.setThirdShopId(delivery.getThirdShopId());
        res.setAuthToken(delivery.getAuthToken());
        res.setPhone(delivery.getPhone());
        res.setDeliveryType(delivery.getType());
    }

}