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

package com.ydd.app.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.binarywang.wxpay.exception.WxPayException;
import com.ijpay.core.enums.TradeType;
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.OrderMarkerDto;
import com.ydd.app.dto.OrderReq;
import com.ydd.app.dto.ValuationRes;
import com.ydd.app.service.ApiOrderService;
import com.ydd.app.service.ApiProductService;
import com.ydd.app.service.ApiRiderLocationService;
import com.ydd.app.task.TipsTask;
import com.ydd.common.constant.RedisKeyConstant;
import com.ydd.common.core.page.PageResult;
import com.ydd.common.core.redis.RedisCache;
import com.ydd.common.enums.DeliveryTypeEnums;
import com.ydd.common.enums.WaimaiTypeEnums;
import com.ydd.common.exception.CustomException;
import com.ydd.common.utils.DateUtils;
import com.ydd.common.utils.SnCodeUtils;
import com.ydd.common.utils.StringUtils;
import com.ydd.ecloud.core.utils.JsonMapper;
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.expection.CustomAppException;
import com.ydd.module.expection.CustomWebException;
import com.ydd.module.pay.alipay.AliPayService;
import com.ydd.module.pay.dto.OrderPaySignResponse;
import com.ydd.module.pay.wechat.service.WechatPayService;
import com.ydd.module.producer.RabbitSender;
import com.ydd.module.request.OrderListRequest;
import com.ydd.module.request.OrderMarkerRequest;
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.AddressLngLatExchanger;
import com.ydd.third.common.vo.GDMapTripResult;
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 com.ydd.third.common.vo.waimai.eleme.api.entity.order.OActivity;
import com.ydd.third.common.vo.waimai.meituan.MeituanOrderExtraVo;
import com.ydd.third.print.request.PrintOrderActDto;
import com.ydd.third.print.request.PrintOrderDto;
import com.ydd.third.print.request.PrintOrderGoodsDto;
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.context.ApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StopWatch;

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

/**
 * Project：lb-server
 * Class：ApiOrderServiceImpl
 * Description：TODO
 * Time：2021/2/23 14:41
 *
 * @author zoe
 */
