liebao-cloud/lb-app/src/main/java/com/ydd/app/service/impl/OpenApiOrderValuationServiceImpl.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.*;
import com.ydd.app.response.OrderValuationResponse;
import com.ydd.app.service.OpenApiOrderValuationService;
import com.ydd.app.vo.OrderValuationVo;
import com.ydd.common.constant.BillingConstant;
import com.ydd.common.constant.RedisKeyConstant;
import com.ydd.common.core.domain.ResponseResult;
import com.ydd.common.core.redis.RedisCache;
import com.ydd.common.enums.DeliveryTypeEnums;
import com.ydd.common.enums.ResponseResultCodeEnum;
import com.ydd.common.utils.DateUtils;
import com.ydd.common.utils.SnCodeUtils;
import com.ydd.common.utils.StringUtils;
import com.ydd.ecloud.core.enums.DeletedEnum;
import com.ydd.ecloud.core.utils.BigDecimalUtils;
import com.ydd.module.constants.AppConstant;
import com.ydd.module.domain.*;
import com.ydd.module.dto.*;
import com.ydd.module.enums.*;
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.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.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * 开放接口-订单计价ServiceImpl
 * @author 叶君翔
 * @date 2022/04/08 15:51
 */
@Slf4j
@Service
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class OpenApiOrderValuationServiceImpl implements OpenApiOrderValuationService {

    private final IShopService iShopService;

    private final IMerchantService iMerchantService;

    private final IMemberService iMemberService;

    private final IProductService iProductService;

    private final IPackageCityConfigService iPackageCityConfigService;

    private final IPackageDeliveryService iPackageDeliveryService;

    private final IPackageDiscountService iPackageDiscountService;

    private final IPackageDiscountDetailService iPackageDiscountDetailService;

    private final IPackageCommissionService iPackageCommissionService;

    private final IPackageCommissionDetailService iPackageCommissionDetailService;

    private final IDspDeliveryService iDspDeliveryService;

    private final IShopDeliveryDisableService iShopDeliveryDisableService;

    private final IShopDeliveryService iShopDeliveryService;

    private final IMemberConfigService iMemberConfigService;

    private final DeliveryConfig deliveryConfig;

    private final ISysConfigService iSysConfigService;

    private final DeliveryService client;

    private final IShopDeliveryBindService iShopDeliveryBindService;

    private final RedisCache redisCache;
    private final IDspDeliveryUuService iDspDeliveryUuService;

    @Override
    public ResponseResult valuation(OrderValuationReq valuationReq, Long loginId) {
        // 开放平台大商户对应的用户
        Member member = iMemberService.getById(loginId);
        OrderValuationDto valuationDto = new OrderValuationDto();
        // 参数校验
        ResponseResult result = this.validParam(valuationReq, valuationDto, member);
        if (result.getCode() != ResponseResultCodeEnum.SUCCESS.getCode()) {
            return result;
        }
        Product product = iProductService.getById(valuationReq.getCategoryId());
        if (product == null) {
            return ResponseResult.error(ResponseResultCodeEnum.CATEGORY_NOT_EXIST);
        }
        valuationDto.setProduct(product);
        valuationDto.setOrderSn(SnCodeUtils.createSn());
        valuationDto.setTakeType(0);

        // 获取最匹配的运力包(门店 > 城市 > 全国)
        Long deliveryPackageId = iPackageCityConfigService.getPackageId(valuationDto.getShopId(), member, null, 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<Integer> disableDeliveryTypes = iShopDeliveryDisableService.list(new QueryWrapper<ShopDeliveryDisable>()
                .eq("shop_id", valuationDto.getShopId()).eq("deleted", 0))
                .stream().map(ShopDeliveryDisable::getDeliveryType).collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(disableDeliveryTypes)) {
            types.removeAll(disableDeliveryTypes);
        }
        // 获取可用发单运力
        List<DeliveryInfo> deliveryInfos = this.getDeliveryInfos(valuationDto, types);
        if (CollectionUtils.isEmpty(deliveryInfos)) {
            log.warn("无可用发单运力！");
            return ResponseResult.error(ResponseResultCodeEnum.NO_DELIVERY);
        }
        List<Integer> deliveryTypes = deliveryInfos.stream().map(DspDelivery::getType).collect(Collectors.toList());
        // 获取最匹配的优惠包(门店 > 代理商 > 全国)
        Long discountPackageId = iPackageCityConfigService.getPackageId(valuationDto.getShopId(), member, null, 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(valuationDto.getShopId(), member, null, 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));
        }
        OrderReq orderReq = this.convertToOrderReq(valuationDto);
        // 计价
        List<ValuationRes> list = this.getValuationResList(orderReq, valuationDto, deliveryInfos, packageDeliveryDto, packageDiscountMap, packageCommissionMap);
        // 默认价格优先
        list.sort(Comparator.comparing(ValuationRes::getDeliveryAmount));
        // 运力包发单类型为自定义, 则先按照sort排，再按价格排
        if (packageDeliveryDto != null && PackageDeliveryTypeEnum.CUSTOM.type.equals(packageDeliveryDto.getType())) {
            Collections.sort(list);
        }
        // 处理发单运力
        List<ValuationRes> billList = this.handleBillList(member.getId(), list);
        // 设置发单时长
        if (packageDeliveryDto != null) {
            billList = this.setBillingDuration(packageDeliveryDto, billList);
        }
        orderReq.setMemberId(member.getId());
        orderReq.setValuationRes(billList);
        // 计价结果缓存到redis, 10分钟有效, 到时需重新计价
        redisCache.setCacheObject(RedisKeyConstant.VALUATION_RESULT + valuationDto.getOutOrderSn(), orderReq, AppConstant.VALUATION_RESULT_EFFECTIVE_MINUTES, TimeUnit.MINUTES);
        // 数据转换
        List<OrderValuationVo> valuationVos = this.convertResult(billList);
        OrderValuationResponse response = OrderValuationResponse.builder().valuationList(valuationVos).outOrderSn(valuationReq.getOutOrderSn()).build();
        return ResponseResult.success(response);
    }

    private List<OrderValuationVo> convertResult(List<ValuationRes> billList) {
        List<OrderValuationVo> valuationVos = Lists.newArrayList();
        for (ValuationRes valuationRes : billList) {
            OrderValuationVo valuationVo = new OrderValuationVo();
            valuationVo.setDeliveryId(valuationRes.getDeliveryType());
            valuationVo.setDeliveryName(valuationRes.getName());
            valuationVo.setDistance(valuationRes.getDesc());
            if (valuationRes.getDeliveryAmount() != null) {
                valuationVo.setDeliveryAmount(valuationRes.getDeliveryAmount().setScale(2, BigDecimal.ROUND_HALF_UP));
                // 暂时第三方
                valuationVo.setDiscountAmount(BigDecimal.ZERO);
                valuationVo.setNeedPayAmount(valuationVo.getDeliveryAmount().subtract(valuationVo.getDiscountAmount()));
            }
            valuationVos.add(valuationVo);
        }
        return valuationVos;
    }

    private List<ValuationRes> handleBillList(Long memberId, List<ValuationRes> list) {
        // 查询下单设置推荐屏蔽运力
        List<ValuationRes> billList = Lists.newArrayList();
        MemberConfig config = iMemberConfigService.getOne(new QueryWrapper<MemberConfig>().eq("member_id", memberId));
        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();
            String distance = optional.get().getDistance();
            for (ValuationRes res1 : billList) {
                if (DeliveryTypeEnums.SHAN_SONG.getType().equals(res1.getDeliveryType())) {
                    res1.setDesc(desc);
                    res1.setDistance(distance);
                    break;
                }
            }
        }
        return billList;
    }

    private List<ValuationRes> getValuationResList(OrderReq orderReq, OrderValuationDto valuationDto, List<DeliveryInfo> deliveryInfos, PackageDeliveryDto packageDeliveryDto, Map<Integer, List<PackageDiscountDetailDto>> packageDiscountMap, Map<Integer, List<PackageCommissionDetailDto>> packageCommissionMap) {
        List<ValuationRes> valuationResList = Lists.newArrayList();
        for (DeliveryInfo deliveryInfo : deliveryInfos) {
//            OrderReq orderReq = this.convertToOrderReq(valuationDto);
            // 计价
            ValuationRes valuationRes = this.doValuation(orderReq, deliveryInfo, valuationDto.getMerchantId(), valuationDto.getShopId());
            if (Objects.isNull(valuationRes)) {
                continue;
            }
            valuationRes.setPreferredDelivery(deliveryInfo.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(deliveryInfo.getType()), valuationRes);
            }
            // 设置佣金
            if (packageCommissionMap.size() > 0) {
                this.setCommissionInfo(packageCommissionMap.get(deliveryInfo.getType()), valuationRes);
            }
            valuationRes.setIsMerchant(deliveryInfo.getIsMerchant());
            if (valuationRes.getIsMine() == 0) {
                // 校验余额是否充足
                Member member = iMemberService.getOne(new QueryWrapper<Member>().eq("member_type", MemberTypeEnum.MERCHANT.type).eq("merchant_id", valuationDto.getMerchantId()));
                if (member.getAmount().compareTo(valuationRes.getDeliveryAmount()) >= 0) {
                    valuationRes.setIsEnough(StatusEnum.SHOW.status);
                }
            }
            valuationResList.add(valuationRes);
        }
        return valuationResList;
    }

    private OrderReq convertToOrderReq(OrderValuationDto valuationDto) {
        OrderReq orderReq = new OrderReq();
        BeanUtils.copyProperties(valuationDto, orderReq);

        AddressReq sendAddress = new AddressReq();
        sendAddress.setContact(valuationDto.getSendName());
        sendAddress.setPhone(valuationDto.getSendPhone());
        sendAddress.setProvinceName(valuationDto.getSendProvinceName());
        sendAddress.setCityName(valuationDto.getSendCityName());
        if (StringUtils.isBlank(valuationDto.getSendDistrictName())) {
            valuationDto.setSendDistrictName("城区");
        }
        sendAddress.setDistrictName(valuationDto.getSendDistrictName());
        sendAddress.setAddress(valuationDto.getSendAddress());
        sendAddress.setStreet(valuationDto.getSendHouseNumber());
        sendAddress.setLng(valuationDto.getSendLng());
        sendAddress.setLat(valuationDto.getSendLat());
        sendAddress.setCityCode(valuationDto.getSendCityCode());
        orderReq.setSendAddress(sendAddress);

        AddressReq receiptAddress = new AddressReq();
        receiptAddress.setContact(valuationDto.getReceiverName());
        receiptAddress.setPhone(valuationDto.getReceiverPhone());
        receiptAddress.setProvinceName(valuationDto.getReceiverProvinceName());
        receiptAddress.setCityName(valuationDto.getReceiverCityName());
        if (StringUtils.isBlank(valuationDto.getReceiverDistrictName())) {
            valuationDto.setReceiverDistrictName("城区");
        }
        receiptAddress.setDistrictName(valuationDto.getReceiverDistrictName());
        receiptAddress.setAddress(valuationDto.getReceiverAddress());
        receiptAddress.setStreet(valuationDto.getReceiverHouseNumber());
        receiptAddress.setLng(valuationDto.getReceiverLng());
        receiptAddress.setLat(valuationDto.getReceiverLat());
        receiptAddress.setCityCode(valuationDto.getReceiverCityCode());
        orderReq.setReceiptAddress(receiptAddress);

        orderReq.setDaySeq(String.valueOf(valuationDto.getDaySeq()));
        orderReq.setOrderNo(valuationDto.getOrderSn());
        orderReq.setProduct(valuationDto.getProduct());
        orderReq.setProductId(valuationDto.getCategoryId());

        if (StringUtils.isNotBlank(valuationDto.getShopCode())) {
            orderReq.setShopId(valuationDto.getShopId());
            orderReq.setShopName(valuationDto.getShopName());
        }
        orderReq.setIsMine(0);
        orderReq.setTransport(0);
        // 对接开放接口的均为余额支付
        orderReq.setPaymentType(PaymentTypeEnum.BALANCE.type);
        orderReq.setTakeRemark(valuationDto.getRemark());
        // 对接开放接口均为自选运力
        orderReq.setDeliveryType(2);
        // 对接开放接口均为立即取件，取件时间为当前
        orderReq.setTakeType(0);
        orderReq.setTakeTime(DateUtils.format(new Date(), DateUtils.YYYY_MM_DD_HH_MM_SS));

        return orderReq;
    }

    private ValuationRes doValuation(OrderReq orderReq, DeliveryInfo delivery, Long merchantId, Long shopId) {
        orderReq.setOrderSn(SnCodeUtils.createSn());
        orderReq.setAmount(orderReq.getProductAmount());
        if (DeliveryTypeEnums.UUPT.getType().equals(delivery.getType())&&delivery.getIsMine() != 1) {
            List<DspDeliveryUu> uuList = iDspDeliveryUuService.list(new QueryWrapper<DspDeliveryUu>().eq("city_name", orderReq.getSendAddress().getCityName()));
            if (CollectionUtils.isNotEmpty(uuList)) {
                for(DspDeliveryUu uu:uuList){
                    if(uu.getProductId().equals(orderReq.getProductId())){
                        delivery.setShopId(uu.getOpenId());
                        break;
                    }
                }
            }
        }
        OrderVo orderVo = OrderEntityUtils.createOrderVo(orderReq, delivery, deliveryConfig.isTest());
        // 获取用户配置
        MemberConfig memberConfig = iMemberConfigService.getShopMemberConfig(shopId, null);
        if (memberConfig != null && memberConfig.getSyncGoodsDetailToDelivery().equals(DeletedEnum.YES.getValue())) {
            // 是否同步订单商品给骑手
            orderVo.setMtGoods(Lists.newArrayList());
        }
        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.setDistance(String.valueOf(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());
    }

    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 List<DeliveryInfo> getDeliveryInfos(OrderValuationDto valuationDto, List<Integer> types) {
        List<DspDelivery> list = iDspDeliveryService.list(new QueryWrapper<DspDelivery>()
                .isNotNull("parent_id")
                .eq("status", StatusEnum.SHOW.status)
                .eq("deleted", IsDeleteEnum.NORMAL.status)
                .ne("type", DeliveryTypeEnums.HUO_LA_LA.getType())
                .in(CollectionUtils.isNotEmpty(types), "type", types));
        List<DeliveryInfo> infos = Lists.newArrayList();

        List<Integer> deliveryTypes = Arrays.asList(DeliveryTypeEnums.DADA.getType(), DeliveryTypeEnums.DADA_YZ.getType(),
                DeliveryTypeEnums.DWD.getType(), DeliveryTypeEnums.FENG_NIAO.getType(), DeliveryTypeEnums.FENG_NIAO_PT.getType(),
                DeliveryTypeEnums.MEI_TUAN.getType(), DeliveryTypeEnums.SHAN_SONG.getType(), DeliveryTypeEnums.SHUN_FENG.getType());

        List<Long> deliveryIds = list.stream().map(DspDelivery::getId).collect(Collectors.toList());
        Map<String, List<ShopDelivery>> deliveryMap = new HashMap<>();
        if (CollectionUtils.isNotEmpty(deliveryIds)) {
            deliveryMap = iShopDeliveryService.list(new QueryWrapper<ShopDelivery>()
                    .eq("merchant_id", valuationDto.getMerchantId())
                    .in("delivery_id", deliveryIds)
                    .eq("deleted", IsDeleteEnum.NORMAL.status)
                    .eq("shop_id", valuationDto.getShopId())
                    .eq("bind_status",1))
                    .stream()
                    .collect(Collectors.groupingBy(item -> item.getDeliveryId() + "-" + item.getMerchantId() + "-" + item.getShopId()));
        }
        for (DspDelivery delivery : list) {
            DeliveryInfo info = new DeliveryInfo();
            BeanUtils.copyProperties(delivery, info);
            if (deliveryTypes.contains(info.getType()) && valuationDto.getMerchantId() != null && valuationDto.getShopId() != null) {
                List<ShopDelivery> shopDeliveries = deliveryMap.get(info.getId() + "-" + valuationDto.getMerchantId() + "-" + valuationDto.getShopId());
                ShopDelivery sd = new ShopDelivery();
                if (CollectionUtils.isNotEmpty(shopDeliveries)) {
                    sd = shopDeliveries.get(0);
                }
                if (sd.getThirdShopId() != null && (DeliveryTypeEnums.DADA.getType().equals(info.getType())
                        || DeliveryTypeEnums.DADA_YZ.getType().equals(info.getType())
                        || DeliveryTypeEnums.SHAN_SONG.getType().equals(info.getType()))) {
                    info.setShopId(sd.getThirdShopId());
                }
                if(sd.getThirdShopId() != null && (DeliveryTypeEnums.FENG_NIAO.getType().equals(info.getType())
                        || DeliveryTypeEnums.FENG_NIAO_PT.getType().equals(info.getType())
                        || DeliveryTypeEnums.MEI_TUAN.getType().equals(info.getType()))) {
                    info.setThirdShopId(sd.getThirdShopId());
                }
            }
            info.setIsMine(0);
            infos.add(info);
        }
        return infos;
    }

    private ResponseResult validParam(OrderValuationReq valuationReq, OrderValuationDto valuationDto, Member member) {
        ResponseResult result = ResponseResult.success();
        List<Integer> platformTypes = Arrays.asList(0, 1, 2, 3, 5, 6);
        if (!platformTypes.contains(valuationReq.getPlatformType())) {
            return ResponseResult.error(ResponseResultCodeEnum.FIELD_INVALID, "platformType", null);
        }
        if (StringUtils.isBlank(valuationReq.getShopCode())) {
            if (StringUtils.isBlank(valuationReq.getSendName())) {
                return ResponseResult.error(ResponseResultCodeEnum.FIELD_EMPTY, "sendName", null);
            }
            if (StringUtils.isBlank(valuationReq.getSendPhone())) {
                return ResponseResult.error(ResponseResultCodeEnum.FIELD_EMPTY, "sendPhone", null);
            }
            if (StringUtils.isBlank(valuationReq.getSendProvinceName())) {
                return ResponseResult.error(ResponseResultCodeEnum.FIELD_EMPTY, "sendProvinceName", null);
            }
            if (StringUtils.isBlank(valuationReq.getSendCityName())) {
                return ResponseResult.error(ResponseResultCodeEnum.FIELD_EMPTY, "sendCityName", null);
            }
            if (StringUtils.isBlank(valuationReq.getSendCityCode())) {
                return ResponseResult.error(ResponseResultCodeEnum.FIELD_EMPTY, "sendCityCode", null);
            }
            if (StringUtils.isBlank(valuationReq.getSendAddress())) {
                return ResponseResult.error(ResponseResultCodeEnum.FIELD_EMPTY, "sendAddress", null);
            }
            if (StringUtils.isBlank(valuationReq.getSendLng())) {
                return ResponseResult.error(ResponseResultCodeEnum.FIELD_EMPTY, "sendLng", null);
            }
            if (StringUtils.isBlank(valuationReq.getSendLat())) {
                return ResponseResult.error(ResponseResultCodeEnum.FIELD_EMPTY, "sendLat", null);
            }
            valuationDto.setShopId(member.getShopId());
            valuationDto.setMerchantId(member.getMerchantId());
        } else {
            Shop shop = iShopService.getByCode(valuationReq.getShopCode());
            if (shop == null) {
                return ResponseResult.error(ResponseResultCodeEnum.SHOP_NOT_EXIST);
            }
            valuationReq.setSendName(shop.getContactName());
            valuationReq.setSendPhone(shop.getMobile());
            valuationReq.setSendProvinceName(shop.getProvinceName());
            valuationReq.setSendCityName(shop.getCityName());
            valuationReq.setSendDistrictName(shop.getDistrictName());
            valuationReq.setSendAddress(shop.getAddress());
            valuationReq.setSendHouseNumber(shop.getStreet());
            valuationReq.setSendLat(shop.getLat());
            valuationReq.setSendLng(shop.getLng());
            valuationReq.setSendCityCode(shop.getCityCode());

            valuationDto.setShopId(shop.getId());
            valuationDto.setShopName(shop.getName());
            valuationDto.setMerchantId(shop.getMerchantId());
        }
        BeanUtils.copyProperties(valuationReq, valuationDto);
        if (valuationDto.getMerchantId() != null) {
            Merchant merchant = iMerchantService.getById(valuationDto.getMerchantId());
            if (merchant == null) {
                return ResponseResult.error(ResponseResultCodeEnum.MERCHANT_DISABLE);
            }
        }
        return result;
    }

}