@Slf4j
@Service
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class ApiOrderServiceImpl implements ApiOrderService {

    public static ScheduledExecutorService tipScheduledExecutorService = Executors.newScheduledThreadPool(10);

    private final ApiProductService apiProductService;

    private final IOrderService iOrderService;

    private final IOrderLogService iOrderLogService;

    private final IOrderCommentService iOrderCommentService;

    private final IMemberService iMemberService;

    private final DeliveryService client;

    private final IDspDeliveryService iDspDeliveryService;

    private final IMemberBalanceLogService iMemberBalanceLogService;

    private final IWaimaiOrderDetailService iWaimaiOrderDetailService;

    private final IWaimaiOrderService iWaimaiOrderService;

    private final IDspWaimaiService iDspWaimaiService;

    private final DeliveryConfig deliveryConfig;

    private final IMemberConfigService iMemberConfigService;

    private final ApplicationContext applicationContext;

    private final ISysConfigService iSysConfigService;

    private final IDspConfigService iDspConfigService;

    private final RedisTemplate redisTemplate;
    private final IOrderDeliveryService iOrderDeliveryService;

    private final IShopDeliveryService iShopDeliveryService;
    private final IOrderTipService iOrderTipService;
    private final AliPayService aliPayService;
    private final WechatPayService wechatPayService;
    private final IPaymentService paymentService;
    private final IDeliveryConfigService iDeliveryConfigService;

    private final IShopService iShopService;
    private final IShopUserService iShopUserService;

    private final IOrderDelayService iOrderDelayService;
    private final RabbitSender rabbitSender;

    private final RedisCache redisCache;
    private final ApiRiderLocationService apiRiderLocationService;
    private final IMemberAddressService iMemberAddressService;
    private final IWaimaiFoodImgService iWaimaiFoodImgService;
    private final IAgentService iAgentService;
    private final ApiCacheUserAddress apiCacheUserAddress;
    private final IShopWaimaiService iShopWaimaiService;
    private final IShopDeliveryBindService iShopDeliveryBindService;
    private final IMerchantService iMerchantService;
    private final IDadaDspService iDadaDspService;

    @Override
    public ValuationRes valuation(Long loginId, OrderReq orderReq, Integer type) {
        log.info("<===========>计价参数" + JsonMapper.nonEmptyMapper().toJson(orderReq));
        try {

            Member member = iMemberService.getById(loginId);
            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();
            Integer defaultShop = 0;
            Long waimaiOrderId = null;
            String takeRemark = "";
            if (orderReq.getOrderId() != null) {
                Order order = iOrderService.getById(orderReq.getOrderId());
                orderReq.setWaimaiOrderId(order.getWaimaiOrderId());
                // orderReq.setOrderSn(order.getOrderSn());
                orderReq.setWaimaiOrderId(order.getWaimaiOrderId());
                waimaiOrderId = order.getWaimaiOrderId();
                if (order.getDeliveryStatus().intValue() >= DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status.intValue() && order.getDeliveryStatus().intValue() != DeliveryStatusEnum.FINISH.status.intValue()) {
                    return null;
                }
                if (DeliveryStatusEnum.CANCEL.status.equals(order.getDeliveryStatus()) || DeliveryStatusEnum.FINISH.status.equals(order.getDeliveryStatus()) || DeliveryStatusEnum.ABNORMAL.status.equals(order.getDeliveryStatus())) {
                    orderReq.setOrderNo(SnCodeUtils.createSn());
                } else {
                    orderReq.setOrderNo(order.getOrderSn());
                }
                shopId = order.getShopId();
                if (DefaultShopEnum.SHOW.status.equals(order.getDefaultShop())) {
                    //非门店模式，不出现蜂鸟和美团
                    defaultShop = 1;
                }
                takeRemark = order.getTakeRemark();
            } else {
                //  orderReq.setOrderSn(SnCodeUtils.createSn());
                orderReq.setOrderNo(SnCodeUtils.createSn());
            }

            if (orderReq.getSendAddress().getId() == null && orderReq.getShopId() != null && waimaiOrderId == null) {//兼容老版本非门店模式下单且不是外卖单子
                //非门店模式，不出现蜂鸟和美团
                defaultShop = 1;
            }
            if (orderReq.getSendAddress().getId() != null && orderReq.getShopId() != null && !orderReq.getSendAddress().getId().equals(orderReq.getShopId())) {//兼容老版本非门店模式下单且不是外卖单子
                //非门店模式，不出现蜂鸟和美团
                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<>();

            if (orderReq.getWaimaiOrderId() != null) {
                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());
                    if (waiMai != null){
                        ShopWaimai shopWaimai = iShopWaimaiService.findById(shopId,waiMai.getId());
                        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");
                }

                orderReq.setTakeRemark(takeRemark);
                orderReq.setWaiMaiRemark(waimaiOrder.getCaution());
                orderReq.setMtMoney(waimaiOrder.getTotalPrice());
                orderReq.setPoiSeq(waimaiOrder.getDaySeq());
                waiMaiOrderDetails = iWaimaiOrderDetailService.findList(orderReq.getWaimaiOrderId());
                shopId = waimaiOrder.getShopId();
                if (waimaiOrder.getOrderType().equals(1)) {
                    orderReq.setOrderSource("101");
                } else if (waimaiOrder.getOrderType().equals(2)) {
                    orderReq.setOrderSource("102");
                }
            }
            orderReq.setWaimaiOrderDetails(waiMaiOrderDetails);
            orderReq.setProduct(product);
            ValuationRes res = new ValuationRes();
            List<ValuationRes> list = new ArrayList<>();
            List<ValuationRes> supports = new ArrayList<>();
            DspConfig dspConfig = null;
            dspConfig = iDspConfigService.getOne(new QueryWrapper<DspConfig>().eq("deleted", 0));

            List<DeliveryInfo> deliveryInfos = iDspDeliveryService.findList(member, shopId, orderReq.getTransport(), null, null);
            if (type == 2) {
                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));
            }
            if(shopId!=null){
                Shop shop = iShopService.getById(shopId);
                orderReq.setShopName(shop.getName());
            }
            for (DeliveryInfo info : deliveryInfos) {
                /*if (orderReq.getTransport().equals(0)) {
                    if (info.getType().equals(DeliveryTypeEnums.HUO_LA_LA.getType())) {
                        continue;
                    }
                } else if (orderReq.getTransport().equals(1)) {
                    if (!info.getType().equals(DeliveryTypeEnums.HUO_LA_LA.getType())) {
                        continue;
                    }
                }*/
                ValuationRes valuationRes = queryOrderDeliverFee(orderReq, info, member.getAmount(), loginId, shopId, defaultShop);
                if (valuationRes != null) {
                    valuationRes.setPreferredDelivery(info.getPreferredDelivery());
                    valuationRes.setOriginalMoney(valuationRes.getDeliveryAmount());
                    //金额折扣
//                    SysConfig sysConfig = iSysConfigService.selectSysConfigByKey("MONEY_DISCOUNT");
//                    if (sysConfig != null && StringUtils.isNotBlank(sysConfig.getConfigValue()) && valuationRes.getIsMine() == 0) {
//                        valuationRes.setDeliveryAmount(new BigDecimal(sysConfig.getConfigValue()).multiply(valuationRes.getDeliveryAmount()).divide(BigDecimal.TEN));
//                    }

                    //城市运力优惠配置
                    DeliveryCityConfig deliveryCityConfig = new DeliveryCityConfig();
                    deliveryCityConfig.setCityCode(orderReq.getSendAddress().getCityCode());
                    deliveryCityConfig.setDeliveryType(info.getType());
                    List<DeliveryCityConfig> configList = iDeliveryConfigService.queryList(deliveryCityConfig);
                    if (CollectionUtils.isEmpty(configList)) {//对应城市没配置运力优惠，查全国
                        deliveryCityConfig = iDeliveryConfigService.getOne(new QueryWrapper<DeliveryCityConfig>().eq("city_code", 0).eq("delivery_type", info.getType()));
                    } else {
                        deliveryCityConfig = configList.get(0);
                    }
                    if (deliveryCityConfig != null && StringUtils.isNotBlank(deliveryCityConfig.getConfigValue()) && valuationRes.getIsMine() == 0) {
                        if (CouponTypeEnum.ZHE_KOU.type.equals(deliveryCityConfig.getType())) {//折扣
                            valuationRes.setDeliveryAmount(new BigDecimal(deliveryCityConfig.getConfigValue()).multiply(valuationRes.getDeliveryAmount()).divide(BigDecimal.TEN));
                            valuationRes.setZk(new BigDecimal(deliveryCityConfig.getConfigValue()));
                        } else if (CouponTypeEnum.LI_JIAN.type.equals(deliveryCityConfig.getType())) {//直减
                            valuationRes.setDeliveryAmount(valuationRes.getDeliveryAmount().subtract(new BigDecimal(deliveryCityConfig.getConfigValue())));
                            valuationRes.setMj(new BigDecimal(deliveryCityConfig.getConfigValue()));
                        }
                    }


                    BigDecimal commission = BigDecimal.ZERO;
                    if (dspConfig != null && dspConfig.getCommissionRate() != null && !info.getType().equals(DeliveryTypeEnums.HUO_LA_LA.getType())) {
                        commission = dspConfig.getCommissionRate().multiply(valuationRes.getDeliveryAmount()).divide(new BigDecimal("100"));
                    }
                    valuationRes.setIsMerchant(info.getIsMerchant());
                    // 判断是否是自己的平台,是的话没有佣金
                    if (valuationRes.getIsMine() == 1) {
                        commission = BigDecimal.ZERO;
                    }
                    valuationRes.setCommission(commission);
                    valuationRes.setDeliveryAmount(commission.add(valuationRes.getDeliveryAmount()));
                    if (valuationRes.getIsMine() == 0) {
                        //校验余额是否充足
                        if (member.getAmount().compareTo(valuationRes.getDeliveryAmount()) >= 0) {
                            valuationRes.setIsEnough(StatusEnum.SHOW.status);
                        }
                    }
                }
                list.add(valuationRes);
            }
            //排序
            list.removeAll(Collections.singleton(null));
            list.sort((o1, o2) -> {
                BigDecimal i = o1.getDeliveryAmount().subtract(o2.getDeliveryAmount());
                return i.intValue();
            });
            //获取聚合配送的预估价，选最低价格展示
            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");
            }
            //查询下单设置推荐屏蔽运力

            List<ValuationRes> billList = new ArrayList<>();
            if (type == 1) {
                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);
            // Map<Integer, List<ValuationRes>> lowMap = list.stream().collect(Collectors.groupingBy(ValuationRes::getIsEnough));
            //新用户只要没有产生过订单数据的算首单
            List<Order> orderList = iOrderService.list(new QueryWrapper<Order>().eq("member_id", loginId).eq("status", PayStatusEnum.PAYED.status));
            if (CollectionUtils.isEmpty(orderList)) {
                String configValue = iSysConfigService.selectConfigByKey("NEW_COMERS");
                res.setFirstCoupon(configValue);
            }
            //闪送距离替换
            Optional<ValuationRes> optionalb = billList.stream().filter(item -> !item.getDeliveryType().equals(DeliveryTypeEnums.SHAN_SONG.getType())).findFirst();
            if (optionalb.isPresent()) {
                String desc = optionalb.get().getDesc();
                for (ValuationRes res1 : billList) {
                    if (DeliveryTypeEnums.SHAN_SONG.getType().equals(res1.getDeliveryType())) {
                        res1.setDesc(desc);
                        break;
                    }
                }
            }
            //  res.setOptionals(lowMap.get(StatusEnum.SHOW.status));
            //  res.setLowOptionals(lowMap.get(StatusEnum.STOP.status));
            res.setOptionals(billList);
            res.setSupports(supports);

            return res;
        } catch (Exception e) {
            log.error("发起计价异常", e);
            return null;
        }
    }

    private ValuationRes queryOrderDeliverFee(OrderReq orderReq, DeliveryInfo delivery, BigDecimal amount, Long memberId, Long shopId, Integer defaultShop) {
        if (DeliveryTypeEnums.SHUN_FENG.getType().equals(delivery.getType()) && "0".equals(orderReq.getProduct().getSfProductType())) {
            return null;
        }
        Member member = iMemberService.getById(memberId);
        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())) {
            ShopDelivery shopDelivery = iShopDeliveryService.findOne(shopId, delivery.getId());
            if (shopDelivery == null || !shopDelivery.getBindStatus().equals(BindStatusEnum.BIND.status)) {
                return null;
            }
        }
        if ((DeliveryTypeEnums.FENG_NIAO.getType().equals(delivery.getType()) || DeliveryTypeEnums.MEI_TUAN.getType().equals(delivery.getType())) && DefaultShopEnum.SHOW.status.equals(defaultShop.intValue())) {
            return null;
        }
        if (DeliveryTypeEnums.FENG_NIAO.getType().equals(delivery.getType()) && shopId == null) {
            return null;
        }
        // 美团跑腿未绑定不参与计价
        if (DeliveryTypeEnums.MEI_TUAN_ZB.getType().equals(delivery.getType()) && delivery.getIsMine() == 0){
            return null;
        }
        if (DeliveryTypeEnums.MEI_TUAN_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() == 2155 && (DeliveryTypeEnums.DADA.getType().equals(delivery.getType()) || DeliveryTypeEnums.DADA_YZ.getType().equals(delivery.getType()))){
            // 达达/优质余额不足，重新计价
            log.info("余额不足----" + DeliveryTypeEnums.getNameByType(delivery.getType()) + "余额不足，重新计价");
            orderVo.setMerchantId(null);
            orderVo.setShopNo(delivery.getDadaThirdShopId());
            delivery.setShopId(delivery.getDadaThirdShopId());
            resObject = client.queryOrderDeliverFee(orderVo);
        }
        if (resObject.getCode() == 0) {
            ValuationRes res = new ValuationRes();
            transResObejct(res, delivery, resObject, orderReq, orderVo);
            // 判断是否是自己平台，查询金额是否充足
            if (delivery.getIsMine() == 1 && !delivery.getType().equals(DeliveryTypeEnums.KUAI_FU.getType()) && !delivery.getType().equals(DeliveryTypeEnums.MEI_TUAN_ZB.getType())) {
                QueryAmount queryAmount = QueryAmountEntityUtils.queryAmount(delivery, member.getMerchantId(), delivery.getIsMine());
                ResObject<AmountResultVo> amountRes = client.queryAmount(queryAmount);
                if (amountRes.getCode() == 0) {
                    // 更新余额
                    AmountResultVo vo = amountRes.getData();
                    ShopDelivery shopDelivery = iShopDeliveryService.getOne(new QueryWrapper<ShopDelivery>().eq("merchant_id", member.getMerchantId()).eq("delivery_id", delivery.getId())
                            .eq("deleted", IsDeleteEnum.NORMAL.status).isNull("shop_id").eq("bind_status", 1));
                    if (shopDelivery != null) {
                        shopDelivery.setBalance(vo.getBalanceAmount());
                        iShopDeliveryService.updateById(shopDelivery);
                    }
                    if (vo.getBalanceAmount().compareTo(res.getDeliveryAmount()) >= 0) {
                        res.setIsEnough(StatusEnum.SHOW.status);
                        res.setIsMine(1);
                    } else {
                        //uupt需重新计价
                        res.setIsMine(0);
                        orderVo.setIsMine(0);
                        if ("uupt".equals(orderVo.getLbClient())) {
                            orderVo.setOpenId("");
                            resObject = client.queryOrderDeliverFee(orderVo);
                            transResObejct(res, delivery, resObject, orderReq, orderVo);
                        }

                    }
                }
            } else if (delivery.getIsMine() == 1 && delivery.getType().equals(DeliveryTypeEnums.KUAI_FU.getType())) {
                if (!resObject.getData().getFeStatus().equals("1")) {
                    res.setIsMine(0);
                    orderVo.setIsMine(0);
                }
            }
            return res;
        }
        return null;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void createOrder(Long loginId, OrderReq req, Integer type) {
        //转移到apiordernew
    }


    @Override
    public OrderMarkerDto marker(Long loginId) {
        OrderMarkerDto dto = new OrderMarkerDto();
        List<Long> shopIds = new ArrayList<>();
        Member member = iMemberService.getById(loginId);
        if (member.getMemberType().equals(MemberTypeEnum.SHOP.type)) {
            // shopIds.add(member.getShopId());
            shopIds = null;
        }
        if (member.getMemberType().equals(MemberTypeEnum.MERCHANT.type)) {
            shopIds = iShopService.getShopByMerchantId(member.getMerchantId(), null);
        }
        if (member.getMemberType().equals(MemberTypeEnum.PERSON.type)) {
            shopIds = null;
        }
        List<Order> list = new ArrayList<>();
        if (shopIds != null&&shopIds.size()>0) {
            list = iOrderService.list(new QueryWrapper<Order>().in("shop_id", shopIds).isNull("waimai_order_id"));
        } else {
            list = iOrderService.list(new QueryWrapper<Order>().eq("member_id", loginId).isNull("waimai_order_id"));
        }
        List<Order> toBeBillNum = list.stream().filter((Order detailDto) -> DeliveryStatusEnum.ORDERS_TO_BE_BILLED.status.equals(detailDto.getDeliveryStatus())).collect(Collectors.toList());
        List<Order> completedNum = list.stream().filter((Order detailDto) -> DeliveryStatusEnum.FINISH.status.equals(detailDto.getDeliveryStatus())).collect(Collectors.toList());
        List<Order> cancelNum = list.stream().filter((Order detailDto) -> DeliveryStatusEnum.CANCEL.status.equals(detailDto.getDeliveryStatus())).collect(Collectors.toList());
        List<Order> inDeliveryNum = list.stream().filter((Order detailDto) -> DeliveryStatusEnum.IN_DELIVERY.status.equals(detailDto.getDeliveryStatus())).collect(Collectors.toList());
        List<Order> toBePickedNum = list.stream().filter((Order detailDto) -> DeliveryStatusEnum.TO_BE_DELIVERED.status.equals(detailDto.getDeliveryStatus())).collect(Collectors.toList());
        List<Order> toBeReceivedNum = list.stream().filter((Order detailDto) -> DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status.equals(detailDto.getDeliveryStatus())).collect(Collectors.toList());
        List<Order> toBePaidNum = list.stream().filter((Order detailDto) -> PayStatusEnum.NO_PAYED.status.equals(detailDto.getStatus())).collect(Collectors.toList());
        dto.setToBeBillNum(toBeBillNum.size());
        dto.setCompletedNum(completedNum.size());
        dto.setCancelNum(cancelNum.size());
        dto.setInDeliveryNum(inDeliveryNum.size());
        dto.setToBePickedNum(toBePickedNum.size());
        dto.setToBeReceivedNum(toBeReceivedNum.size());
        dto.setToBePaidNum(toBePaidNum.size());
        return dto;
    }

    @Override
    public void comment(Long loginId, Long orderId, Integer rate) {
        OrderComment comment = iOrderCommentService.getOne(new QueryWrapper<OrderComment>().eq("member_id", loginId).eq("order_id", orderId));
        if (comment != null) {
            throw new CustomAppException("该订单已评价");
        }
        comment = new OrderComment();
        comment.setOrderId(orderId);
        comment.setMemberId(loginId);
        comment.setRate(rate);
        iOrderCommentService.save(comment);
    }

    @Override
    public List<OrderLog> findOrderStatus(Long loginId, Integer orderId) {
        List<OrderLog> list = iOrderLogService.list(new QueryWrapper<OrderLog>().eq("order_id", orderId));
        list = list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(
                () -> new TreeSet<>(Comparator.comparing(OrderLog::getOrderStatus))), ArrayList::new));
        list.sort((a, b) -> a.getCreateTime().compareTo(b.getCreateTime()));
        return list;
    }

    /**
     * 添加小费
     * @param loginId 当前登录用户
     * @param orderId 订单id
     * @param tipAmount 消费金额
     * @param paymentType 支付类型
     * @param createType 下单方式(0/null:APP  1:PC)
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object tips(Long loginId, Integer orderId, BigDecimal tipAmount, Integer paymentType, Integer createType) {
        Object resp = "fail";
        Order order = iOrderService.getById(orderId);
        if (order == null) {
            throw new CustomAppException("订单不存在!", 500);
        }
        if (order.getDadaDspType() != null) {
            throw new CustomAppException("达达配送商模式订单不支持加小费!", 500);
        }
        List<OrderDelivery> orderDeliverys = iOrderDeliveryService.list(new QueryWrapper<OrderDelivery>().eq("order_sn", order.getOrderSn()));
        if(orderDeliverys!=null&&orderDeliverys.size() ==1 &&"-1".equals(orderDeliverys.get(0).getOutTradeNo())){
            throw new CustomAppException("加小费失败，下单失败！", 260);
        }
        List<OrderDelivery>  orderDeliverys_new = orderDeliverys.stream().filter(orderDelivery -> StringUtils.isBlank(orderDelivery.getOutTradeNo())).collect(Collectors.toList());
             //   .isNull("out_trade_no"));
        if (orderDeliverys_new.size()>0) {
            throw new CustomAppException("请2分钟后加小费！", 260);
        }
        Member member = iMemberService.getById(loginId);
        if (member.getMemberType().equals(MemberTypeEnum.SHOP.type)) {
            member = iMemberService.getOne(new QueryWrapper<Member>().eq("member_type", MemberTypeEnum.MERCHANT.type).eq("merchant_id", member.getMerchantId()));
        }
        if (PaymentTypeEnum.BALANCE.type.equals(paymentType) && tipAmount.compareTo(member.getAmount()) > 0) {
            throw new CustomAppException("余额不足！", 250);
        }
        //加小费

        if (order.getDeliveryStatus().equals(DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status) && tipAmount.compareTo(BigDecimal.ZERO) > 0) {
            //   MemberConfig config = iMemberConfigService.getById(order.getMemberId());
            OrderTip orderTip = new OrderTip();
            orderTip.setChildOrderNo("T" + SnCodeUtils.createSn());
            orderTip.setAmount(tipAmount);
            orderTip.setOrderId(orderId);
            orderTip.setOrderNo(order.getOrderSn());
            orderTip.setPayType(paymentType);
            orderTip.setTotalAmout(tipAmount);
            if (PaymentTypeEnum.BALANCE.type.equals(paymentType)) {
                orderTip.setStatus(PayStatusEnum.PAYED.status);
            }
            iOrderTipService.save(orderTip);

            if (tipAmount.compareTo(BigDecimal.ZERO) > 0) {
                paymentService.savePayment(order.getMemberId(), order.getOrderSn(), tipAmount, paymentType, TradeTypeEnum.ADDTIP.type, null, orderTip.getChildOrderNo());
            }
            if (PaymentTypeEnum.BALANCE.type.equals(paymentType)) {
                Order updateOrder = new Order();
                updateOrder.setId(order.getId());
                iOrderDeliveryService.updateDelivery(tipAmount, order.getOrderSn());
                if (order.getTipAmount() != null) {
                    updateOrder.setTipAmount(order.getTipAmount().add(tipAmount));
                } else {
                    updateOrder.setTipAmount(tipAmount);
                }
//            order.setUseTip(StatusEnum.SHOW.status);
                updateOrder.setTotalAmount(order.getTotalAmount().add(tipAmount));
                updateOrder.setPayAmount(order.getPayAmount().add(tipAmount));
                iOrderService.updateById(updateOrder);
                //扣钱
                iMemberService.updateAmount(member.getId(), tipAmount.negate());
                iMemberBalanceLogService.saveLog(loginId, LogTypeEnum.REDUCE.type, "加小费", LogSourceEnum.CONSUMPTION.status, tipAmount, order.getMerchantId(),order.getId(), orderTip.getPayType(), member.getAmount());
                resp = "ok";
                tipScheduledExecutorService.schedule(new TipsTask(order, null, iOrderService, iDspDeliveryService, client, tipAmount, iOrderDeliveryService, iShopDeliveryService,iShopDeliveryBindService), 1, TimeUnit.SECONDS);
            } else if (PaymentTypeEnum.ZHI_FU_BAO.type.equals(paymentType) && order.getPayAmount().compareTo(BigDecimal.ZERO) > 0) {
                // PC加小费
                if (createType != null && createType == 1) {
                    resp = getPaymentQRCode(tipAmount, orderTip.getChildOrderNo(), PaymentTypeEnum.ZHI_FU_BAO.type);
                } else {
                    // APP加小费
                    order.setDeliveryStatus(DeliveryStatusEnum.ORDERS_TO_BE_BILLED.status);
                    resp = aliPayService.pay(orderTip.getChildOrderNo(), tipAmount.toString(), order.getOrderSn());
                }
            } else if (PaymentTypeEnum.WEI_XIN.type.equals(paymentType) && order.getPayAmount().compareTo(BigDecimal.ZERO) > 0) {
                // PC加小费
                if (createType != null && createType == 1) {
                    resp = getPaymentQRCode(tipAmount, orderTip.getChildOrderNo(), PaymentTypeEnum.WEI_XIN.type);
                } else {
                    // APP加小费
                    order.setDeliveryStatus(DeliveryStatusEnum.ORDERS_TO_BE_BILLED.status);
                    OrderPaySignResponse.WechatPayParam respon = null;
                    try {
                        respon = wechatPayService.pay(tipAmount, orderTip.getChildOrderNo(), orderTip.getChildOrderNo(), TradeType.APP);
                    } catch (WxPayException e) {
                      //  e.printStackTrace();
                    }
                    resp = JSONObject.toJSONString(respon);
                }
            }
        }
        return resp;
    }


    @Override
    public OrderMarkerDto oneKeyMarker(Long loginId) {
        List<Long> shopIds = new ArrayList<>();
        Member member = iMemberService.getById(loginId);
        if (member.getMemberType().equals(MemberTypeEnum.SHOP.type)) {
            shopIds.add(member.getShopId());
        }
        if (member.getMemberType().equals(MemberTypeEnum.MERCHANT.type)) {
            shopIds = iShopService.getShopByMerchantId(member.getMerchantId(), null);
        }
        OrderMarkerDto dto = new OrderMarkerDto();

        List<OrderDetailDto> list = iOrderService.findOneKeyList(member.getId(), null, null, null, null, shopIds, null, null, null);
        List<OrderDetailDto> toBeBillNum = list.stream().filter((OrderDetailDto detailDto) -> DeliveryStatusEnum.ORDERS_TO_BE_BILLED.status.equals(detailDto.getDeliveryStatus())
                && detailDto.getWmstatus() != null && !DeliveryStatusEnum.FINISH.status.equals(detailDto.getWmstatus())
                && !TakeTypeEnum.APPOINTMENT.type.equals(detailDto.getTakeType())).collect(Collectors.toList());
        List<OrderDetailDto> appointNum = list.stream().filter((OrderDetailDto detailDto) -> DeliveryStatusEnum.ORDERS_TO_BE_BILLED.status.equals(detailDto.getDeliveryStatus())
                && detailDto.getWmstatus() != null && !DeliveryStatusEnum.FINISH.status.equals(detailDto.getWmstatus())
                && TakeTypeEnum.APPOINTMENT.type.equals(detailDto.getTakeType())).collect(Collectors.toList());
        List<OrderDetailDto> completedNum = list.stream().filter((OrderDetailDto detailDto) -> DeliveryStatusEnum.FINISH.status.equals(detailDto.getDeliveryStatus()) || DeliveryStatusEnum.FINISH.status.equals(detailDto.getWmstatus())).collect(Collectors.toList());
        List<OrderDetailDto> cancelNum = list.stream().filter((OrderDetailDto detailDto) -> DeliveryStatusEnum.CANCEL.status.equals(detailDto.getDeliveryStatus()) && detailDto.getWmstatus() != null && !DeliveryStatusEnum.FINISH.status.equals(detailDto.getWmstatus())).collect(Collectors.toList());
        List<OrderDetailDto> inDeliveryNum = list.stream().filter((OrderDetailDto detailDto) -> DeliveryStatusEnum.IN_DELIVERY.status.equals(detailDto.getDeliveryStatus()) && detailDto.getWmstatus() != null && !DeliveryStatusEnum.FINISH.status.equals(detailDto.getWmstatus())).collect(Collectors.toList());
        List<OrderDetailDto> toBePickedNum = list.stream().filter((OrderDetailDto detailDto) -> DeliveryStatusEnum.TO_BE_DELIVERED.status.equals(detailDto.getDeliveryStatus()) && detailDto.getWmstatus() != null && !DeliveryStatusEnum.FINISH.status.equals(detailDto.getWmstatus())).collect(Collectors.toList());
        List<OrderDetailDto> toBeReceivedNum = list.stream().filter((OrderDetailDto detailDto) -> DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status.equals(detailDto.getDeliveryStatus()) && detailDto.getWmstatus() != null && !DeliveryStatusEnum.FINISH.status.equals(detailDto.getWmstatus())).collect(Collectors.toList());
        List<OrderDetailDto> exceptionNum = list.stream().filter((OrderDetailDto detailDto) -> DeliveryStatusEnum.ABNORMAL.status.equals(detailDto.getDeliveryStatus()) && detailDto.getWmstatus() != null && !DeliveryStatusEnum.FINISH.status.equals(detailDto.getWmstatus())).collect(Collectors.toList());
        dto.setToBeBillNum(toBeBillNum.size());
        dto.setCompletedNum(completedNum.size());
        dto.setCancelNum(cancelNum.size());
        dto.setInDeliveryNum(inDeliveryNum.size());
        dto.setToBePickedNum(toBePickedNum.size());
        dto.setToBeReceivedNum(toBeReceivedNum.size());
        dto.setAppointNum(appointNum.size());
        dto.setExceptionNum(exceptionNum.size());
        return dto;
    }


    @Override
    public List<OrderDetailDto> findOneKeyList(List<Long> shopIds, Integer status, String searchKey, Integer waimaiId, Integer shopId, Member member, String startDate, String endDate, String version) {
        List<OrderDetailDto> list = iOrderService.findOneKeyList(member.getId(), status, searchKey, waimaiId, shopId, shopIds, startDate, endDate, version);
        if (CollectionUtils.isNotEmpty(list)) {
            for (OrderDetailDto dto : list) {
                // version没有就是老版本
                if (StringUtils.isEmpty(version)) {
                    if (dto.getDeliveryStatus().equals(DeliveryStatusEnum.ABNORMAL.status)) {
                        dto.setDeliveryStatus(DeliveryStatusEnum.CANCEL.status);
                    }
                }
                // 设置门牌号,兼容app改版、老版本
                if (StringUtils.isNotBlank(dto.getSendStreet()) && StringUtils.isNotBlank(dto.getSendAddress()) && !dto.getSendAddress().endsWith(dto.getSendStreet())) {
                    dto.setSendAddress(dto.getSendAddress() + dto.getSendStreet());
                }
                if (StringUtils.isNotBlank(dto.getReceiptStreet()) && StringUtils.isNotBlank(dto.getReceiptAddress()) && !dto.getReceiptAddress().endsWith(dto.getReceiptStreet())) {
                    dto.setReceiptAddress(dto.getReceiptAddress() + dto.getReceiptStreet());
                }
/*                List<OrderLog> logs = iOrderLogService.list(new QueryWrapper<OrderLog>().eq("order_status", DeliveryStatusEnum.IN_DELIVERY.status).eq("order_id", dto.getId()));
                if (!org.springframework.util.CollectionUtils.isEmpty(logs)) {
                    dto.setTakeTime(logs.get(0).getCreateTime());
                }*/
                DspWaimai waimai = iDspWaimaiService.getById(dto.getWaimaiId());
                dto.setWaimaiLogo(waimai.getLogo());
                //查询商品详情
//                List<WaimaiOrderDetail> details = iWaimaiOrderDetailService.findList(dto.getWaimaiOrderId());
//                dto.setList(details);
//                dto.setIsMoRen(1);
//                // 判断是否是商家默认门店
//                if (dto.getShopId() == null || !dto.getShopId().equals(member.getShopId())) {
//                    dto.setIsMoRen(0);
//                }
                // 门店名称
                if (dto.getShopId() != null && StringUtils.isNull(dto.getShopName())) {
                    Shop shop = iShopService.getById(dto.getShopId());
                    if (shop != null) {
                        dto.setShopName(shop.getName());
                    }
                }
            }
        } else {
            list = new ArrayList<>();
        }
        Long merchant = null;
        if (member.getMemberType().equals(MemberTypeEnum.MERCHANT.type)) {
            merchant = member.getMerchantId();
        }
        if (member != null && member.getShopId() != null && merchant == null && redisTemplate.hasKey("shop" + member.getShopId() + "")) {
            //  if (member != null && member.getShopId() != null && redisTemplate.hasKey(member.getShopId() + "")) {
            Long size = redisTemplate.opsForList().size("shop" + member.getShopId() + "");
            log.info("外卖新订单数量：" + size);
            for (int i = 0; i < size.intValue(); i++) {
                redisTemplate.opsForList().rightPop("shop" + member.getShopId() + "");
            }
        }
        if (member != null && merchant != null && redisTemplate.hasKey("merchant" + member.getMerchantId() + "")) {
            //  if (member != null && member.getShopId() != null && redisTemplate.hasKey(member.getShopId() + "")) {
            Long size = redisTemplate.opsForList().size("merchant" + member.getMerchantId() + "");
            log.info("商家外卖新订单数量：" + size);
            for (int i = 0; i < size.intValue(); i++) {
                redisTemplate.opsForList().rightPop("merchant" + member.getMerchantId() + "");
            }
        }
//        if (member != null && member.getShopId() != null && redisTemplate.hasKey(member.getShopId() + "")) {
//            Long size = redisTemplate.opsForList().size(member.getShopId() + "");
//            for (int i = 0; i < size.intValue(); i++) {
//                redisTemplate.opsForList().rightPop(member.getShopId() + "");
//            }
//        }
        return list;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void ignore(Long loginId, Integer orderId) {
        Order order = iOrderService.getById(orderId);

        WaimaiOrder waimaiOrder = new WaimaiOrder();
        waimaiOrder.setId(order.getWaimaiOrderId());
        waimaiOrder.setStatus(DeliveryStatusEnum.FINISH.status);
        iWaimaiOrderService.updateById(waimaiOrder);

    }


    /**
     * 轮询拉取外面新订单
     *
     * @param loginId
     * @return
     */
    @Override
    public Map<String, Object> findNewList(Long loginId, List<Integer> orderIds, Integer status, String searchShopIdStr) {
        List<OrderDetailDto> list = new ArrayList<>();
        Member member = iMemberService.getById(loginId);
        if (Objects.isNull(member)) {
            throw new CustomAppException("用户不存在!");
        }
        Long shopId = member.getShopId();
        Long merchant = null;
        if (member.getMemberType().equals(MemberTypeEnum.MERCHANT.type)) {
            merchant = member.getMerchantId();
        }
        if(status == null || DeliveryStatusEnum.ORDERS_TO_BE_BILLED.status.equals(status)
                || DeliveryStatusEnum.APPOINTMENT.status.equals(status)){
            String shopNewOrderListKey = "shop" + shopId + "";
            if (member.getShopId() != null && merchant == null && redisCache.hasKey(shopNewOrderListKey)) {
                Long size = redisCache.getListSize(shopNewOrderListKey);
                log.info("外卖新订单数量：" + size);
                for (int i = 0; i < size.intValue(); i++) {
                    list.add((OrderDetailDto) redisCache.rPop(shopNewOrderListKey));
                }
            }
            String merchantNewOrderListKey = "merchant" + merchant + "";
            if (merchant != null && redisCache.hasKey(merchantNewOrderListKey)) {
                Long size = redisCache.getListSize(merchantNewOrderListKey);
                log.info("商家外卖新订单数量：" + size);
                for (int i = 0; i < size.intValue(); i++) {
                    list.add((OrderDetailDto) redisCache.rPop(merchantNewOrderListKey));
                }
            }
        } else if (DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status.equals(status)){
            String shopReceivedOrderListKey = "shop_received" + shopId + "";
            if (shopId != null && merchant == null && redisCache.hasKey(shopReceivedOrderListKey)) {
                Long size = redisCache.getListSize(shopReceivedOrderListKey);
                log.info("外卖待接单数量：" + size);
                for (int i = 0; i < size.intValue(); i++) {
                    list.add((OrderDetailDto) redisCache.rPop(shopReceivedOrderListKey));
                }
            }
            String merchantReceivedOrderListKey = "merchant_received" + merchant + "";
            if (merchant != null && redisCache.hasKey(merchantReceivedOrderListKey)) {
                Long size = redisCache.getListSize(merchantReceivedOrderListKey);
                log.info("商家待接单数量：" + size);
                for (int i = 0; i < size.intValue(); i++) {
                    list.add((OrderDetailDto) redisCache.rPop(merchantReceivedOrderListKey));
                }
            }
        }

        // 过滤已选门店的订单
        if (StringUtils.isNotEmpty(searchShopIdStr)) {
            List<Long> searchShopIds = Lists.newArrayList();
            String[] split = searchShopIdStr.split(",");
            for (String item : split) {
                searchShopIds.add(Long.valueOf(item));
            }
            if (CollectionUtils.isNotEmpty(searchShopIds) && CollectionUtils.isNotEmpty(list)) {
                list = list.stream().filter(item -> searchShopIds.contains(item.getShopId())).collect(Collectors.toList());
            }
        }

        Map<String, Object> map = new HashMap<>();
        List<Long> ids = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(orderIds)) {
            if(DeliveryStatusEnum.APPOINTMENT.status.equals(status)){
                status = DeliveryStatusEnum.ORDERS_TO_BE_BILLED.status;
            }
            List<Order> orderList = iOrderService.list(new QueryWrapper<Order>().in("id", orderIds).ne("delivery_status", status));
            ids = orderList.stream().map(Order::getId).collect(Collectors.toList());
            // 待接单状态下缓存过滤
            list = list.stream().filter(item -> !orderIds.contains(item.getId().intValue())).collect(Collectors.toList());
        }
        map.put("newList", list);
        map.put("deliveryList", ids);
        return map;
    }


    private void transResObejct(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());
    }

    @Override
    public boolean setDeliveryTime(Long loginId, Long orderId, String delayTime, Integer delayTimeType) {
        Order order = iOrderService.getById(orderId);
        boolean result = false;
        String orderkey=orderId+"_0";
        if (order != null) {
            OrderDelay orderDelay = iOrderDelayService.getOne(new QueryWrapper<OrderDelay>().eq("order_id", orderId));
            if (orderDelay != null) {
                orderDelay.setModifyNum(orderDelay.getModifyNum() + 1);
                if (delayTimeType == null || delayTimeType == 0) {
                    orderDelay.setDelayTime(new BigDecimal(delayTime));
                } else {
                    orderDelay.setDelayTimeMinute(Integer.valueOf(delayTime));
                }
                result = iOrderDelayService.updateById(orderDelay);
                orderkey = orderId+"_"+orderDelay.getModifyNum();
            } else {
                orderDelay = new OrderDelay();
                if (delayTimeType == null || delayTimeType == 0) {
                    orderDelay.setDelayTime(new BigDecimal(delayTime));
                } else {
                    orderDelay.setDelayTimeMinute(Integer.valueOf(delayTime));
                }
                orderDelay.setCreateTime(new Date());
                orderDelay.setOrderId(orderId);
                result = iOrderDelayService.save(orderDelay);
            }
            if (result&&order.getWaimaiOrderId()!=null) {
                WaimaiOrder waimaiOrder = iWaimaiOrderService.getById(order.getWaimaiOrderId());
                long deliveryTime =waimaiOrder.getDeliveryTime()* 1000L;
                Date exceptTime;
                if (delayTimeType == null || delayTimeType == 0) {
                    exceptTime = com.ydd.third.common.utils.DateUtils.addDateMinutes(new Date(deliveryTime),- new BigDecimal(delayTime).multiply(new BigDecimal("60")).intValue());
                } else {
                    exceptTime = com.ydd.third.common.utils.DateUtils.addDateMinutes(new Date(deliveryTime), - Integer.parseInt(delayTime));
                }
                long diff =  exceptTime.getTime()-new Date().getTime();
                //int delay = new BigDecimal(delayTime).multiply(new BigDecimal("3600")).multiply(new BigDecimal("1000")).intValue();
                if(diff>=0){
                    log.info("延时发送时间"+diff);
                    rabbitSender.sendDelay(orderkey, "delay.waimai", (int) diff);
                }
            }
        }
        return result;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void cancelTimingPublish(Long orderId) {
        Order order = iOrderService.getOne(new QueryWrapper<Order>().eq("id", orderId));
        if (Objects.isNull(order)) {
            throw new CustomException("订单不存在!");
        }
        if (!DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(order.getDeliveryStatus())) {
            throw new CustomException("只有待发单状态才可以取消定时发单!");
        }
        if (order.getAutoDeliveryMinutes() != null && order.getAutoDeliveryMinutes() != 0) {
            iOrderService.update(new UpdateWrapper<Order>()
                    .set("auto_delivery_minutes", 0)
                    .eq("id", orderId));
        }
        iOrderDelayService.update(new UpdateWrapper<OrderDelay>()
                .set("deleted", 1)
                .eq("order_id", orderId));
    }

    @Override
    public PageResult getOrderList(OrderListRequest request) {
        Member member = iMemberService.getById(request.getMemberId());
        if (Objects.isNull(member)) {
            throw new CustomException("用户不存在!");
        }
        // 缓存搜索记录
        this.cacheSearchWord(request);
        // 处理查询条件
        this.handleSearchCondition(request, member);
        Page<OrderListDto> page = iOrderService.getOrderList(request, new Page<>(request.getPageNum(), request.getPageSize()));
        List<OrderListDto> list = page.getRecords();
        // 获取订单日志信息
        Map<Long, List<OrderLog>> orderLogMap = new HashMap<>();
        // 获取订单延迟发单信息
        Map<Long, List<OrderDelay>> orderDelayMap = new HashMap<>();
        if (CollectionUtils.isNotEmpty(list)){
            List<Long> orderIds = list.stream().map(OrderListDto::getId).collect(Collectors.toList());
            List<OrderLog> orderLogs = iOrderLogService.getOrderLogByOrderIds(orderIds);
            orderLogMap = orderLogs.stream().collect(Collectors.groupingBy(OrderLog::getOrderId));

            orderDelayMap = iOrderDelayService.list(new QueryWrapper<OrderDelay>()
                    .in("order_id", orderIds)
                    .eq("deleted", 0)).stream().collect(Collectors.groupingBy(OrderDelay::getOrderId));
        }
        // 获取外卖商品的种类以及总件数
        List<Long> waimaiOrderIds = list.stream().map(OrderListDto::getWaimaiOrderId).collect(Collectors.toList());
        Map<Long, List<WaimaiOrderDetail>> orderDetailMap = new HashMap<>();
        if (CollectionUtils.isNotEmpty(waimaiOrderIds)) {
            orderDetailMap = iWaimaiOrderDetailService.list(new QueryWrapper<WaimaiOrderDetail>()
                    .in("waimai_order_id", waimaiOrderIds)
                    .eq("deleted", 0))
                    .stream()
                    .collect(Collectors.groupingBy(WaimaiOrderDetail::getWaimaiOrderId));
        }
        // 获取外卖门店
        List<Long> shopIds = list.stream().filter(item -> item.getShopId() != null).map(OrderListDto::getShopId).collect(Collectors.toList());
        Map<String, List<ShopWaimai>> shopWaiMaiMap = new HashMap<>();
        if (CollectionUtils.isNotEmpty(shopIds)) {
            shopWaiMaiMap = iShopWaimaiService.list(new QueryWrapper<ShopWaimai>()
                    .in("shop_id", shopIds)
                    .eq("bind_status", 1)
                    .eq("deleted", 0))
                    .stream()
                    .collect(Collectors.groupingBy(item -> item.getShopId() + "-" + item.getWaimaiId()));
        }
        // 待接单状态下获取运力
        Map<String, List<OrderDelivery>> deliveryMap = new HashMap<>();
        if ((request.getSearchType() != null && request.getSearchType() == 0 && request.getStatus() == OrderListRequest.OrderListSearchStatusEnum.ORDERS_TO_BE_RECEIVED)
                || (request.getSearchType() != null && request.getSearchType() == 1)
                || (request.getSearchType() != null && request.getSearchType() == 2 && request.getSearchStatusItem().isToBeReceivedOrder())) {
            List<String> orderSns = list.stream().filter(item -> item.getOrderSn() != null && item.getDeliveryStatus() == 1).map(OrderListDto::getOrderSn).collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(orderSns)) {
                deliveryMap = iOrderDeliveryService.list(new QueryWrapper<OrderDelivery>()
                        .in("order_sn", orderSns)
                        .eq("deleted", 0))
                        .stream()
                        .collect(Collectors.groupingBy(OrderDelivery::getOrderSn));
            }
        }
        for (OrderListDto dto : list) {
            if (dto.getWaimaiOrderId() != null) {
                DspWaimai waiMai = iDspWaimaiService.getById(dto.getWaimaiId());
                dto.setLogo(Objects.isNull(waiMai) ? "" : waiMai.getLogo());
            } else if (dto.getPlatformType() != 0) {
                // 手动发外卖单
                String logo = iDspWaimaiService.selectLogoByType(dto.getPlatformType());
                dto.setLogo(logo);
            } else {
                dto.setLogo(AppConstant.LIE_BAO_LOGO);
            }
            if (dto.getShopId() != null && StringUtils.isNull(dto.getShopName())) {
                Shop shop = iShopService.getById(dto.getShopId());
                dto.setShopName(Objects.isNull(shop) ? "" : shop.getName());
            }
            // 设置运力logo
            if (deliveryMap != null && CollectionUtils.isNotEmpty(deliveryMap.get(dto.getOrderSn()))) {
                List<OrderDelivery> orderDeliveries = deliveryMap.get(dto.getOrderSn());
                List<String> logos = orderDeliveries.stream().map(OrderDelivery::getDeliveryLogo).collect(Collectors.toList());
                dto.setDeliveryLogos(logos);
            }
            // 设置外卖门店名称
            if (shopWaiMaiMap != null && shopWaiMaiMap.size() > 0 && dto.getShopId() != null && dto.getWaimaiId() != null) {
                List<ShopWaimai> shopWaimais = shopWaiMaiMap.get(dto.getShopId() + "-" + dto.getWaimaiId());
                if (CollectionUtils.isNotEmpty(shopWaimais) && shopWaimais.get(0) != null) {
                    dto.setWaimaiShopName(shopWaimais.get(0).getThirdShopName());
                }
            }
            // 设置外卖订单件数
            if (orderDetailMap != null && CollectionUtils.isNotEmpty(orderDetailMap.get(dto.getWaimaiOrderId()))){
                List<WaimaiOrderDetail> orderDetailList = orderDetailMap.get(dto.getWaimaiOrderId());
                long totalNum = orderDetailList.stream().mapToLong(WaimaiOrderDetail::getQuantity).sum();
                dto.setSkuNum(orderDetailList.size());
                dto.setTotalNum(totalNum);
            }
            // 计算外卖单用户期望送达时间
            if (dto.getWmDeliveryTime() != null && dto.getWmDeliveryTime() != 0) {
                dto.setExceptTime(new Date(dto.getWmDeliveryTime() * 1000L));
            }
            // 设置相关操作时间
            if (orderLogMap.size() > 0) {
                this.setOrderTime(dto, orderLogMap);
            }
            // 设置发件详细地址(发单计价用)
            if (dto.getSendStreet() == null && dto.getSendAddressId() != null && DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(dto.getDeliveryStatus())) {
                MemberAddress memberAddress = iMemberAddressService.findById(request.getMemberId(), dto.getSendAddressId());
                dto.setSendStreet(memberAddress != null ? memberAddress.getStreet() : "");
            }
            // 设置收件详细地址(发单计价用)
            if (dto.getReceiptStreet() == null && dto.getReceiptAddressId() != null && DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(dto.getDeliveryStatus())) {
                MemberAddress memberAddress = iMemberAddressService.findById(request.getMemberId(), dto.getReceiptAddressId());
                dto.setReceiptStreet(memberAddress != null ? memberAddress.getStreet() : "");
            }
            OrderDelay orderDelay = null;
            if (orderDelayMap != null && CollectionUtils.isNotEmpty(orderDelayMap.get(dto.getId()))) {
                List<OrderDelay> orderDelays = orderDelayMap.get(dto.getId());
                if (CollectionUtils.isNotEmpty(orderDelays) && orderDelays.get(0) != null) {
                    orderDelay = orderDelays.get(0);
                }
            }
            // 外卖预约单
            if (dto.getTakeType() > 0 && dto.getWaimaiOrderId() != null) {
                this.setDelayTime(orderDelay, dto, null);
            }
            // 设置按钮状态
            dto.setButtonStatus(this.getButtonStatus(dto));
        }
        this.removeOrderCache(request.getStatus(), member.getShopId(), member.getMerchantId());
        return new PageResult(page);
    }

    private void setDelayTime(OrderDelay orderDelay, OrderListDto listDto, OrderInfoDto infoDto) {
        if (listDto != null) {
            // 设置过下单快照
            if (listDto.getAutoDeliveryMinutes() != null && listDto.getAutoDeliveryMinutes() != 0) {
                listDto.setDelayMinutes(listDto.getAutoDeliveryMinutes());
                listDto.setAutoDeliveryTime(new Date((listDto.getWmDeliveryTime() - (listDto.getDelayMinutes() * 60)) * 1000L));
            }
            // 设置过延迟发单
            if (orderDelay != null) {
                if (orderDelay.getDelayTime() != null) {
                    // 兼容pc老版本
                    listDto.setDelayTime(orderDelay.getDelayTime());
                    // 老版本设置的小时，转化为分钟
                    listDto.setDelayMinutes(orderDelay.getDelayTime().multiply(new BigDecimal(60)).intValue());
                } else if (orderDelay.getDelayTimeMinute() != null && orderDelay.getDelayTimeMinute() != 0) {
                    // 新版本设置的延迟分钟
                    listDto.setDelayMinutes(orderDelay.getDelayTimeMinute());
                }
                listDto.setAutoDeliveryTime(new Date((listDto.getWmDeliveryTime() - (listDto.getDelayMinutes() * 60)) * 1000L));
                return;
            }
            // 有总配置
            MemberConfig memberConfig = iMemberConfigService.getShopMemberConfig(listDto.getShopId(), listDto.getMemberId());
            if (memberConfig != null && memberConfig.getOpenBookingAutodelivery() != null && memberConfig.getOpenBookingAutodelivery() == 1
                    && memberConfig.getBookingAutodeliveryOrderTime() != null && memberConfig.getBookingAutodeliveryOrderTime() != 0) {
                listDto.setDelayMinutes(memberConfig.getBookingAutodeliveryOrderTime() / 60);
                return;
            }
            // 以上都不满足, 设置默认值
            listDto.setDelayMinutes(AppConstant.AUTO_DELIVERY_ADVANCE_MINUTES);
        }
        if (infoDto != null) {
            // 设置过下单快照
            if (infoDto.getAutoDeliveryMinutes() != null && infoDto.getAutoDeliveryMinutes() != 0) {
                infoDto.setDelayMinutes(infoDto.getAutoDeliveryMinutes());
                infoDto.setAutoDeliveryTime(new Date((infoDto.getWmDeliveryTime() - (infoDto.getDelayMinutes() * 60)) * 1000L));
            }
            // 设置过延迟发单
            if (orderDelay != null) {
                if (orderDelay.getDelayTime() != null) {
                    // 老版本设置的小时，转化为分钟
                    infoDto.setDelayMinutes(orderDelay.getDelayTime().multiply(new BigDecimal(60)).intValue());
                } else if (orderDelay.getDelayTimeMinute() != null && orderDelay.getDelayTimeMinute() != 0) {
                    // 新版本设置的延迟分钟
                    infoDto.setDelayMinutes(orderDelay.getDelayTimeMinute());
                }
                infoDto.setAutoDeliveryTime(new Date((infoDto.getWmDeliveryTime() - (infoDto.getDelayMinutes() * 60)) * 1000L));
                return;
            }
            // 走总配置
            MemberConfig memberConfig = iMemberConfigService.getShopMemberConfig(infoDto.getShopId(), infoDto.getMemberId());
            if (memberConfig != null && memberConfig.getOpenBookingAutodelivery() != null && memberConfig.getOpenBookingAutodelivery() == 1
                    && memberConfig.getBookingAutodeliveryOrderTime() != null && memberConfig.getBookingAutodeliveryOrderTime() != 0) {
                infoDto.setDelayMinutes(memberConfig.getBookingAutodeliveryOrderTime() / 60);
                return;
            }
            // 以上都不满足, 设置默认值
            infoDto.setDelayMinutes(AppConstant.AUTO_DELIVERY_ADVANCE_MINUTES);
        }
    }

    private void cacheSearchWord(OrderListRequest request) {
        try {
            if (request.getSearchType() != null && StringUtils.isNotBlank(request.getSearchKey())) {
                String key = RedisKeyConstant.ORDER_LIST_SEARCH + request.getMemberId();
                List<OrderListSearchCacheDto> searchWordsCacheList = this.getSearchHistory(request.getMemberId());
                OrderListSearchCacheDto searchCacheDto = OrderListSearchCacheDto.builder().searchKey(request.getSearchKey()).searchKeyType(request.getSearchKeyType()).build();
                // 默认每个用户缓存10条不重复的搜索记录
                if (redisCache.hasKey(key) && redisCache.zSetSize(key) >= 10 && !searchWordsCacheList.contains(searchCacheDto)) {
                    redisCache.zSetRemove(key, 0, 0);
                }
                redisCache.zSetAdd(key, searchCacheDto);
            }
        } catch (Exception e) {
            log.error("添加订单搜索记录缓存失败!");
        }
    }

    private void setOrderTime(OrderListDto dto, Map<Long, List<OrderLog>> orderLogMap) {
        List<OrderLog> orderLogs = orderLogMap.get(dto.getId());
        if (CollectionUtils.isNotEmpty(orderLogs)) {
//            List<OrderLog> distinctList = orderLogs.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(OrderLog::getOrderId))), ArrayList::new));
            List<OrderLog> toBeReceiveList = orderLogs.stream().filter(item -> DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status.equals(item.getOrderStatus())).sorted(Comparator.comparing(OrderLog::getCreateTime)).collect(Collectors.toList());
            List<OrderLog> toBeDeliveredList = orderLogs.stream().filter(item -> DeliveryStatusEnum.TO_BE_DELIVERED.status.equals(item.getOrderStatus())).sorted(Comparator.comparing(OrderLog::getCreateTime)).collect(Collectors.toList());
            List<OrderLog> cancelList = orderLogs.stream().filter(item -> DeliveryStatusEnum.CANCEL.status.equals(item.getOrderStatus()) || DeliveryStatusEnum.ABNORMAL.status.equals(item.getOrderStatus())).collect(Collectors.toList());
            List<OrderLog> finishList = orderLogs.stream().filter(item -> DeliveryStatusEnum.FINISH.status.equals(item.getOrderStatus())).collect(Collectors.toList());
            List<OrderLog> inDeliveredList = orderLogs.stream().filter(item -> DeliveryStatusEnum.IN_DELIVERY.status.equals(item.getOrderStatus())).sorted(Comparator.comparing(OrderLog::getCreateTime)).collect(Collectors.toList());
            // 发单时间
            dto.setSendTime(CollectionUtils.isNotEmpty(toBeReceiveList) ? toBeReceiveList.get(0).getCreateTime() : null);
            // 取消时间
            dto.setCancelTime(CollectionUtils.isNotEmpty(cancelList) ? cancelList.get(0).getCreateTime() : null);
            // 完成时间
            dto.setFinishTime(CollectionUtils.isNotEmpty(finishList) ? finishList.get(0).getCreateTime() : null);
            // 骑手接单时间
            dto.setShipperReceiveTime(CollectionUtils.isEmpty(toBeDeliveredList) ? null : toBeDeliveredList.get(0).getCreateTime());
            // 骑手取货时间
            dto.setShipperTakeTime(CollectionUtils.isEmpty(inDeliveredList) ? null : inDeliveredList.get(0).getCreateTime());
        }
    }

    /**
     * 清除订单缓存
     */
    private void removeOrderCache(Integer status, Long shopId, Long merchantId) {
        // 新订单、预约单
        if (DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(status)
                || DeliveryStatusEnum.APPOINTMENT.getStatus().equals(status)) {
            String shopNewOrderListKey = "shop" + shopId + "";
            if (shopId != null && merchantId == null && redisCache.hasKey(shopNewOrderListKey)) {
                Long size = redisCache.getListSize(shopNewOrderListKey);
                log.info("外卖新订单数量：" + size);
                for (int i = 0; i < size.intValue(); i++) {
                    redisCache.rPop(shopNewOrderListKey);
                }
            }
            String merchantNewOrderListKey = "merchant" + merchantId + "";
            if (merchantId != null && redisCache.hasKey(merchantNewOrderListKey)) {
                Long size = redisCache.getListSize(merchantNewOrderListKey);
                log.info("商家外卖新订单数量：" + size);
                for (int i = 0; i < size.intValue(); i++) {
                    redisCache.rPop(merchantNewOrderListKey);
                }
            }
        }
        // 待接单
        if (DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.getStatus().equals(status)) {
            String shopReceivedOrderListKey = "shop_received" + shopId + "";
            if (shopId != null && merchantId == null && redisCache.hasKey(shopReceivedOrderListKey)) {
                Long size = redisCache.getListSize(shopReceivedOrderListKey);
                log.info("外卖待接单数量：" + size);
                for (int i = 0; i < size.intValue(); i++) {
                    redisCache.rPop(shopReceivedOrderListKey);
                }
            }
            String merchantReceivedOrderListKey = "merchant_received" + merchantId + "";
            if (merchantId != null && redisCache.hasKey(merchantReceivedOrderListKey)) {
                Long size = redisCache.getListSize(merchantReceivedOrderListKey);
                log.info("商家待接单数量：" + size);
                for (int i = 0; i < size.intValue(); i++) {
                    redisCache.rPop(merchantReceivedOrderListKey);
                }
            }
        }
    }

    private Integer getButtonStatus(OrderListDto item) {
        if (DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(item.getDeliveryStatus())
                && item.getWmstatus() != null && item.getWmstatus() != 4
                && item.getTakeType()!= null && TakeTypeEnum.NOW.getType().equals(item.getTakeType())) {
            // 新订单
            return 0;
        } else if (DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(item.getDeliveryStatus())
                && item.getTakeType() != null && !TakeTypeEnum.NOW.getType().equals(item.getTakeType())
                && (item.getWaimaiOrderId() == null || (item.getWaimaiOrderId() != null && item.getWmstatus() != null && item.getWmstatus() != 4))) {
            // 预约单
            return 10;
        } else if ((item.getWaimaiOrderId() == null && DeliveryStatusEnum.ABNORMAL.getStatus().equals(item.getDeliveryStatus()))
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.ABNORMAL.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != null && item.getWmstatus() != 4)) {
            // 异常单
            return -2;
        } else if ((item.getWaimaiOrderId() == null && DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.getStatus().equals(item.getDeliveryStatus()))
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != null && item.getWmstatus() != 4)) {
            // 待接单
            return 1;
        } else if ((item.getWaimaiOrderId() == null && DeliveryStatusEnum.TO_BE_DELIVERED.getStatus().equals(item.getDeliveryStatus()))
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.TO_BE_DELIVERED.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != null && item.getWmstatus() != 4)) {
            // 取货中
            return 2;
        } else if ((item.getWaimaiOrderId() == null && DeliveryStatusEnum.IN_DELIVERY.getStatus().equals(item.getDeliveryStatus()))
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.IN_DELIVERY.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != null && item.getWmstatus() != 4)) {
            // 配送中
            return 3;
        } else if (item.getWaimaiOrderId() == null && DeliveryStatusEnum.CANCEL.getStatus().equals(item.getDeliveryStatus())
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.CANCEL.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != 4)) {
            // 已取消
            return -1;
        } else if (DeliveryStatusEnum.FINISH.getStatus().equals(item.getDeliveryStatus())) {
            // 本平台完成
            return 97;
        } else if (item.getWaimaiOrderId() != null && item.getWmstatus() == 4 && !DeliveryStatusEnum.FINISH.getStatus().equals(item.getDeliveryStatus())) {
            // 其他平台完成
            return 98;
        }
        return null;
    }

    private void handleSearchCondition(OrderListRequest request, Member member) {
        List<Long> shopIds = Lists.newArrayList();
        request.setMemberType(member.getMemberType());
        if (MemberTypeEnum.SHOP.type.equals(member.getMemberType())) {
            shopIds.add(member.getShopId());
        } else if (MemberTypeEnum.MERCHANT.type.equals(member.getMemberType())) {
            shopIds = iShopService.getShopByMerchantId(member.getMerchantId(), null);
        }

        // 门店查询
        List<Long> searchShopIds = Lists.newArrayList();
        String searchShopIdStr = request.getSearchShopIdStr();
        if (StringUtils.isNotEmpty(searchShopIdStr)) {
            String[] split = searchShopIdStr.split(",");
            for (String shopId : split) {
                searchShopIds.add(Long.valueOf(shopId));
            }
        }
        if (CollectionUtils.isNotEmpty(shopIds) && CollectionUtils.isNotEmpty(searchShopIds)) {
            shopIds.retainAll(searchShopIds);
        }
        request.setShopIds(shopIds);
        // 处理日期
        if (StringUtils.isNotEmpty(request.getStartDate())) {
            String startDateBeginTime = DateUtils.parseToBeginTime(request.getStartDate());
            request.setStartDate(startDateBeginTime);
        }
        if (StringUtils.isNotEmpty(request.getEndDate())) {
            String tomorrowBeginTime = DateUtils.parseToTomorrowBeginTime(request.getEndDate());
            request.setEndDate(tomorrowBeginTime);
        }
        String lastDayTime = DateUtils.addDaysToTimeStr(new Date(), -3, DateUtils.yyyyMMdd000000);
        // 非个人用户，近三日是否有进行中的个人订单(即申请成为商家前的订单)
        if (!MemberTypeEnum.PERSON.type.equals(member.getMemberType())) {
            Integer count = iOrderService.countPersonalOrder(lastDayTime, member.getId());
            request.setHasPersonalOrder(count != null && count > 0);
        }
        log.info("用户类型: {}, memberId: {}, 个人订单数量: {}", member.getMemberType(), member.getId(), request.isHasPersonalOrder());
        // 订单列表已取消状态，只查询近三天,
        if (request.getSearchType() == 0 && request.getStatus() == -1) {
            request.setCancelTime(lastDayTime);
        }
        // 近三日订单
        if (request.getSearchType() == 0 && request.getStatus() == OrderListRequest.OrderListSearchStatusEnum.LAST_THREE_DAYS) {
            request.setLastDayTime(lastDayTime);
        }
        // 近七日订单(完成/取消)
        if (request.getSearchType() == 0 && request.getStatus() == OrderListRequest.OrderListSearchStatusEnum.LAST_SEVEN_FINISH_OR_CANCEL) {
            lastDayTime = DateUtils.addDaysToTimeStr(new Date(), -7, DateUtils.yyyyMMdd000000);
            request.setLastDayTime(lastDayTime);
        }
        // APP历史订单查询, 状态检索
        List<Integer> searchStatusList = Lists.newArrayList();
        String searchStatusStr = request.getSearchStatusStr();
        if (request.getSearchType() != null && request.getSearchType() == 2) {
            // 查询日期默认90天
            if (StringUtils.isEmpty(request.getStartDate()) || StringUtils.isEmpty(request.getEndDate())) {
                String startDateBeginTime = DateUtils.parseToBeginTime(DateUtils.addDaysToTimeStr(new Date(), -90, DateUtils.YYYY_MM_DD));
                request.setStartDate(startDateBeginTime);
                String endDateBeginTime = DateUtils.parseToTomorrowBeginTime(DateUtils.dateTime(new Date()));
                request.setEndDate(endDateBeginTime);
            }
            OrderListRequest.SearchStatusItem searchStatusItem = new OrderListRequest.SearchStatusItem();
            if (StringUtils.isNotEmpty(searchStatusStr)) {
                String[] split = searchStatusStr.split(",");
                for (String status : split) {
                    searchStatusList.add(Integer.valueOf(status));
                }
                if (CollectionUtils.isNotEmpty(searchStatusList)) {
                    searchStatusItem.setNewOrder(searchStatusList.contains(OrderListRequest.OrderListSearchStatusEnum.NEW_ORDER));
                    searchStatusItem.setBookingOrder(searchStatusList.contains(OrderListRequest.OrderListSearchStatusEnum.BOOKING_ORDER));
                    searchStatusItem.setToBeReceivedOrder(searchStatusList.contains(OrderListRequest.OrderListSearchStatusEnum.ORDERS_TO_BE_RECEIVED));
                    searchStatusItem.setToBeDeliveredOrder(searchStatusList.contains(OrderListRequest.OrderListSearchStatusEnum.TO_BE_DELIVERED));
                    searchStatusItem.setInDeliveryOrder(searchStatusList.contains(OrderListRequest.OrderListSearchStatusEnum.IN_DELIVERY));
                    searchStatusItem.setAbnormalOrder(searchStatusList.contains(OrderListRequest.OrderListSearchStatusEnum.ABNORMAL));
                    searchStatusItem.setFinishOrder(searchStatusList.contains(OrderListRequest.OrderListSearchStatusEnum.FINISH));
                    searchStatusItem.setCancelOrder(searchStatusList.contains(OrderListRequest.OrderListSearchStatusEnum.CANCEL));
                }
            } else {
                searchStatusItem.setNewOrder(true);
                searchStatusItem.setBookingOrder(true);
                searchStatusItem.setToBeReceivedOrder(true);
                searchStatusItem.setToBeDeliveredOrder(true);
                searchStatusItem.setInDeliveryOrder(true);
                searchStatusItem.setAbnormalOrder(true);
                searchStatusItem.setFinishOrder(true);
                searchStatusItem.setCancelOrder(true);
            }
            request.setSearchStatusItem(searchStatusItem);
        }
    }

    @Override
    public OrderTrackDto getOrderTrack(Long orderId) {
        Order order = iOrderService.getById(orderId);
        if (Objects.isNull(order)) {
            log.error("订单不存在, orderId: {}", orderId);
            throw new CustomException("订单不存在!");
        }
        OrderTrackDto orderTrackDto = new OrderTrackDto();
        BeanUtils.copyProperties(order, orderTrackDto);
        orderTrackDto.setOrderId(orderId);
        orderTrackDto.setDeliveryOrderSn(order.getOutTradeNo());
        List<OrderLog> orderLogs = iOrderLogService.getOrderLogListByOrderId(orderId);
        List<OrderTrackDto.OrderTrackItem> orderTrackItems = orderLogs.stream().map(orderLog -> {
            OrderTrackDto.OrderTrackItem orderTrackItem = new OrderTrackDto.OrderTrackItem();
            orderTrackItem.setId(orderLog.getId());
            orderTrackItem.setOrderStatus(orderLog.getOrderStatus());
            orderTrackItem.setNodeTime(orderLog.getCreateTime());
            return orderTrackItem;
        }).collect(Collectors.toList());
        if (order.getWaimaiOrderId() != null) {
            WaimaiOrder waimaiOrder = iWaimaiOrderService.getById(order.getWaimaiOrderId());
            if (waimaiOrder != null) {
                // 外卖单用户下单时间
                OrderTrackDto.OrderTrackItem orderTrackItem1 = new OrderTrackDto.OrderTrackItem();
                orderTrackItem1.setId(0L);
                orderTrackItem1.setOrderStatus(99);
                orderTrackItem1.setNodeTime(waimaiOrder.getOrderTime());
                orderTrackItems.add(orderTrackItem1);
                // 其他平台完成
                if (order.getDeliveryStatus() != 4 && waimaiOrder.getStatus() != null && waimaiOrder.getStatus() == 4) {
                    OrderTrackDto.OrderTrackItem orderTrackItem2 = new OrderTrackDto.OrderTrackItem();
                    orderTrackItem1.setId(Long.MAX_VALUE);
                    orderTrackItem2.setOrderStatus(98);
                    orderTrackItem2.setNodeTime(waimaiOrder.getUpdateTime());
                    orderTrackItems.add(orderTrackItem2);
                }
            }
        }
        orderTrackItems = orderTrackItems.stream().sorted((Comparator.comparing(OrderTrackDto.OrderTrackItem::getNodeTime).reversed().thenComparing(OrderTrackDto.OrderTrackItem::getId, Comparator.reverseOrder()))).collect(Collectors.toList());
        orderTrackDto.setItemList(orderTrackItems);

        List<OrderLog> toBeDeliveredList = orderLogs.stream().filter(item -> DeliveryStatusEnum.TO_BE_DELIVERED.status.equals(item.getOrderStatus())).collect(Collectors.toList());
        // 骑手接单时间
        orderTrackDto.setReceiveTime(CollectionUtils.isEmpty(toBeDeliveredList) ? null : toBeDeliveredList.get(0).getCreateTime());
        // 商家发单时间
        List<OrderLog> toBeReceivedList = orderLogs.stream().filter(item -> DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status.equals(item.getOrderStatus())).collect(Collectors.toList());
        orderTrackDto.setSendTime(CollectionUtils.isEmpty(toBeReceivedList) ? null : toBeReceivedList.get(0).getCreateTime());

        if (!DeliveryStatusEnum.ORDERS_TO_BE_BILLED.status.equals(order.getDeliveryStatus()) &&
                !DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status.equals(order.getDeliveryStatus())) {
            DspDelivery delivery = iDspDeliveryService.getById(order.getDeliveryId());
            // 平台信息
            if (!Objects.isNull(delivery)) {
                orderTrackDto.setDeliveryLogo(delivery.getLogo());
                orderTrackDto.setDeliveryName(delivery.getName());
                orderTrackDto.setCustomerPhone(delivery.getCustomerPhone());
            }
        }
        return orderTrackDto;
    }

    @Override
    public OrderDetailNewDto getOrderDetail(Long orderId, Long loginId) {
        Order order = iOrderService.getById(orderId);
        if (Objects.isNull(order)) {
            log.error("订单不存在, orderId: {}", orderId);
            throw new CustomException("订单不存在!");
        }
        OrderDetailNewDto orderDetailNewDto = new OrderDetailNewDto();
        BeanUtils.copyProperties(order, orderDetailNewDto);
        orderDetailNewDto.setOrderId(order.getId());
        if (order.getWaimaiOrderId() != null && order.getWaimaiOrderId() != 0) {
            WaimaiOrder waimaiOrder = iWaimaiOrderService.getById(order.getWaimaiOrderId());
            orderDetailNewDto.setCaution(waimaiOrder.getCaution());
            orderDetailNewDto.setDaySeq(waimaiOrder.getDaySeq());
            orderDetailNewDto.setInvoiceTitle(waimaiOrder.getInvoiceTitle());
            orderDetailNewDto.setTaxpayerId(waimaiOrder.getTaxpayerId());
            orderDetailNewDto.setOrderType(waimaiOrder.getOrderType());
            orderDetailNewDto.setOrderTime(waimaiOrder.getOrderTime());
            orderDetailNewDto.setOutOrderId(waimaiOrder.getOutOrderId());
            orderDetailNewDto.setProductAmount(waimaiOrder.getTotalPrice());
            if (waimaiOrder.getDeliveryTime() != null && waimaiOrder.getDeliveryTime() != 0) {
                orderDetailNewDto.setExceptTime(new Date(waimaiOrder.getDeliveryTime() * 1000L));
            }
            List<WaimaiOrderDetail> waimaiOrderDetails = iWaimaiOrderDetailService.findList(order.getWaimaiOrderId());
            MemberConfigDto memberConfig = iMemberConfigService.findDetail(loginId);
            boolean showFoodImg = memberConfig == null || memberConfig.getShowFoodImg() == 1;
            List<OrderDetailNewDto.OrderDetailItem> orderDetailItems = waimaiOrderDetails.stream().map(waimaiOrderDetail -> {
                OrderDetailNewDto.OrderDetailItem orderDetailItem = new OrderDetailNewDto.OrderDetailItem();
                orderDetailItem.setFoodName(waimaiOrderDetail.getFoodName());
                orderDetailItem.setQuantity(waimaiOrderDetail.getQuantity());
                if (showFoodImg) {
                    WaimaiFoodImg waimaiFoodImg = iWaimaiFoodImgService.getOne(new QueryWrapper<WaimaiFoodImg>()
                            .eq("sku_id", waimaiOrderDetail.getSkuId())
                            .eq("waimai_id", waimaiOrder.getWaimaiId())
                            .eq("shop_id", order.getShopId())
                            .eq("deleted", 0));
                    orderDetailItem.setFoodPic(Objects.isNull(waimaiFoodImg) ? "" : waimaiFoodImg.getImg());
                }
                return orderDetailItem;
            }).collect(Collectors.toList());
            orderDetailNewDto.setDetailItems(orderDetailItems);
        }
        return orderDetailNewDto;
    }

    @Override
    public OrderMarkerDto getOrderMarker(Long memberId, OrderMarkerRequest request) {
        Member member = iMemberService.getById(memberId);
        if (Objects.isNull(member)) {
            throw new CustomException("用户不存在!");
        }
        // 用户类型处理
        List<Long> shopIds = Lists.newArrayList();
        if (MemberTypeEnum.SHOP.type.equals(member.getMemberType())) {
            shopIds.add(member.getShopId());
        } else if (MemberTypeEnum.MERCHANT.type.equals(member.getMemberType())) {
            shopIds = iShopService.getShopByMerchantId(member.getMerchantId(), null);
        }

        // 固定门店
        List<Long> searchShopIds = Lists.newArrayList();
        String searchShopIdStr = request.getSearchShopIdStr();
        if (StringUtils.isNotEmpty(searchShopIdStr)) {
            String[] split = searchShopIdStr.split(",");
            for (String shopId : split) {
                searchShopIds.add(Long.valueOf(shopId));
            }
        }
        if (CollectionUtils.isNotEmpty(shopIds) && CollectionUtils.isNotEmpty(searchShopIds)) {
            shopIds.retainAll(searchShopIds);
        }

        if (!MemberTypeEnum.PERSON.type.equals(member.getMemberType()) && CollectionUtils.isEmpty(shopIds)) {
            return OrderMarkerDto.builder().appointNum(0).cancelNum(0).exceptionNum(0).InDeliveryNum(0)
                    .toBeBillNum(0).toBePickedNum(0).toBeReceivedNum(0).completedNum(0).build();
        }
        // 非个人用户，近三日是否有进行中的个人订单(即申请成为商家前的订单)
//        Integer personalOrderCount = null;
//        if (!MemberTypeEnum.PERSON.type.equals(member.getMemberType())) {
//            String lastDayTime = DateUtils.addDaysToTimeStr(new Date(), -3, DateUtils.yyyyMMdd000000);
//            personalOrderCount = iOrderService.countPersonalOrder(lastDayTime, member.getId());
//        }

//        log.info("用户类型: {}, memberId: {}, 个人订单数量: {}", member.getMemberType(), member.getId(), personalOrderCount);
        List<OrderListDto> list = iOrderService.getOrderListByShopIdsAndMemberIds(shopIds, memberId, member.getMemberType(), false);
        // 新订单、异常单 门店/商家才有
        List<OrderListDto> newOrderList = Lists.newArrayList();
        List<OrderListDto> exceptionList = Lists.newArrayList();
        if (!MemberTypeEnum.PERSON.type.equals(member.getMemberType())) {
            // 新订单
            newOrderList = list.stream().filter(item -> DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(item.getDeliveryStatus())
                    && item.getWmstatus() != null && item.getWmstatus() != 4
                    && item.getTakeType()!= null && TakeTypeEnum.NOW.getType().equals(item.getTakeType())).collect(Collectors.toList());
            // 异常单
            exceptionList = list.stream().filter(item -> (item.getWaimaiOrderId() == null && DeliveryStatusEnum.ABNORMAL.getStatus().equals(item.getDeliveryStatus()))
                    || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.ABNORMAL.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != null && item.getWmstatus() != 4)).collect(Collectors.toList());
        }
        // 预约单
        List<OrderListDto> appointList = list.stream().filter(item -> DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(item.getDeliveryStatus()) && item.getTakeType() != null && !TakeTypeEnum.NOW.getType().equals(item.getTakeType())
                && (item.getWaimaiOrderId() == null && item.getSaveFlag() == 1 || (item.getWaimaiOrderId() != null && item.getWmstatus() != null && item.getWmstatus() != 4))).collect(Collectors.toList());
        // 待接单
        List<OrderListDto> toBeReceivedList = list.stream().filter(item -> (item.getWaimaiOrderId() == null && DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.getStatus().equals(item.getDeliveryStatus()))
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != null && item.getWmstatus() != 4)).collect(Collectors.toList());
        // 取货中
        List<OrderListDto> inPickUpList = list.stream().filter(item -> (item.getWaimaiOrderId() == null && DeliveryStatusEnum.TO_BE_DELIVERED.getStatus().equals(item.getDeliveryStatus()))
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.TO_BE_DELIVERED.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != null && item.getWmstatus() != 4)).collect(Collectors.toList());
        // 配送中
        List<OrderListDto> inDeliveryList = list.stream().filter(item -> (item.getWaimaiOrderId() == null && DeliveryStatusEnum.IN_DELIVERY.getStatus().equals(item.getDeliveryStatus()))
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.IN_DELIVERY.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != null && item.getWmstatus() != 4)).collect(Collectors.toList());
        // 已取消(取消时间在3天之内的)
        Date cancelTime = DateUtils.addDaysToTimeDate(new Date(), -3, DateUtils.yyyyMMdd000000);
        List<OrderListDto> cancelList = list.stream().filter(item -> (item.getWaimaiOrderId() == null && DeliveryStatusEnum.CANCEL.getStatus().equals(item.getDeliveryStatus()) && item.getUpdateTime().compareTo(cancelTime) >= 0)
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.CANCEL.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != 4 && item.getWmUpdateTime().compareTo(cancelTime) >= 0)).collect(Collectors.toList());
        // 已完成
        List<OrderListDto> completedList = list.stream().filter(item -> (item.getWaimaiOrderId() == null && DeliveryStatusEnum.FINISH.getStatus().equals(item.getDeliveryStatus()))
                || (item.getWaimaiOrderId() != null && item.getWmstatus() == 4)).collect(Collectors.toList());
        // 近七日完成/取消
        Date sevenFinishCancelTime = DateUtils.addDaysToTimeDate(new Date(), -7, DateUtils.yyyyMMdd000000);
        List<OrderListDto> sevenDayCancelList = list.stream().filter(item -> (item.getWaimaiOrderId() == null && DeliveryStatusEnum.CANCEL.getStatus().equals(item.getDeliveryStatus()) && item.getUpdateTime().compareTo(sevenFinishCancelTime) >= 0)
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.CANCEL.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != 4 && item.getWmUpdateTime().compareTo(sevenFinishCancelTime) >= 0)).collect(Collectors.toList());
        // 已完成
        List<OrderListDto> sevenDayFinishList = list.stream().filter(item -> (item.getWaimaiOrderId() == null && DeliveryStatusEnum.FINISH.getStatus().equals(item.getDeliveryStatus()) && item.getUpdateTime().compareTo(sevenFinishCancelTime) >= 0)
                || (item.getWaimaiOrderId() != null && item.getWmstatus() == 4 && item.getWmUpdateTime().compareTo(sevenFinishCancelTime) >= 0)).collect(Collectors.toList());
        return OrderMarkerDto.builder()
                .toBeBillNum(newOrderList.size())
                .toBePickedNum(inPickUpList.size())
                .appointNum(appointList.size())
                .InDeliveryNum(inDeliveryList.size())
                .toBeReceivedNum(toBeReceivedList.size())
                .exceptionNum(exceptionList.size())
                .cancelNum(cancelList.size())
                .completedNum(completedList.size())
                .sevenDayNum(sevenDayCancelList.size() + sevenDayFinishList.size())
                .build();
    }

    /**
     * 获取付款二维码
     * @param amount 订单金额
     * @param orderSn 订单号
     * @param payType 付款方式 1-支付宝 2-微信
     * @return 二维码链接
     */
    @Override
    public PaymentQRCodeDto getPaymentQRCode(BigDecimal amount, String orderSn, Integer payType) {
        PaymentQRCodeDto paymentQRCodeDto;
        try {
            if (PaymentTypeEnum.ZHI_FU_BAO.type.equals(payType)) {
                paymentQRCodeDto = aliPayService.getCodeUrl(amount, orderSn);
            } else if (PaymentTypeEnum.WEI_XIN.type.equals(payType)) {
                paymentQRCodeDto = wechatPayService.getCodeUrl(amount, orderSn);
            } else {
                log.warn("无效的付款类型! orderSn: {}, payType: {}", orderSn, payType);
                throw new CustomException("payType参数错误!");
            }
            paymentQRCodeDto.setOrderSn(orderSn);
        } catch (Exception e) {
            log.error("获取付款二维码失败, orderSn:{}, amount:{}, payType:{}, error: {}", orderSn, amount, payType, e);
            throw new CustomException("获取付款二维码失败!");
        }
        return paymentQRCodeDto;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void ignoreOrder(Long memberId, Integer orderId) {
        Order order = iOrderService.getOrderByMemberIdAndOrderId(memberId, orderId);
        if (Objects.isNull(order)) {
            log.info("用户memberId: {}, 无此订单: {}", memberId, orderId);
            throw new CustomAppException("订单不存在!");
        }
        if (!DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(order.getDeliveryStatus())
                && !DeliveryStatusEnum.ABNORMAL.getStatus().equals(order.getDeliveryStatus())) {
            log.info("非待发单、异常单状态下订单不可忽略! orderId: {}, deliveryStatus: {}", orderId, order.getDeliveryStatus());
            throw new CustomAppException("该状态下订单不可忽略!");
        }
        iWaimaiOrderService.update(new UpdateWrapper<WaimaiOrder>()
                .set("status", DeliveryStatusEnum.FINISH.status)
                .eq("id", order.getWaimaiOrderId()));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveOrder(Long loginId, OrderReq req) {
        Member member = iMemberService.getById(loginId);
        if (Objects.isNull(member)) {
            throw new CustomAppException("用户不存在!");
        }
//        if (MemberTypeEnum.SHOP.type.equals(member.getMemberType())) {
//            member = iMemberService.getOne(new QueryWrapper<Member>().eq("member_type", MemberTypeEnum.MERCHANT.type).eq("merchant_id", member.getMerchantId()));
//        }
        Product product = apiProductService.findById(req.getProductId());
        if (product == null) {
            throw new CustomAppException(ExceptionEnum.PRODUCT_NOT_EXISTS);
        }
        // 地址处理重复楼层
        this.handleAddress(req);
        // 保存发件信息, 如果发件Id不存在, 则为手工录入信息, 保存到缓存
//        apiCacheUserAddress.cacheAddress(loginId, req);
        try {
            apiCacheUserAddress.cacheSendReceiveAddress(loginId, req.getSendAddress(), req.getReceiptAddress());
        } catch (Exception e) {
            log.error("缓存收发件地址异常, {}", e.getMessage());
        }
        Order order = createOrder(product, req, loginId, member);
        Merchant merchant = iMerchantService.getById(member.getMerchantId());
        // 达达配送商
        if (merchant != null && merchant.getDadaDspId() != null) {
            DadaDsp dadaDsp = iDadaDspService.getById(merchant.getDadaDspId());
            if (dadaDsp != null) {
                order.setDadaDspId(dadaDsp.getId());
                order.setDadaDspType(DadaDspRoleEnum.SELF_DELIVERY.type.equals(dadaDsp.getDspRole()) ? OrderDadaDspTypeEnum.DELIVERY.type : OrderDadaDspTypeEnum.DELIVERY_RAP.type);
            }
        } else {
            if (member.getAgentId() != null) {
                order.setAgentId(member.getAgentId());
                order.setAgentIdSource(member.getAgentSource());
                if (member.getPersonnelId() != null) {
                    order.setPersonnelId(member.getPersonnelId());
                }
            } else {
                // 判断区域,只给一级代理商
                Agent agent = iAgentService.findByArea(order.getSendCityName(), order.getSendDistrictName());
                if (agent != null) {
                    order.setAgentId(agent.getId());
                    order.setAgentIdSource(AgentSourceEnum.QU_YU.status);
                }
            }
        }
        // 设置外卖平台, 订单流水号
        if ((order.getShopId() != null || order.getMemberId() != null) && req.getPlatformType() != null) {
            if (req.getPlatformType() != 0 && req.getDaySeq() == null) {
                throw new CustomAppException("流水号不能为空!");
            }
            if (req.getPlatformType() == 0) {
                // 猎豹平台生成流水号
                String daySeq = this.getLieBaoDaySeq(order.getShopId(), order.getMemberId());
                req.setDaySeq(daySeq);
            }
            order.setPlatformType(req.getPlatformType());
            order.setLbDaySeq(req.getDaySeq());
        }
        boolean result = iOrderService.save(order);
        if (!result) {
            throw new CustomAppException("预约发单保存失败!");
        }
        // 设置订单延迟发单
        this.createOrderDelay(order.getId(), order.getDeliveryTime());
    }

    private String getLieBaoDaySeq(Long shopId, Long memberId) {
        int daySeq = 1;
        String memberKey = RedisKeyConstant.MEMBER_DAY_SEQ + DateUtils.getDate() + ":member_id:" + memberId;
        Boolean hasMemberKey = redisCache.hasKey(memberKey);
        if (shopId == null) {
            if (hasMemberKey) {
                daySeq = redisCache.increment(memberKey).intValue();
            } else {
                // 36小时后过期自动清除
                redisCache.setCacheObject(memberKey, daySeq, 36, TimeUnit.HOURS);
            }
        } else {
            String shopKey = RedisKeyConstant.SHOP_DAY_SEQ + DateUtils.getDate() + ":shop_id:" + shopId;
            if (redisCache.hasKey(shopKey)) {
                daySeq = redisCache.increment(shopKey).intValue();
            } else {
                // 个人申请成为门店账号, 订单流水号不间断
                if (hasMemberKey) {
                    daySeq = redisCache.increment(memberKey).intValue();
                }
                // 36小时后过期自动清除
                redisCache.setCacheObject(shopKey, daySeq, 36, TimeUnit.HOURS);
            }
        }
        return Integer.toString(daySeq);
    }

    private void createOrderDelay(Long orderId, Date deliveryTime) {
        boolean result;
        String orderKey = orderId + "_0";
        OrderDelay orderDelay = iOrderDelayService.getOne(new QueryWrapper<OrderDelay>().eq("order_id", orderId));
        if (orderDelay != null) {
            orderDelay.setModifyNum(orderDelay.getModifyNum() + 1);
            result = iOrderDelayService.updateById(orderDelay);
            orderKey = orderId + "_" + orderDelay.getModifyNum();
        } else {
            orderDelay = new OrderDelay();
            orderDelay.setCreateTime(new Date());
            orderDelay.setOrderId(orderId);
            result = iOrderDelayService.save(orderDelay);
        }
        if (!result) {
            throw new CustomAppException("预约发单保存失败!");
        }
        if (deliveryTime != null && deliveryTime.compareTo(new Date()) > 0) {
            long diff =  deliveryTime.getTime() - new Date().getTime();
            if(diff >= 0) {
                log.info("手动发预约单, 延时发送时间" + diff);
                rabbitSender.sendDelay(orderKey, "delay.waimai", (int) diff);
            }
        }
    }

    private void handleAddress(OrderReq req){
        String sendAddress = req.getSendAddress().getAddress();
        String sendStreet = req.getSendAddress().getStreet();
        String receiptAddress = req.getReceiptAddress().getAddress();
        String receiptStreet = req.getReceiptAddress().getStreet();
        if(StringUtils.isNotBlank(sendStreet)&&sendAddress.endsWith(sendStreet)){
            req.getSendAddress().setAddress(sendAddress.substring(0,sendAddress.lastIndexOf(sendStreet)));
        }
        if(StringUtils.isNotBlank(receiptStreet)&&receiptAddress.endsWith(receiptStreet)){
            req.getReceiptAddress().setAddress(receiptAddress.substring(0,receiptAddress.lastIndexOf(receiptStreet)));
        }
    }

    private Order createOrder(Product product, OrderReq req, Long memberId, Member member) {
        Order order = new Order();
        order.setMemberId(memberId);
        order.setCreateTime(new Date());
        order.setTakeType(req.getTakeType());
        order.setTakeDate(DateUtils.parseDate(req.getTakeTime()));
        order.setTakeTime(DateUtils.parseDate(req.getTakeTime()));
        order.setOrderSn(SnCodeUtils.createSn());
        order.setTotalAmount(BigDecimal.ZERO);
        order.setMaxAmount(BigDecimal.ZERO);
        order.setPayAmount(BigDecimal.ZERO);
        order.setCommission(BigDecimal.ZERO);
        order.setPaymentType(PaymentTypeEnum.BALANCE.type);
        order.setDeliveryStatus(DeliveryStatusEnum.ORDERS_TO_BE_BILLED.status);
        order.setStatus(PayStatusEnum.NO_PAYED.status);
        order.setRefundMoney(BigDecimal.ZERO);
        order.setSaveFlag(req.getSaveFlag());
        order.setDeliveryTime(DateUtils.parseDate(req.getTakeTime()));
        order.setInvoiceTitle(req.getInvoiceTitle());
        order.setTaxpayerId(req.getTaxpayerId());
        /*if(TakeTypeEnum.APPOINTMENT.type.equals(req.getTakeType())){
            if(DateUtils.addMinutes(new Date(),130).compareTo(DateUtils.dateTime(DateUtils.YYYY_MM_DD_HH_MM_SS,req.getTakeTime()))>0){
                order.setTakeType(TakeTypeEnum.APPOINTMENT_2.type);
            } else {
                order.setTakeTime(DateUtils.dateTime(DateUtils.YYYY_MM_DD_HH_MM_SS,req.getTakeTime()));
            }
        }*/
        order.setMerchantId(member.getMerchantId());
        order.setWeight(req.getWeight());
        order.setTakeRemark(req.getTakeRemark());
        order.setDeliveryType(req.getDeliveryType());
        order.setPreDeliveryIds(req.getPreDeliveryIds());
        order.setProductId(product.getId());
        order.setProductName(product.getName());
        order.setCouponAmount(BigDecimal.ZERO);
        Long shopId = req.getShopId();
        if (shopId == null){
            if (member.getShopId() != null){
                shopId = member.getShopId();
                order.setDefaultShop(DefaultShopEnum.SHOW.status);
            }
        }
        order.setShopId(shopId);
        order.setShopName(req.getShopName());
        AddressReq sendAddress = req.getSendAddress();
        AddressReq receiveAddress = req.getReceiptAddress();
        if (Objects.isNull(sendAddress) || Objects.isNull(receiveAddress)) {
            throw new CustomAppException("取件地址和发件地址不可为空!");
        }
        if(StringUtils.isNotBlank(sendAddress.getStreet())){
            order.setSendStreet(sendAddress.getStreet());
        }
        order.setSendAddress(sendAddress.getAddress());
        order.setSendAddressId(sendAddress.getId());
        order.setSendCityName(sendAddress.getCityName());
        order.setSendContactName(sendAddress.getContact());
        order.setSendPhone(sendAddress.getPhone());
        order.setSendExtension(sendAddress.getExtension());
        order.setSendDistrictName((String)sendAddress.getDistrictName());
        order.setSendProvinceName(sendAddress.getProvinceName());
        order.setSendLat(sendAddress.getLat());
        order.setSendLng(sendAddress.getLng());
        order.setSendCityCode(sendAddress.getCityCode());
        if(StringUtils.isNotBlank(receiveAddress.getStreet())){
            order.setReceiptStreet(receiveAddress.getStreet());
        }
        order.setReceiptAddress(receiveAddress.getAddress());
        order.setReceiptAddressId(receiveAddress.getId());
        order.setReceiptCityName(receiveAddress.getCityName());
        order.setReceiptContactName(receiveAddress.getContact());
        order.setReceiptPhone(receiveAddress.getPhone());
        order.setReceiptExtension(receiveAddress.getExtension());
        order.setReceiptDistrictName((String)receiveAddress.getDistrictName());
        order.setReceiptProvinceName(receiveAddress.getProvinceName());
        order.setReceiptLat(receiveAddress.getLat());
        order.setReceiptLng(receiveAddress.getLng());
        order.setReceiptCityCode(receiveAddress.getCityCode());
        if (order.getWaimaiOrderId() != null){
            order.setWaimaiOrderId(order.getWaimaiOrderId());
        }else {
            order.setWaimaiOrderId(req.getWaimaiOrderId());
        }
        order.setProductAmount(req.getProductAmount());
        return order;
    }

    @Override
    public DeliveryLocationDto showMap(Long orderId) {
        DeliveryLocationDto dto = new DeliveryLocationDto();
        Order order = iOrderService.getById(orderId);
        if (Objects.isNull(order)) {
            throw new CustomAppException("订单不存在!");
        }
        OrderDelivery orderDelivery = iOrderDeliveryService.getOne(new QueryWrapper<OrderDelivery>().eq("order_sn", order.getOrderSn()).eq("delivery_id", order.getDeliveryId()));
        DspDelivery delivery = iDspDeliveryService.getById(order.getDeliveryId());
        dto.setSendLat(order.getSendLat());
        dto.setSendLng(order.getSendLng());
        dto.setReceiptLat(order.getReceiptLat());
        dto.setReceiptLng(order.getReceiptLng());
        dto.setId(order.getId());
        // 计算收发距离
        StopWatch t1 = new StopWatch();
        t1.start();
        if (order.getOrderDistance() == null || order.getOrderDistance().compareTo(BigDecimal.ZERO) == 0) {
            String startLat = dto.getSendLng() + "," + dto.getSendLat();
            String endLat = dto.getReceiptLng() + "," + dto.getReceiptLat();
            if (!Objects.isNull(delivery) && DeliveryTypeEnums.HUO_LA_LA.getType().equals(delivery.getType()) && !Objects.isNull(orderDelivery)){
                dto.setOrderDistance(BigDecimal.valueOf(AddressLngLatExchanger.getDriveDistince(startLat, endLat)));
            } else {
                GDMapTripResult result = AddressLngLatExchanger.getBicyclingInfo(startLat, endLat);
                dto.setOrderDistance(BigDecimal.valueOf(result.getDistance()));
            }
        } else {
            dto.setOrderDistance(order.getOrderDistance());
        }
        t1.stop();
        log.info("计算收发距离耗时: " + t1.getTotalTimeMillis() + "MS");

        // 待配送、配送中设置时间
        if (OrderStatusEnum.TO_BE_DELIVERED.status.equals(order.getDeliveryStatus())
                || OrderStatusEnum.IN_DELIVERY.status.equals(order.getDeliveryStatus())) {
            OrderDto orderDto = new OrderDto();
            if (!Objects.isNull(orderDelivery) && !Objects.isNull(delivery)) {
                orderDto = apiRiderLocationService.getRiderLocation(order, orderDelivery, orderDto, delivery);
                String startLonLat = orderDto.getShipperLng() + "," + orderDto.getShipperLat();
                String endLonLat = OrderStatusEnum.TO_BE_DELIVERED.status.equals(order.getDeliveryStatus()) ? (dto.getSendLng() + "," + dto.getSendLat()) : (dto.getReceiptLng() + "," + dto.getReceiptLat());
                GDMapTripResult result = AddressLngLatExchanger.getBicyclingInfo(startLonLat, endLonLat);
                if (DeliveryTypeEnums.HUO_LA_LA.getType().equals(delivery.getType())) {
                    result = AddressLngLatExchanger.getDrivingInfo(startLonLat, endLonLat);
                }
                if (OrderStatusEnum.TO_BE_DELIVERED.status.equals(order.getDeliveryStatus())) {
                    dto.setRiderArriveMinute(Math.max(result.getDuration() / 60, 0));
                } else {
                    Date estimateArriveTime = DateUtils.addSecondsToTimeDate(new Date(), Integer.parseInt(String.valueOf(result.getDuration())));
                    dto.setEstimateArriveTime(estimateArriveTime);
                }
                dto.setShipperDistance(BigDecimal.valueOf(result.getDistance()));
                dto.setShipperLat(orderDto.getShipperLat() == null ? "" : orderDto.getShipperLat().setScale(6, BigDecimal.ROUND_HALF_UP).toString());
                dto.setShipperLng(orderDto.getShipperLng() == null ? "" : orderDto.getShipperLng().setScale(6, BigDecimal.ROUND_HALF_UP).toString());
            }
        }
        return dto;
    }

    @Override
    public DeliveryLocationDto getRiderArriveTime(Long orderId) {
        DeliveryLocationDto dto = new DeliveryLocationDto();
        Order order = iOrderService.getById(orderId);
        if (Objects.isNull(order)) {
            throw new CustomAppException("订单不存在!");
        }
        // 骑手预计到店时长、预计送达时间
        if (DeliveryStatusEnum.TO_BE_DELIVERED.status.equals(order.getDeliveryStatus())
                || DeliveryStatusEnum.IN_DELIVERY.status.equals(order.getDeliveryStatus())) {
            DspDelivery delivery = iDspDeliveryService.getById(order.getDeliveryId());
            OrderDelivery orderDelivery = iOrderDeliveryService.getOne(new QueryWrapper<OrderDelivery>().eq("order_sn", order.getOrderSn()).eq("delivery_id", order.getDeliveryId()));
            if (!Objects.isNull(orderDelivery) && !Objects.isNull(delivery)) {
                OrderDto orderDto = new OrderDto();
                // 获取骑手位置
                StopWatch t1 = new StopWatch();
                t1.start();
                orderDto = apiRiderLocationService.getRiderLocation(order, orderDelivery, orderDto, delivery);
                t1.stop();
                log.info("获取骑手位置耗时: " + t1.getTotalTimeMillis() + "MS");
                if (orderDto.getShipperLat() != null && orderDto.getShipperLng() != null) {
                    String startLonLat = orderDto.getShipperLng() + "," + orderDto.getShipperLat();
                    String endLonLat = OrderStatusEnum.TO_BE_DELIVERED.status.equals(order.getDeliveryStatus()) ? (order.getSendLng() + "," + order.getSendLat()) : (order.getReceiptLng() + "," + order.getReceiptLat());
                    GDMapTripResult result = AddressLngLatExchanger.getBicyclingInfo(startLonLat, endLonLat);
                    if (DeliveryTypeEnums.HUO_LA_LA.getType().equals(delivery.getType())) {
                        result = AddressLngLatExchanger.getDrivingInfo(startLonLat, endLonLat);
                    }
                    if (DeliveryStatusEnum.TO_BE_DELIVERED.status.equals(order.getDeliveryStatus())) {
//                        dto.setRiderArriveMinute(Math.max(DateUtils.parseMsToMinute(result.getDuration() * 1000), 0));
                        dto.setRiderArriveMinute(Math.max(result.getDuration() / 60, 0));
                        log.info("配送平台: {}, 骑手取货中, 三方平台返回预计到店时间: {}, 计算预计到店时长: {} 分钟", DeliveryTypeEnums.getNameByType(delivery.getType()), orderDto.getEstimateArriveTimeStr(), Math.max(DateUtils.parseMsToMinute(result.getDuration() * 1000), 0));
                    } else if (DeliveryStatusEnum.IN_DELIVERY.status.equals(order.getDeliveryStatus())) {
                        Date estimateArriveTime = DateUtils.addSecondsToTimeDate(new Date(), Integer.parseInt(String.valueOf(result.getDuration())));
                        dto.setEstimateArriveTime(estimateArriveTime);
                        log.info("配送平台: {}, 骑手配送中, 三方平台返回预计送达时间: {}, 计算预计送达时间: {}", DeliveryTypeEnums.getNameByType(delivery.getType()), orderDto.getEstimateArriveTimeStr(), estimateArriveTime);
                    }
                }
            }
        }
        return dto;
    }

    @Override
    public PrintOrderDto getPrintOrderInfos(Long orderId, Long waimaiOrderId) {
        WaimaiOrder waimaiOrder = null;
        if (Objects.nonNull(orderId)) {
            Order order = iOrderService.getById(orderId);
            if (Objects.isNull(order)) {
                return null;
            }
            waimaiOrder = iWaimaiOrderService.getById(order.getWaimaiOrderId());
        }
        if (Objects.nonNull(waimaiOrderId)) {
            waimaiOrder = iWaimaiOrderService.getById(waimaiOrderId);
        }
        if (Objects.isNull(waimaiOrder)) {
            return null;
        }
        PrintOrderDto printOrderDto = new PrintOrderDto();
        BeanUtil.copyProperties(waimaiOrder, printOrderDto);
        // 取消单
        if (waimaiOrder.getStatus().equals(OrderStatusEnum.CANCEL.status)){
            printOrderDto.setOrderStatus(OrderStatusEnum.CANCEL.status);
        }
        if (waimaiOrder.getCaution().contains("收餐人隐私号")){
            printOrderDto.setCaution(waimaiOrder.getCaution().substring(0,waimaiOrder.getCaution().indexOf("收餐人隐私号")));
        } else {
            printOrderDto.setCaution(waimaiOrder.getCaution());
        }
        if (waimaiOrder.getDeliveryTime() != 0) {
            String deliverTimeStr = DateUtils.format( new Date(waimaiOrder.getDeliveryTime() * 1000),"MM月dd日 HH:mm") + "送达";
            printOrderDto.setDeliveryTime(deliverTimeStr);
        }
        // 设置商品信息
        printOrderDto.setOrderGoodsDtoList(this.getOrderGoods(waimaiOrder.getId()));
        // 设置订单活动信息
        DspWaimai dspWaimai = iDspWaimaiService.getById(waimaiOrder.getWaimaiId());
        printOrderDto.setActDtos(this.getOrderActs(waimaiOrder, dspWaimai.getType()));

        if (waimaiOrder.getShippingFee() != null) {
            printOrderDto.setDeliverFee(waimaiOrder.getShippingFee().toString());
        }
        if (waimaiOrder.getBoxFee() != null) {
            printOrderDto.setBoxFee(waimaiOrder.getBoxFee().toString());
        }
        printOrderDto.setIsBook(waimaiOrder.getDeliveryTime() > 0 ? 1 : 0);
        if (waimaiOrder.getOrderTime() != null) {
            printOrderDto.setCreateTime(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS,waimaiOrder.getOrderTime()));
        } else {
            printOrderDto.setCreateTime(DateUtils.dateTimeNow(DateUtils.YYYY_MM_DD_HH_MM_SS));
        }
        printOrderDto.setOrderSource(dspWaimai.getName());
        printOrderDto.setShopName(waimaiOrder.getPoiName());
        printOrderDto.setRecipientPrivacyPhone(waimaiOrder.getReceiptPrivacyPhone());
        if (waimaiOrder.getLogisticsCode() != null && !waimaiOrder.getLogisticsCode().equals("0000") && !waimaiOrder.getLogisticsCode().equals("5001") && !waimaiOrder.getLogisticsCode().equals("00009003")){
            printOrderDto.setRecipientAddress(waimaiOrder.getRecipientAddressDesensitization());
        } else {
            printOrderDto.setRecipientAddress(waimaiOrder.getRecipientAddress());
        }
        printOrderDto.setOpenQrCode(iShopService.getOpenQrCode(waimaiOrder.getShopId()));
        printOrderDto.setQrCode(waimaiOrder.getOutOrderId());
        return printOrderDto;
    }

    private List<PrintOrderActDto> getOrderActs(WaimaiOrder waimaiOrder, Integer waimaiType) {
        List<PrintOrderActDto> orderActs = Lists.newArrayList();
        if (StringUtils.isBlank(waimaiOrder.getExtras())) {
            return orderActs;
        }
        if (WaimaiTypeEnums.E_LE_ME.getType().equals(waimaiType)) {
            List<OActivity> list = JSONArray.parseArray(waimaiOrder.getExtras(), OActivity.class);
            if (CollectionUtils.isNotEmpty(list)) {
                for (OActivity activity : list) {
                    if (activity != null) {
                        PrintOrderActDto actDto = new PrintOrderActDto();
                        actDto.setAmount(String.valueOf(activity.getAmount()));
                        actDto.setName(activity.getName());
                        actDto.setType(activity.getType());
                        orderActs.add(actDto);
                    }
                }
            }
        } else if (WaimaiTypeEnums.MEI_TUAN.getType().equals(waimaiType)) {
            List<MeituanOrderExtraVo> list =JSONArray.parseArray(waimaiOrder.getExtras(), MeituanOrderExtraVo.class);
            if (CollectionUtils.isNotEmpty(list)) {
                for (MeituanOrderExtraVo vo : list) {
                    if(vo != null && vo.getRemark() != null) {
                        PrintOrderActDto actDto = new PrintOrderActDto();
                        actDto.setAmount(String.valueOf(vo.getReduceFee()));
                        actDto.setType(String.valueOf(vo.getType()));
                        actDto.setName(vo.getRemark());
                        orderActs.add(actDto);
                    }
                }
            }
        } else if (WaimaiTypeEnums.E_LE_ME_RETAIL.getType().equals(waimaiType)) {
            JSONArray array = JSONArray.parseArray(waimaiOrder.getExtras());
            if(array != null && array.size() > 0){
                for(int i = 0; i < array.size(); i++){
                    JSONObject json1 = array.getJSONObject(i);
                    PrintOrderActDto actDto = new PrintOrderActDto();
                    actDto.setAmount(new BigDecimal(json1.getString("fee")).divide(new BigDecimal("100")).toString());
                    actDto.setName(json1.getString("desc"));
                    actDto.setType(json1.getString("type"));
                    orderActs.add(actDto);
                }
            }
        }
        orderActs = MeiTuanConvertPrint.merge(orderActs);
        return orderActs;
    }

    private List<PrintOrderGoodsDto> getOrderGoods(Long waimaiOrderId) {
        List<PrintOrderGoodsDto> orderGoods = Lists.newArrayList();
        List<WaimaiOrderDetail> detailList = iWaimaiOrderDetailService.list(new QueryWrapper<WaimaiOrderDetail>().eq("waimai_order_id", waimaiOrderId));
        for (WaimaiOrderDetail waimaiOrderDetail : detailList) {
            PrintOrderGoodsDto printOrderGoodsDto = new PrintOrderGoodsDto();
            BeanUtil.copyProperties(waimaiOrderDetail, printOrderGoodsDto);
            StringBuilder spec = new StringBuilder();
            if (StringUtils.isNotBlank(waimaiOrderDetail.getFoodProperty())){
                spec.append(waimaiOrderDetail.getFoodProperty());
            }
            if (StringUtils.isNotBlank(spec.toString()) && StringUtils.isNotBlank(waimaiOrderDetail.getSpec())) {
                spec.append(",").append(waimaiOrderDetail.getSpec());
            } else if (StringUtils.isBlank(spec.toString()) && StringUtils.isNotBlank(waimaiOrderDetail.getSpec())) {
                spec.append(waimaiOrderDetail.getSpec());
            }
            if (StringUtils.isNotBlank(spec.toString())) {
                printOrderGoodsDto.setFoodName(waimaiOrderDetail.getFoodName() + "(" + spec.toString() + ")");
            }
            orderGoods.add(printOrderGoodsDto);
        }
        return orderGoods;
    }

    @Override
    public List<OrderListSearchCacheDto> getSearchHistory(Long loginId) {
        List<OrderListSearchCacheDto> list = Lists.newArrayList();
        Set<ZSetOperations.TypedTuple> set = redisCache.zSetGet(RedisKeyConstant.ORDER_LIST_SEARCH + loginId, 0, 10);
        for (ZSetOperations.TypedTuple next : set) {
            OrderListSearchCacheDto cacheDto = (OrderListSearchCacheDto) next.getValue();
            list.add(cacheDto);
        }
        return list;
    }

    @Override
    public void clearSearchHistory(Long loginId, OrderListSearchCacheDto orderListSearchCacheDto) {
        String key = RedisKeyConstant.ORDER_LIST_SEARCH + loginId;
        if (orderListSearchCacheDto != null && StringUtils.isNotEmpty(orderListSearchCacheDto.getSearchKey())) {
            Set<ZSetOperations.TypedTuple> set = redisCache.zSetGet(key, 0, 10);
            if (CollectionUtils.isNotEmpty(set)) {
                int index = 0;
                for (ZSetOperations.TypedTuple next : set) {
                    OrderListSearchCacheDto cacheDto = (OrderListSearchCacheDto) next.getValue();
                    if (orderListSearchCacheDto.equals(cacheDto)) {
                        redisCache.zSetRemove(key, set.size() - index - 1, set.size() - index - 1);
                        return;
                    }
                    index++;
                }
            }
        } else {
            redisCache.deleteObject(key);
        }
    }

    @Override
    public OrderInfoDto getOrderInfo(Long orderId, Long memberId) {
        OrderInfoDto dto = iOrderService.getOrderInfoByOrderId(orderId);
        if (dto == null) {
            throw new CustomAppException("订单不存在");
        }
        if (dto.getWaimaiOrderId() != null) {
            DspWaimai waiMai = iDspWaimaiService.getById(dto.getWaimaiId());
            dto.setLogo(Objects.isNull(waiMai) ? "" : waiMai.getLogo());
        } else if (dto.getPlatformType() != 0) {
            // 手动发外卖单
            String logo = iDspWaimaiService.selectLogoByType(dto.getPlatformType());
            dto.setLogo(logo);
        } else {
            dto.setLogo(AppConstant.LIE_BAO_LOGO);
        }
//        if (dto.getWaimaiOrderId() != null) {
//            DspWaimai waiMai = iDspWaimaiService.getById(dto.getWaimaiId());
//            dto.setLogo(Objects.isNull(waiMai) ? "" : waiMai.getLogo());
//        } else {
//            dto.setLogo(AppConstant.LIE_BAO_LOGO);
//        }
        if (dto.getShopId() != null && StringUtils.isNull(dto.getShopName())) {
            Shop shop = iShopService.getById(dto.getShopId());
            dto.setShopName(Objects.isNull(shop) ? "" : shop.getName());
        }
        // 设置外卖订单件数
        List<WaimaiOrderDetail> orderDetailList = iWaimaiOrderDetailService.list(new QueryWrapper<WaimaiOrderDetail>()
                .eq("waimai_order_id", dto.getWaimaiOrderId())
                .eq("deleted", 0));
        if (CollectionUtils.isNotEmpty(orderDetailList)){
            long totalNum = orderDetailList.stream().mapToLong(WaimaiOrderDetail::getQuantity).sum();
            dto.setSkuNum(orderDetailList.size());
            dto.setTotalNum(totalNum);
        }
        // 设置外卖门店名称
        if (dto.getShopId() != null) {
            List<ShopWaimai> shopWaimai = iShopWaimaiService.list(new QueryWrapper<ShopWaimai>()
                    .eq("shop_id", dto.getShopId())
                    .eq("bind_status", 1)
                    .eq("deleted", 0)
                    .orderByDesc("id"));
            // 设置外卖门店名称
            if (CollectionUtils.isNotEmpty(shopWaimai) && shopWaimai.get(0) != null && dto.getShopId() != null && dto.getWaimaiId() != null) {
                dto.setWaimaiShopName(shopWaimai.get(0).getThirdShopName());
            }
        }

        // 计算外卖单用户期望送达时间
        if (dto.getWmDeliveryTime() != null && dto.getWmDeliveryTime() != 0) {
            dto.setExceptTime(new Date(dto.getWmDeliveryTime() * 1000L));
        }
        // 设置相关操作时间
        this.setOrderInfoTime(dto);
        // 设置发件详细地址(发单计价用)
        if (dto.getSendStreet() == null && dto.getSendAddressId() != null && DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(dto.getDeliveryStatus())) {
            MemberAddress memberAddress = iMemberAddressService.findById(memberId, dto.getSendAddressId());
            dto.setSendStreet(memberAddress != null ? memberAddress.getStreet() : "");
        }
        // 设置收件详细地址(发单计价用)
        if (dto.getReceiptStreet() == null && dto.getReceiptAddressId() != null && DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(dto.getDeliveryStatus())) {
            MemberAddress memberAddress = iMemberAddressService.findById(memberId, dto.getReceiptAddressId());
            dto.setReceiptStreet(memberAddress != null ? memberAddress.getStreet() : "");
        }
        // 子订单号、客服电话
        if (StringUtils.isNotEmpty(dto.getOutTradeNo()) && dto.getDeliveryId() != null) {
            String childOrderSn = iOrderDeliveryService.getChildOrderSnByOutTradeNo(dto.getOutTradeNo(), dto.getDeliveryId());
            dto.setChildOrderSn(childOrderSn);
            DspDelivery dspDelivery = iDspDeliveryService.findById(dto.getDeliveryId());
            dto.setCustomerPhone(dspDelivery != null ? dspDelivery.getCustomerPhone() : "");
        }
        // 配送距离
        if (dto.getDeliveryId() == null || dto.getOrderDistance() == null || dto.getOrderDistance().compareTo(BigDecimal.ZERO) == 0) {
            DspDelivery delivery = iDspDeliveryService.getById(dto.getDeliveryId());
            String startLat = dto.getSendLng() + "," + dto.getSendLat();
            String endLat = dto.getReceiptLng() + "," + dto.getReceiptLat();
            if (!Objects.isNull(delivery) && DeliveryTypeEnums.HUO_LA_LA.getType().equals(delivery.getType())){
                dto.setOrderDistance(BigDecimal.valueOf(AddressLngLatExchanger.getDriveDistince(startLat, endLat)));
            } else {
                GDMapTripResult result = AddressLngLatExchanger.getBicyclingInfo(startLat, endLat);
                dto.setOrderDistance(BigDecimal.valueOf(result.getDistance()));
            }
        } else {
            dto.setOrderDistance(dto.getOrderDistance());
        }
        // 设置按钮状态
        dto.setButtonStatus(this.setButtonStatus(dto));
        OrderDelay orderDelay = iOrderDelayService.list(new QueryWrapper<OrderDelay>()
                .eq("order_id", dto.getOrderId())
                .eq("deleted", 0))
                .stream().findFirst().orElse(null);
        // 外卖预约单
        if (dto.getTakeType() > 0 && dto.getWaimaiOrderId() != null) {
            this.setDelayTime(orderDelay, null, dto);
        }
        return dto;
    }

    private void setOrderInfoTime(OrderInfoDto dto) {
        List<OrderLog> orderLogs = iOrderLogService.getOrderLogListByOrderId(dto.getOrderId());
        if (CollectionUtils.isNotEmpty(orderLogs)) {
            List<OrderLog> payList = orderLogs.stream().filter(item -> item.getOrderStatus() != null && item.getOrderStatus() == 5).collect(Collectors.toList());
            List<OrderLog> toBeReceiveList = orderLogs.stream().filter(item -> DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status.equals(item.getOrderStatus())).collect(Collectors.toList());
            List<OrderLog> toBeDeliveredList = orderLogs.stream().filter(item -> DeliveryStatusEnum.TO_BE_DELIVERED.status.equals(item.getOrderStatus())).collect(Collectors.toList());
            List<OrderLog> cancelList = orderLogs.stream().filter(item -> DeliveryStatusEnum.CANCEL.status.equals(item.getOrderStatus()) || DeliveryStatusEnum.ABNORMAL.status.equals(item.getOrderStatus())).collect(Collectors.toList());
            List<OrderLog> finishList = orderLogs.stream().filter(item -> DeliveryStatusEnum.FINISH.status.equals(item.getOrderStatus())).collect(Collectors.toList());
            List<OrderLog> inDeliveredList = orderLogs.stream().filter(item -> DeliveryStatusEnum.IN_DELIVERY.status.equals(item.getOrderStatus())).collect(Collectors.toList());
            // 支付时间
            dto.setPayTime(CollectionUtils.isNotEmpty(payList) ? payList.get(0).getCreateTime() : null);
            // 发单时间
            dto.setSendTime(CollectionUtils.isNotEmpty(toBeReceiveList) ? toBeReceiveList.get(0).getCreateTime() : null);
            // 取消时间
            dto.setCancelTime(CollectionUtils.isNotEmpty(cancelList) ? cancelList.get(0).getCreateTime() : null);
            // 完成时间
            dto.setFinishTime(CollectionUtils.isNotEmpty(finishList) ? finishList.get(0).getCreateTime() : null);
            // 骑手接单时间
            dto.setShipperReceiveTime(CollectionUtils.isEmpty(toBeDeliveredList) ? null : toBeDeliveredList.get(0).getCreateTime());
            // 骑手取货时间
            dto.setShipperTakeTime(CollectionUtils.isEmpty(inDeliveredList) ? null : inDeliveredList.get(0).getCreateTime());
        }
    }

    private Integer setButtonStatus(OrderInfoDto item) {
        if (DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(item.getDeliveryStatus())
                && item.getWmstatus() != null && item.getWmstatus() != 4
                && item.getTakeType()!= null && TakeTypeEnum.NOW.getType().equals(item.getTakeType())) {
            // 新订单
            return 0;
        } else if (DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(item.getDeliveryStatus())
                && item.getTakeType() != null && !TakeTypeEnum.NOW.getType().equals(item.getTakeType())
                && (item.getWaimaiOrderId() == null || (item.getWaimaiOrderId() != null && item.getWmstatus() != null && item.getWmstatus() != 4))) {
            // 预约单
            return 10;
        } else if ((item.getWaimaiOrderId() == null && DeliveryStatusEnum.ABNORMAL.getStatus().equals(item.getDeliveryStatus()))
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.ABNORMAL.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != null && item.getWmstatus() != 4)) {
            // 异常单
            return -2;
        } else if ((item.getWaimaiOrderId() == null && DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.getStatus().equals(item.getDeliveryStatus()))
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != null && item.getWmstatus() != 4)) {
            // 待接单
            return 1;
        } else if ((item.getWaimaiOrderId() == null && DeliveryStatusEnum.TO_BE_DELIVERED.getStatus().equals(item.getDeliveryStatus()))
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.TO_BE_DELIVERED.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != null && item.getWmstatus() != 4)) {
            // 取货中
            return 2;
        } else if ((item.getWaimaiOrderId() == null && DeliveryStatusEnum.IN_DELIVERY.getStatus().equals(item.getDeliveryStatus()))
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.IN_DELIVERY.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != null && item.getWmstatus() != 4)) {
            // 配送中
            return 3;
        } else if (item.getWaimaiOrderId() == null && DeliveryStatusEnum.CANCEL.getStatus().equals(item.getDeliveryStatus())
                || (item.getWaimaiOrderId() != null && DeliveryStatusEnum.CANCEL.getStatus().equals(item.getDeliveryStatus()) && item.getWmstatus() != 4)) {
            // 已取消
            return -1;
        } else if (DeliveryStatusEnum.FINISH.getStatus().equals(item.getDeliveryStatus())) {
            // 本平台完成
            return 97;
        } else if (item.getWaimaiOrderId() != null && item.getWmstatus() == 4 && !DeliveryStatusEnum.FINISH.getStatus().equals(item.getDeliveryStatus())) {
            // 其他平台完成
            return 98;
        }
        return null;
    }

    @Override
    public OrderGoodsInfoDto getGoodsInfo(Long orderId, Long memberId) {
        Order order = iOrderService.getById(orderId);
        if (order == null) {
            throw new CustomAppException("订单不存在");
        }
        OrderGoodsInfoDto dto = new OrderGoodsInfoDto();
        WaimaiOrder waimaiOrder = iWaimaiOrderService.findById(order.getWaimaiOrderId());
        dto.setOrderTime(waimaiOrder.getOrderTime());
        dto.setOutOrderId(waimaiOrder.getOutOrderId());
        dto.setTotalPrice(waimaiOrder.getTotalPrice());

        List<OrderGoodsInfoDto.Item> goodsItems = Lists.newArrayList();
        // 外卖订单件数
        List<WaimaiOrderDetail> orderDetailList = iWaimaiOrderDetailService.list(new QueryWrapper<WaimaiOrderDetail>()
                .eq("waimai_order_id", order.getWaimaiOrderId())
                .eq("deleted", 0));
        if (CollectionUtils.isNotEmpty(orderDetailList)){
            long totalNum = orderDetailList.stream().mapToLong(WaimaiOrderDetail::getQuantity).sum();
            dto.setSkuNum(orderDetailList.size());
            dto.setTotalNum(totalNum);
            // 外卖商品信息
            MemberConfigDto memberConfig = iMemberConfigService.findDetail(memberId);
            boolean showFoodImg = memberConfig == null || memberConfig.getShowFoodImg() == 1;
            goodsItems = orderDetailList.stream().map(waimaiDetail -> {
                OrderGoodsInfoDto.Item goodsItem = new OrderGoodsInfoDto.Item();
                goodsItem.setFoodName(waimaiDetail.getFoodName());
                goodsItem.setQuantity(waimaiDetail.getQuantity());
                goodsItem.setPrice(waimaiDetail.getPrice());
                goodsItem.setFoodProperty(waimaiDetail.getFoodProperty() == null ? "" : waimaiDetail.getFoodProperty());
                StringBuilder spec = new StringBuilder();
                if(StringUtils.isNotBlank(waimaiDetail.getFoodProperty())){
                    spec.append(waimaiDetail.getFoodProperty());
                }
                if(StringUtils.isNotBlank(spec.toString())&&StringUtils.isNotBlank(waimaiDetail.getSpec())){
                    spec.append(",").append(waimaiDetail.getSpec());
                }else if(StringUtils.isBlank(spec.toString())&&StringUtils.isNotBlank(waimaiDetail.getSpec())){
                    spec.append(waimaiDetail.getSpec());
                }
                // goodsItem.setSpec(waimaiDetail.getSpec() == null ? "" : waimaiDetail.getSpec());
                goodsItem.setSpec(spec.toString());
                if (showFoodImg) {
                    WaimaiFoodImg waimaiFoodImg = iWaimaiFoodImgService.getOne(new QueryWrapper<WaimaiFoodImg>()
                            .eq("sku_id", waimaiDetail.getSkuId())
                            .eq("waimai_id", waimaiOrder.getWaimaiId())
                            .eq("shop_id", order.getShopId())
                            .eq("deleted", 0));
                    goodsItem.setFoodPic(Objects.isNull(waimaiFoodImg) ? "" : waimaiFoodImg.getImg());
                }
                return goodsItem;
            }).collect(Collectors.toList());
        }
        dto.setGoodsList(goodsItems);
        return dto;
    }

    @Override
    public Map<String, Object> pullNewOrder(Long loginId, List<Integer> orderIds, Integer status, String searchShopIdStr) {
        List<OrderDetailDto> list = new ArrayList<>();
        Member member = iMemberService.getById(loginId);
        if (Objects.isNull(member)) {
            throw new CustomAppException("用户不存在!");
        }
        Long shopId = member.getShopId();
        Long merchant = null;
        if (member.getMemberType().equals(MemberTypeEnum.MERCHANT.type)) {
            merchant = member.getMerchantId();
        }
        if(status == null || DeliveryStatusEnum.ORDERS_TO_BE_BILLED.status.equals(status)
                || DeliveryStatusEnum.APPOINTMENT.status.equals(status)) {
            String shopNewOrderListKey = "shop" + shopId + "";
            if (member.getShopId() != null && merchant == null && redisCache.hasKey(shopNewOrderListKey)) {
                Long size = redisCache.getListSize(shopNewOrderListKey);
                log.info("外卖新订单数量：" + size);
                for (int i = 0; i < size.intValue(); i++) {
                    list.add((OrderDetailDto) redisCache.rPop(shopNewOrderListKey));
                }
            }
            String merchantNewOrderListKey = "merchant" + merchant + "";
            if (merchant != null && redisCache.hasKey(merchantNewOrderListKey)) {
                Long size = redisCache.getListSize(merchantNewOrderListKey);
                log.info("商家外卖新订单数量：" + size);
                for (int i = 0; i < size.intValue(); i++) {
                    list.add((OrderDetailDto) redisCache.rPop(merchantNewOrderListKey));
                }
            }
        } else if (DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status.equals(status)){
            String shopReceivedOrderListKey = "shop_received" + shopId + "";
            if (shopId != null && merchant == null && redisCache.hasKey(shopReceivedOrderListKey)) {
                Long size = redisCache.getListSize(shopReceivedOrderListKey);
                log.info("外卖待接单数量：" + size);
                for (int i = 0; i < size.intValue(); i++) {
                    list.add((OrderDetailDto) redisCache.rPop(shopReceivedOrderListKey));
                }
            }
            String merchantReceivedOrderListKey = "merchant_received" + merchant + "";
            if (merchant != null && redisCache.hasKey(merchantReceivedOrderListKey)) {
                Long size = redisCache.getListSize(merchantReceivedOrderListKey);
                log.info("商家待接单数量：" + size);
                for (int i = 0; i < size.intValue(); i++) {
                    list.add((OrderDetailDto) redisCache.rPop(merchantReceivedOrderListKey));
                }
            }
        }

        // 过滤已选门店的订单
        if (StringUtils.isNotEmpty(searchShopIdStr)) {
            List<Long> searchShopIds = Lists.newArrayList();
            String[] split = searchShopIdStr.split(",");
            for (String item : split) {
                searchShopIds.add(Long.valueOf(item));
            }
            if (CollectionUtils.isNotEmpty(searchShopIds) && CollectionUtils.isNotEmpty(list)) {
                list = list.stream().filter(item -> searchShopIds.contains(item.getShopId())).collect(Collectors.toList());
            }
        }

        Map<String, Object> map = new HashMap<>();
        List<Long> ids = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(orderIds)) {
            if(DeliveryStatusEnum.APPOINTMENT.status.equals(status)){
                status = DeliveryStatusEnum.ORDERS_TO_BE_BILLED.status;
            }
            List<Order> orderList = iOrderService.list(new QueryWrapper<Order>().in("id", orderIds).ne("delivery_status", status));
            ids = orderList.stream().map(Order::getId).collect(Collectors.toList());
            // 待接单状态下缓存过滤
            list = list.stream().filter(item -> !orderIds.contains(item.getId().intValue())).collect(Collectors.toList());
        }
        log.info("原始新订单: {}", JSONObject.toJSONString(list));
        List<OrderListDto> result = this.buildNewOrderList(list, loginId, status);
        log.info("处理后新订单: {}", JSONObject.toJSONString(result));
        map.put("newList", result);
        map.put("deliveryList", ids);
        return map;
    }

    private List<OrderListDto> buildNewOrderList(List<OrderDetailDto> list, Long memberId, Integer status) {
        List<OrderListDto> result = Lists.newArrayList();
        if (CollectionUtils.isEmpty(list)) {
            return result;
        }
        // 获取订单日志信息
        Map<Long, List<OrderLog>> orderLogMap = new HashMap<>();
        // 获取订单延迟发单信息
        Map<Long, List<OrderDelay>> orderDelayMap = new HashMap<>();
        if (CollectionUtils.isNotEmpty(list)){
            List<Long> orderIds = list.stream().map(OrderDetailDto::getId).collect(Collectors.toList());
            List<OrderLog> orderLogs = iOrderLogService.getOrderLogByOrderIds(orderIds);
            orderLogMap = orderLogs.stream().collect(Collectors.groupingBy(OrderLog::getOrderId));

            orderDelayMap = iOrderDelayService.list(new QueryWrapper<OrderDelay>()
                    .in("order_id", orderIds)
                    .eq("deleted", 0)).stream().collect(Collectors.groupingBy(OrderDelay::getOrderId));
        }
        List<Long> waimaiOrderIds = list.stream().map(OrderDetailDto::getWaimaiOrderId).collect(Collectors.toList());
        // 外卖订单
        Map<Long, List<WaimaiOrder>> waiMaiOrderMap = new HashMap<>();
        // 外卖商品
        Map<Long, List<WaimaiOrderDetail>> orderDetailMap = new HashMap<>();
        if (CollectionUtils.isNotEmpty(waimaiOrderIds)) {
            waiMaiOrderMap = iWaimaiOrderService.list(new QueryWrapper<WaimaiOrder>()
                    .in("id", waimaiOrderIds))
                    .stream()
                    .collect(Collectors.groupingBy(WaimaiOrder::getId));

            orderDetailMap = iWaimaiOrderDetailService.list(new QueryWrapper<WaimaiOrderDetail>()
                    .in("waimai_order_id", waimaiOrderIds)
                    .eq("deleted", 0))
                    .stream()
                    .collect(Collectors.groupingBy(WaimaiOrderDetail::getWaimaiOrderId));
        }
        // 获取外卖门店
        List<Long> shopIds = list.stream().filter(item -> item.getShopId() != null).map(OrderDetailDto::getShopId).collect(Collectors.toList());
        Map<String, List<ShopWaimai>> shopWaiMaiMap = new HashMap<>();
        if (CollectionUtils.isNotEmpty(shopIds)) {
            shopWaiMaiMap = iShopWaimaiService.list(new QueryWrapper<ShopWaimai>()
                    .in("shop_id", shopIds)
                    .eq("bind_status", 1)
                    .eq("deleted", 0))
                    .stream()
                    .collect(Collectors.groupingBy(item -> item.getShopId() + "-" + item.getWaimaiId()));
        }

        // 待接单状态下获取运力
        Map<String, List<OrderDelivery>> deliveryMap = new HashMap<>();
        if (DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status.equals(status)) {
            List<String> orderSns = list.stream().filter(item -> item.getOrderSn() != null && item.getDeliveryStatus() == 1).map(OrderDetailDto::getOrderSn).collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(orderSns)) {
                deliveryMap = iOrderDeliveryService.list(new QueryWrapper<OrderDelivery>()
                        .in("order_sn", orderSns)
                        .eq("deleted", 0))
                        .stream()
                        .collect(Collectors.groupingBy(OrderDelivery::getOrderSn));
            }
        }
        for (OrderDetailDto detailDto : list) {
            OrderListDto dto = new OrderListDto();
            BeanUtils.copyProperties(detailDto, dto);
            // 外卖订单
            if (waiMaiOrderMap != null && CollectionUtils.isNotEmpty(waiMaiOrderMap.get(dto.getWaimaiOrderId()))){
                List<WaimaiOrder> waimaiOrderList = waiMaiOrderMap.get(dto.getWaimaiOrderId());
                WaimaiOrder waimaiOrder = waimaiOrderList.get(0);
                if (waimaiOrder != null && dto.getWaimaiOrderId() != null) {
                    dto.setWaimaiOrderId(waimaiOrder.getId());
                    dto.setWaimaiId(waimaiOrder.getWaimaiId());
                    dto.setWmstatus(waimaiOrder.getStatus());
                    dto.setWmDeliveryTime(waimaiOrder.getDeliveryTime());
                    dto.setOrderType(waimaiOrder.getOrderType());
                    dto.setProductAmount(waimaiOrder.getTotalPrice());
                    dto.setOrderTime(waimaiOrder.getOrderTime());
                    DspWaimai waiMai = iDspWaimaiService.getById(waimaiOrder.getWaimaiId());
                    dto.setLogo(Objects.isNull(waiMai) ? "" : waiMai.getLogo());
                } else {
                    dto.setLogo(AppConstant.LIE_BAO_LOGO);
                }
            }
            if (dto.getShopId() != null && StringUtils.isNull(dto.getShopName())) {
                Shop shop = iShopService.getById(dto.getShopId());
                dto.setShopName(Objects.isNull(shop) ? "" : shop.getName());
            }
            // 设置运力logo
            if (deliveryMap != null && CollectionUtils.isNotEmpty(deliveryMap.get(dto.getOrderSn()))) {
                List<OrderDelivery> orderDeliveries = deliveryMap.get(dto.getOrderSn());
                List<String> logos = orderDeliveries.stream().map(OrderDelivery::getDeliveryLogo).collect(Collectors.toList());
                dto.setDeliveryLogos(logos);
            }
            // 设置外卖门店名称
            if (shopWaiMaiMap != null && shopWaiMaiMap.size() > 0 && dto.getShopId() != null && dto.getWaimaiId() != null) {
                List<ShopWaimai> shopWaimais = shopWaiMaiMap.get(dto.getShopId() + "-" + dto.getWaimaiId());
                if (CollectionUtils.isNotEmpty(shopWaimais) && shopWaimais.get(0) != null) {
                    dto.setWaimaiShopName(shopWaimais.get(0).getThirdShopName());
                }
            }
            // 设置外卖订单件数
            if (orderDetailMap != null && CollectionUtils.isNotEmpty(orderDetailMap.get(dto.getWaimaiOrderId()))){
                List<WaimaiOrderDetail> orderDetailList = orderDetailMap.get(dto.getWaimaiOrderId());
                long totalNum = orderDetailList.stream().mapToLong(WaimaiOrderDetail::getQuantity).sum();
                dto.setSkuNum(orderDetailList.size());
                dto.setTotalNum(totalNum);
            }
            // 计算外卖单用户期望送达时间
            if (dto.getWmDeliveryTime() != null && dto.getWmDeliveryTime() != 0) {
                dto.setExceptTime(new Date(dto.getWmDeliveryTime() * 1000L));
            }
            // 设置相关操作时间
            if (orderLogMap.size() > 0) {
                this.setOrderTime(dto, orderLogMap);
            }
            // 设置发件详细地址(发单计价用)
            if (dto.getSendStreet() == null && dto.getSendAddressId() != null && DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(dto.getDeliveryStatus())) {
                MemberAddress memberAddress = iMemberAddressService.findById(memberId, dto.getSendAddressId());
                dto.setSendStreet(memberAddress != null ? memberAddress.getStreet() : "");
            }
            // 设置收件详细地址(发单计价用)
            if (dto.getReceiptStreet() == null && dto.getReceiptAddressId() != null && DeliveryStatusEnum.ORDERS_TO_BE_BILLED.getStatus().equals(dto.getDeliveryStatus())) {
                MemberAddress memberAddress = iMemberAddressService.findById(memberId, dto.getReceiptAddressId());
                dto.setReceiptStreet(memberAddress != null ? memberAddress.getStreet() : "");
            }
            OrderDelay orderDelay = null;
            if (orderDelayMap != null && CollectionUtils.isNotEmpty(orderDelayMap.get(dto.getId()))) {
                List<OrderDelay> orderDelays = orderDelayMap.get(dto.getId());
                if (CollectionUtils.isNotEmpty(orderDelays) && orderDelays.get(0) != null) {
                    orderDelay = orderDelays.get(0);
                }
            }
            // 外卖预约单
            if (dto.getTakeType() > 0 && dto.getWaimaiOrderId() != null) {
                this.setDelayTime(orderDelay, dto, null);
            }
            // 设置按钮状态
            dto.setButtonStatus(this.getButtonStatus(dto));
            result.add(dto);
        }
        return result;
    }

}