liebao-cloud/lb-app/src/main/java/com/ydd/app/OrderEntityUtils.java

package com.ydd.app;

import com.fasterxml.jackson.core.type.TypeReference;
import com.google.common.collect.Lists;
import com.ydd.app.dto.AddressReq;
import com.ydd.app.dto.OrderReq;
import com.ydd.common.enums.DeliveryTypeEnums;
import com.ydd.common.utils.DateUtils;
import com.ydd.common.utils.StringUtils;
import com.ydd.ecloud.core.utils.JsonMapper;
import com.ydd.module.domain.WaimaiOrderDetail;
import com.ydd.module.dto.DeliveryInfo;
import com.ydd.module.dto.SfShopDto;
import com.ydd.third.common.dto.MaKePtProductVo;
import com.ydd.third.common.vo.dada.config.DadaConstant;
import com.ydd.third.common.vo.dada.domain.order.GoodsInfo;
import com.ydd.third.common.vo.vo.order.OrderVo;

import com.ydd.third.common.vo.vo.order.ProductVo;
import com.ydd.third.common.vo.waimai.meituan.OpenApiGood;
import org.apache.commons.collections4.CollectionUtils;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * Project：lb-server
 * Class：OrderEntityUtils
 * Description：TODO
 * Time：2021/3/8 16:14
 *
 * @author zoe
 */
public class OrderEntityUtils {


    /**
     * @param orderReq
     * @param delivery
     * @return
     * @Description 创建配送订单
     * @Author peakren
     * @Date 2021/3/26 3:21 PM
     */
    public static OrderVo createOrderVo(OrderReq orderReq, DeliveryInfo delivery) {
        return createOrderVo(orderReq, delivery, false);
    }


    /**
     * @param orderReq
     * @param delivery
     * @return
     * @Description 创建配送订单
     * @Author peakren
     * @Date 2021/3/26 3:21 PM
     *
     * app改版需求: 猎豹AI针对配送方都是即时单 2022-02-26修改
     */
    public static OrderVo createOrderVo(OrderReq orderReq, DeliveryInfo delivery, boolean isTest) {
        OrderVo orderVo = new OrderVo();
        /**
         * 备注
         */
//        if(StringUtils.isNotBlank(orderReq.getTakeRemark())){
//            orderVo.setRemark(orderReq.getTakeRemark().trim());
//        }
        String remark = orderReq.getWaiMaiRemark();
        if(StringUtils.isNotBlank(remark)){
            if (StringUtils.isNotBlank(remark) && remark.contains("收餐人隐私号")) {
                remark = remark.substring(0, remark.indexOf("收餐人隐私号"));
            }
            if(StringUtils.isNotBlank(orderReq.getTakeRemark())&&!orderReq.getTakeRemark().equals(remark)){
                remark = "【"+orderReq.getTakeRemark()+"】" + remark;
            }
            if(StringUtils.isNotBlank(remark)&&remark.length()>200){
                remark = remark.substring(0,200);
            }
            orderVo.setRemark(remark);
        }else if(StringUtils.isNotBlank(orderReq.getTakeRemark())){
            orderVo.setRemark(orderReq.getTakeRemark().trim());
        }

        /**
         * 发件人信息
         */
        AddressReq sendAddress = orderReq.getSendAddress();
        orderVo.setFromAddress(checkAddress(sendAddress.getAddress()));
        if(StringUtils.isNotBlank(sendAddress.getStreet()) && !sendAddress.getAddress().endsWith(sendAddress.getStreet())){
            orderVo.setFromAddressDetail(checkAddress(sendAddress.getStreet()));
            orderVo.setFromAddressWithHouseNumber(checkAddress(sendAddress.getAddress() + sendAddress.getStreet()));
        }else{
            orderVo.setFromAddressDetail("");
            orderVo.setFromAddressWithHouseNumber(checkAddress(sendAddress.getAddress()));
        }
        if(StringUtils.isNotBlank(sendAddress.getExtension())){
            orderVo.setFromMobile(sendAddress.getPhone()+"_"+sendAddress.getExtension());
        }else{
            orderVo.setFromMobile(sendAddress.getPhone());
        }
        orderVo.setFromSenderName(sendAddress.getContact());
        orderVo.setFromLongitude(new BigDecimal(sendAddress.getLng()));
        orderVo.setFromLatitude(new BigDecimal(sendAddress.getLat()));
        orderVo.setSenderCity(sendAddress.getCityName());
        if (sendAddress.getDistrictName() != null){
            orderVo.setFromDistrictName(sendAddress.getDistrictName().toString());
        }else {
            orderVo.setFromDistrictName("城区");
        }
        if ("石河子市".equals(sendAddress.getDistrictName()) ){
            orderVo.setSenderCity("石河子市");
            sendAddress.setCityName("石河子市");
        }
        /**
         * 收件人信息
         */
        AddressReq receiptAddress = orderReq.getReceiptAddress();
        orderVo.setReceiverName(receiptAddress.getContact());
        orderVo.setReceiverAddress(checkAddress(receiptAddress.getAddress()));
        orderVo.setReceiverCity(receiptAddress.getCityName());
        if(StringUtils.isNotBlank(receiptAddress.getStreet())&&!receiptAddress.getAddress().endsWith(receiptAddress.getStreet())){
            orderVo.setReceiverAddressDetail(checkAddress(receiptAddress.getStreet()));
            orderVo.setReceiverAddressWithHouseNumber(checkAddress(receiptAddress.getAddress() + receiptAddress.getStreet()));
        }else{
            orderVo.setReceiverAddressDetail("");
            orderVo.setReceiverAddressWithHouseNumber(checkAddress(receiptAddress.getAddress()));
        }
        if ("石河子市".equals(receiptAddress.getDistrictName()) ){
            orderVo.setReceiverCity("石河子市");
            receiptAddress.setCityName("石河子市");
        }
      //  orderVo.setReceiverAddressDetail(receiptAddress.getStreet());
        orderVo.setReceiverLat(new BigDecimal(receiptAddress.getLat()));
        orderVo.setReceiverLng(new BigDecimal(receiptAddress.getLng()));
        if(StringUtils.isNotBlank(receiptAddress.getExtension())){
            orderVo.setReceiverPhone(receiptAddress.getPhone()+"_"+receiptAddress.getExtension().trim());
        }else{
            orderVo.setReceiverPhone(receiptAddress.getPhone());
        }

        if (receiptAddress.getDistrictName() != null){
            orderVo.setReceiverDistrictName(receiptAddress.getDistrictName().toString());
        }else {
            orderVo.setReceiverDistrictName("城区");
        }

        BigDecimal orderMoney = orderReq.getAmount();
        BigDecimal waiMaiMoney = orderReq.getMtMoney();
        /**
         * 外卖商品信息
         */
        List<WaimaiOrderDetail> details = new ArrayList<>();
        if (orderReq.getWaimaiOrderDetails() != null){
            details = orderReq.getWaimaiOrderDetails();
        }
        List<ProductVo> fnGoods = new ArrayList<>();
        List<OpenApiGood> mtGoods = new ArrayList<>();
        List<GoodsInfo> dadaGoodsList = new ArrayList<>();
        List<MaKePtProductVo> maKePtProductVos = Lists.newArrayList();
        for (WaimaiOrderDetail d : details){
            StringBuilder spec = new StringBuilder();
            if(StringUtils.isNotBlank(d.getFoodProperty())){
                spec.append(d.getFoodProperty());
            }
            if(StringUtils.isNotBlank(spec.toString())&&StringUtils.isNotBlank(d.getSpec())){
                spec.append(",").append(d.getSpec());
            }else if(StringUtils.isBlank(spec.toString())&&StringUtils.isNotBlank(d.getSpec())){
                spec.append(d.getSpec());
            }
            OpenApiGood good = new OpenApiGood();
            ProductVo dto = new ProductVo();
            GoodsInfo dadaGoods = new GoodsInfo();
            MaKePtProductVo ptProductVo = new MaKePtProductVo();
            good.setGoodCount(d.getQuantity().intValue());
            good.setGoodName(d.getFoodName());
            good.setGoodPrice(d.getPrice());
            dto.setProductName(d.getFoodName());
            dadaGoods.setSku_name(d.getFoodName());
            ptProductVo.setName(d.getFoodName());
            if(StringUtils.isNotBlank(spec.toString())){
                good.setGoodName(d.getFoodName()+"("+spec.toString()+")");
                dto.setProductName(d.getFoodName()+"("+spec.toString()+")");
                dadaGoods.setSku_name(d.getFoodName()+"("+spec.toString()+")");
                ptProductVo.setName(d.getFoodName()+"("+spec.toString()+")");
            }
            mtGoods.add(good);
            dto.setProductNum(d.getQuantity().intValue());
            dto.setProductActualMoney(d.getPrice());
            dto.setProductMoney(d.getPrice());
            fnGoods.add(dto);
            dadaGoods.setSrc_product_no(d.getId().toString());
            dadaGoods.setCount(d.getQuantity().doubleValue());
            dadaGoodsList.add(dadaGoods);
            ptProductVo.setNum(d.getQuantity().toString());
            ptProductVo.setPrice(d.getPrice().toString());
            maKePtProductVos.add(ptProductVo);
        }

        // 使用的运力平台是自己的平台还是我们的平台
        orderVo.setIsMine(orderReq.getIsMine());
        // 普通订单价格
        if (orderMoney == null) {
            orderMoney = new BigDecimal("50");
        }
        // 外卖订单价格
        if (waiMaiMoney != null){
            orderMoney = waiMaiMoney;
        }
        if (DeliveryTypeEnums.DADA.getType().equals(delivery.getType())) {
            orderVo.setLbClient(DeliveryTypeEnums.DADA.getName());
            if(StringUtils.isNotBlank(orderReq.getShopName())){
                orderVo.setFromSenderName(orderReq.getShopName());
            }
            /**
             * 门店编号
             * 达达
             * shop_no 必传
             * 门店编号，门店创建后可在门店列表和单页查看
             */
            orderVo.setShopNo(delivery.getShopId());

            /**
             * 第三方订单ID
             * 达达
             * origin_id 必传
             */
            orderVo.setOrderNo(orderReq.getOrderSn());
            /**
             * 达达
             * city_code，必传
             *  可调用相关接口查看，经查与所在城市的区号一致
             */
            orderVo.setCityCode(orderReq.getSendAddress().getCityCode());
            /**
             * 	订单金额
             * 达达
             * cargo_price，必传
             * 这个订单的货物的金额，单位元
             */
            orderVo.setOrderMoney(orderMoney);
            /**
             * 预约发单时间
             * 达达
             * delay_publish_time，不必传
             * 可以支持未来3天内的订单发预约单。
             */
//            if (TakeTypeEnum.APPOINTMENT.type.equals(orderReq.getTakeType())) {
//                orderVo.setDelayPublishTime(DateUtils.parseDate(orderReq.getTakeTime()));
//            }
            /**
             * 达达
             * 回调URL，必传
             */
            orderVo.setCallback(DadaConstant.getCallbackUrl(isTest));
            /**
             * 物品类型
             * 达达
             * cargo_type，不必传
             * 订单商品类型：
             * 食品小吃-1,饮料-2,鲜花-3,文印票务-8,便利店-9,水果生鲜-13,同城电商-19, 医药-20,蛋糕-21,酒品-24,小商品市场-25,
             * 服装-26,汽修零配-27,数码-28,小龙虾-29,火锅-51,其他-5
             */
            orderVo.setGoodsType(Integer.valueOf(orderReq.getProduct().getDadaProductType()));
            /**
             * 订单来源标示和订单来源编号
             */
            if (StringUtils.isNotBlank(orderReq.getOrderSource())){
                if (orderReq.getOrderSource().equals("101")){
                    orderVo.setOriginMark("mt");
                    orderVo.setOriginMarkNo(orderReq.getPoiSeq());
                }else if (orderReq.getOrderSource().equals("102")||orderReq.getOrderSource().equals("103")){
                    orderVo.setOriginMark("elm");
                    orderVo.setOriginMarkNo(orderReq.getPoiSeq());
                } else if (orderReq.getOrderSource().equals("104")){
                    orderVo.setOriginMark("jdhome");
                    orderVo.setOriginMarkNo(orderReq.getPoiSeq());
                }
            }
            /**
             * 订单重量
             * 达达
             * cargo_weight 必传
             * 货物重量（单位：Kg）
             */
            orderVo.setWeight(new BigDecimal(orderReq.getWeight()));
            /**
             * 订单商品数量
             * 达达:
             * cargo_num，不必传
             */
            orderVo.setGoodsNum(1);
            //设置是否是指定商家
//            if (delivery.getPreferredDelivery().equals(StatusEnum.SHOW.status)) {
            orderVo.setIsShansongSH(true);
            orderVo.setMerchantId(delivery.getThirdShopId());
            orderVo.setAccessToken(delivery.getAuthToken());
            orderVo.setTips(orderReq.getTipAmount());
            // 订单商品
            orderVo.setDadaGoods(dadaGoodsList);
            orderVo.setOrderingSourceNo(orderReq.getOrderingSourceNo());

//            }

        }
        if (DeliveryTypeEnums.DADA_YZ.getType().equals(delivery.getType())) {
            orderVo.setLbClient(DeliveryTypeEnums.DADA_YZ.getName());
            if(StringUtils.isNotBlank(orderReq.getShopName())){
                orderVo.setFromSenderName(orderReq.getShopName());
            }
            /**
             * 门店编号
             * 达达
             * shop_no 必传
             * 门店编号，门店创建后可在门店列表和单页查看
             */
            orderVo.setShopNo(delivery.getShopId());

            /**
             * 第三方订单ID
             * 达达
             * origin_id 必传
             */
            orderVo.setOrderNo(orderReq.getOrderSn());
            /**
             * 达达
             * city_code，必传
             *  可调用相关接口查看，经查与所在城市的区号一致
             */
            orderVo.setCityCode(orderReq.getSendAddress().getCityCode());
            /**
             * 	订单金额
             * 达达
             * cargo_price，必传
             * 这个订单的货物的金额，单位元
             */
            orderVo.setOrderMoney(orderMoney);
            /**
             * 预约发单时间
             * 达达
             * delay_publish_time，不必传
             * 可以支持未来3天内的订单发预约单。
             */
//            if (TakeTypeEnum.APPOINTMENT.type.equals(orderReq.getTakeType())) {
//                orderVo.setDelayPublishTime(DateUtils.parseDate(orderReq.getTakeTime()));
//            }
            /**
             * 达达
             * 回调URL，必传
             */
            orderVo.setCallback(DadaConstant.getYzCallbackUrl(isTest));
            /**
             * 物品类型
             * 达达
             * cargo_type，不必传
             * 订单商品类型：
             * 食品小吃-1,饮料-2,鲜花-3,文印票务-8,便利店-9,水果生鲜-13,同城电商-19, 医药-20,蛋糕-21,酒品-24,小商品市场-25,
             * 服装-26,汽修零配-27,数码-28,小龙虾-29,火锅-51,其他-5
             */
            orderVo.setGoodsType(Integer.valueOf(orderReq.getProduct().getDadaProductType()));
            /**
             * 订单来源标示和订单来源编号
             */
            if (StringUtils.isNotBlank(orderReq.getOrderSource())){
                if (orderReq.getOrderSource().equals("101")){
                    orderVo.setOriginMark("mt");
                    orderVo.setOriginMarkNo(orderReq.getPoiSeq());
                }else if (orderReq.getOrderSource().equals("102")||orderReq.getOrderSource().equals("103")){
                    orderVo.setOriginMark("elm");
                    orderVo.setOriginMarkNo(orderReq.getPoiSeq());
                }   else if (orderReq.getOrderSource().equals("104")){
                    orderVo.setOriginMark("jdhome");
                    orderVo.setOriginMarkNo(orderReq.getPoiSeq());
                }
            }
            /**
             * 订单重量
             * 达达
             * cargo_weight 必传
             * 货物重量（单位：Kg）
             */
            orderVo.setWeight(new BigDecimal(orderReq.getWeight()));
            /**
             * 订单商品数量
             * 达达:
             * cargo_num，不必传
             */
            orderVo.setGoodsNum(1);

            orderVo.setIsDirectDelivery(1);
            //设置是否是指定商家
//            if (delivery.getPreferredDelivery().equals(StatusEnum.SHOW.status)) {
            orderVo.setIsShansongSH(true);
            orderVo.setMerchantId(delivery.getThirdShopId());
            orderVo.setAccessToken(delivery.getAuthToken());
            orderVo.setTips(orderReq.getTipAmount());
            // 订单商品
            orderVo.setDadaGoods(dadaGoodsList);
            orderVo.setOrderingSourceNo(orderReq.getOrderingSourceNo());
//            }

        } else if (DeliveryTypeEnums.SHAN_SONG.getType().equals(delivery.getType())) {

            orderVo.setLbClient(DeliveryTypeEnums.SHAN_SONG.getName());
            /**
             * 第三方平台订单流水号
             * 闪送
             * orderNo 必传
             */
            orderVo.setOrderNo(orderReq.getOrderSn());

            /**
             * 城市名称
             * 闪送
             * cityName 必传
             * 城市名称:市级即可
             */
            orderVo.setCityName(orderReq.getReceiptAddress().getCityName());

            /**
             * 预约类型
             * 闪送
             * appointType 必传
             * 闪送：appointType，0立即单，1预约单
             */
            orderVo.setIsAppoint(0);
//            if (TakeTypeEnum.APPOINTMENT.type.equals(orderReq.getTakeType())) {
//                orderVo.setIsAppoint(1);
//                /**
//                 * 预约取货时间
//                 * 闪送
//                 * 预约单，期望取货时间
//                 * appointmentDate 非必传
//                 */
//                orderVo.setExpectedPickupTime(DateUtils.parseDate(orderReq.getTakeTime()));
//            }

            /**
             * 物品来源
             * 闪送
             * orderingSourceType 非必传
             * 对应商家版物品来源,支持美团,饿了么，可以为空
             * 物品来源流水号 orderingSourceNo
             */
            if (StringUtils.isNotBlank(orderReq.getOrderSource())){
                if (orderReq.getOrderSource().equals("101")){
                    orderVo.setOrderingSourceType(4);
                    orderVo.setOrderingSourceNo(orderReq.getPoiSeq());
                }else if (orderReq.getOrderSource().equals("102")||orderReq.getOrderSource().equals("103")){
                    orderVo.setOrderingSourceType(3);
                    orderVo.setOrderingSourceNo(orderReq.getPoiSeq());
                } else if (orderReq.getOrderSource().equals("104")){
                    orderVo.setOrderingSourceType(6);
                    orderVo.setOrderingSourceNo(orderReq.getPoiSeq());
                }
            }
            /**
             * 小费
             * 闪送
             * additionFee 非必传
             * 小费（单位：元）
             */
            if (orderReq.getTipAmount() != null && orderReq.getTipAmount().compareTo(BigDecimal.ZERO) > 0) {
                orderVo.setTips(orderReq.getTipAmount());
            }

            /**
             * 物品类型
             * 闪送
             * goodType 必传
             * 闪送：goodType
             */

            orderVo.setGoodsType(Integer.valueOf(orderReq.getProduct().getSsProductType()));

            /**
             * 物品重量
             * 闪送
             * weight 必传
             * 订单重量（单位：Kg）
             */
            orderVo.setWeight(new BigDecimal(orderReq.getWeight()));
            //设置是否是指定商家
//            if (delivery.getPreferredDelivery().equals(StatusEnum.SHOW.status)) {
            orderVo.setIsShansongSH(true);
            orderVo.setAccessToken(delivery.getAuthToken());
            orderVo.setShopNo(delivery.getShopId());
            if (StringUtils.isNotBlank(orderReq.getOutOrderId())) {
                orderVo.setOrderNumber(orderReq.getOutOrderId());
            }

//            }
        } else if (DeliveryTypeEnums.SHUN_FENG.getType().equals(delivery.getType())) {
            orderVo.setLbClient(DeliveryTypeEnums.SHUN_FENG.getName());
            if (StringUtils.isNotBlank(delivery.getThirdShopId())) {
                orderVo.setShopNo(delivery.getThirdShopId());

                /**
                 * 物品类型
                 * 顺丰
                 * 物品类型
                 * product_type 必传
                 * 顺丰：product_type1:快餐 2:送药 3:百货 4:脏衣服收 5:干净衣服派 6:生鲜 7:保8:高端饮9:现场勘验 10:快递 12:文件 13:蛋糕 14:鲜花 15:电子数码 16:服装鞋帽 17:汽车配件 18:珠宝
                 * 20:披萨 21:中餐 22:水产 27:专人直送 32:中端饮品 33:便利店 34:面包糕点 35:火锅 36:证照 41:外部落地 99:其他
                 */
                orderVo.setGoodsType(Integer.valueOf(orderReq.getProduct().getSfProductType()));
            } else {
                //匹配出顺丰shop_id
                List<SfShopDto> list = JsonMapper.nonEmptyMapper().fromJson(delivery.getShopId(), new TypeReference<List<SfShopDto>>() {
                });
                if (CollectionUtils.isNotEmpty(list)) {
                    for (SfShopDto dto : list) {
                        if("张家港市".equals(orderReq.getSendAddress().getDistrictName())||"常熟市".equals(orderReq.getSendAddress().getDistrictName())
                                ||"寿光市".equals(orderReq.getSendAddress().getDistrictName())){
                            if (dto.getCity().equals(orderReq.getSendAddress().getDistrictName())) {
                                orderVo.setShopNo(dto.getShopId());
                                orderVo.setGoodsType(Integer.valueOf(orderReq.getProduct().getSfProductType()));
                                break;
                            }
                        }
                        else if(dto.getCity().equals(orderReq.getSendAddress().getCityName())) {
                            /**
                             * 店铺ID
                             * 顺丰：
                             * shop_id 必传
                             */
                            orderVo.setShopNo(dto.getShopId());

                            /**
                             * 物品类型
                             * 顺丰
                             * 物品类型
                             * product_type 必传
                             * 顺丰：product_type1:快餐 2:送药 3:百货 4:脏衣服收 5:干净衣服派 6:生鲜 7:保8:高端饮9:现场勘验 10:快递 12:文件 13:蛋糕 14:鲜花 15:电子数码 16:服装鞋帽 17:汽车配件 18:珠宝
                             * 20:披萨 21:中餐 22:水产 27:专人直送 32:中端饮品 33:便利店 34:面包糕点 35:火锅 36:证照 41:外部落地 99:其他
                             */
                            orderVo.setGoodsType(Integer.valueOf(orderReq.getProduct().getSfProductType()));
                            break;
                        }
                    }
                } else {
                    //不设置商家店铺，默认走全国统一个人快递业务
                    orderVo.setShopNo("3258674679761");
                    orderVo.setGoodsType(10);  //顺丰开通的默认是快递
                }
            }

            /**
             * 店铺类型
             * 顺丰
             * shop_type 不必传
             * 顺丰：1:顺丰店铺ID 2:接入方店铺ID
             */
//            orderVo.setShopType(1);

            /**
             * 商家订单号
             * 顺丰
             * shop_order_id 必传
             * 商家订单号	不允许重复
             */
            orderVo.setOrderNo(orderReq.getOrderSn());


            /**
             * 闪送,顺丰
             * 对应商家版物品来源,支持美团,饿了么，可以为空
             * 顺丰：
             */
            // orderVo.setorderingSourceType;

            /**
             * 订单接入来源
             * 顺丰
             * order_source 必传
             * 订单接入来源	1：美团；2：饿了么；3：百度；4：口碑；
             * 其他请直接填写中文字符串值
             *
             */
            if (StringUtils.isNotBlank(orderReq.getOrderSource())){
                if (orderReq.getOrderSource().equals("101")){
                    orderVo.setOrderSource("1");
                    orderVo.setOrderSequence(orderReq.getPoiSeq());
                }else if (orderReq.getOrderSource().equals("102")||orderReq.getOrderSource().equals("103")){
                    orderVo.setOrderSource("2");
                    orderVo.setOrderSequence(orderReq.getPoiSeq());
                }
                else if (orderReq.getOrderSource().equals("104")){
                    orderVo.setOrderSource("京东到家");
                    orderVo.setOrderSequence(orderReq.getPoiSeq());
                }
            }else {
                orderVo.setOrderSource("商家APP");
            }
            /**
             * 店铺名称
             * 顺丰
             * shop_name 必传
             */
            orderVo.setShopName(orderReq.getSendAddress().getContact());

            /**
             * 店铺电话
             * 顺丰
             * shop_phone 必传
             */
            orderVo.setShopPhone(orderReq.getSendAddress().getPhone());
            /**
             * 店铺地址
             * 顺丰
             * shop_address 必传
             */
            // orderVo.setShopAddress("北京北京市海淀区华润五彩城购物中心");
            orderVo.setShopAddress(orderReq.getSendAddress().getAddress());
            /**
             * 店铺经度
             * 顺丰
             * shop_lng 不必传
             * 店铺经度
             */
            orderVo.setShopLng(new BigDecimal(orderReq.getSendAddress().getLng()));
            /**
             * 店铺纬度
             * 顺丰
             * shop_lat 不必传
             */
            orderVo.setShopLat(new BigDecimal(orderReq.getSendAddress().getLat()));

            /**
             * 订单金额
             * 顺丰
             * total_price 必传
             * 用户订单总金额（单位：元）
             *
             */
            orderVo.setOrderMoney(orderMoney);

            /**
             * 	是否是预约单
             * 顺丰
             * is_appoint 必传
             * 是否是预约单	0：非预约单；1：预约单
             */
            orderVo.setIsAppoint(0);


            /**
             * 预约单，期望送达时间
             * 顺丰
             * expect_time 不必传
             * 预约单，	用户期望送达时间,appoint_type=1时需必传,秒级时间戳
             */
            orderVo.setExpectedDeliveryTime(null);
            /**
             * 小费
             * 顺丰
             * gratuity_fee 不必传
             * 小费（单位：元，精确小数点后一位）
             */
            orderVo.setTips(orderReq.getTipAmount());

            /**
             * 订单重量（单位：Kg）
             * 顺丰
             * weight 必传
             * 订单重量（单位：Kg）
             * 物品重量（单位：千克）
             */
            orderVo.setWeight(new BigDecimal(orderReq.getWeight()));

            /**
             * 订单商品数量
             * 顺丰
             * product_num 必传
             * 订单商品数量
             */
            orderVo.setGoodsNum(1);
            /**
             * 商品类型个数
             * 顺丰
             * product_type_num 必传
             * 商品类型个数
             */
            orderVo.setGoodsTypeNum(1);

            //设置是否是指定商家
//            if (delivery.getPreferredDelivery().equals(StatusEnum.SHOW.status)) {
            orderVo.setIsShansongSH(true);
            orderVo.setAccessToken(delivery.getAuthToken());
            List<ProductVo> productList = new ArrayList<>();
            if (orderReq.getOrderSource() == null){
                // 普通订单
                ProductVo vo = new ProductVo();
                vo.setProductNum(orderVo.getGoodsNum());
                vo.setProductName(orderReq.getProduct().getName());
                productList.add(vo);
            }else {
                // 外卖订单
                for (WaimaiOrderDetail d : details){
                    StringBuilder spec = new StringBuilder();
                    if(StringUtils.isNotBlank(d.getFoodProperty())){
                        spec.append(d.getFoodProperty());
                    }
                    if(StringUtils.isNotBlank(spec.toString())&&StringUtils.isNotBlank(d.getSpec())){
                        spec.append(",").append(d.getSpec());
                    }else if(StringUtils.isBlank(spec.toString())&&StringUtils.isNotBlank(d.getSpec())){
                        spec.append(d.getSpec());
                    }
                    ProductVo vo = new ProductVo();
                    vo.setProductNum(d.getQuantity().intValue());
                    vo.setProductName(d.getFoodName());
                    if(StringUtils.isNotBlank(spec.toString())){
                        vo.setProductName(d.getFoodName()+"("+spec.toString()+")");
                    }
                    productList.add(vo);
                }
            }
            orderVo.setProductList(productList);
//            }
        } else if (DeliveryTypeEnums.DWD.getType().equals(delivery.getType())) {
            orderVo.setLbClient(DeliveryTypeEnums.DWD.getName());

            /**
             * 商家订单号
             */
            orderVo.setOrderNo(orderReq.getOrderSn());

            orderVo.setShopNo(delivery.getShopId());
            /**
             * 店铺名称
             * 顺丰
             * shop_name 必传
             */
            orderVo.setShopName(orderReq.getSendAddress().getContact());

            /**
             * 店铺电话
             * 顺丰
             * shop_phone 必传
             */
            orderVo.setShopPhone(orderReq.getSendAddress().getPhone());
            /**
             * 店铺地址
             * 顺丰
             * shop_address 必传
             */
            orderVo.setShopAddress(orderReq.getSendAddress().getAddress());
            /**
             * 店铺经度
             * 顺丰
             * shop_lng 不必传
             * 店铺经度
             */
            orderVo.setShopLng(new BigDecimal(orderReq.getSendAddress().getLng()));
            /**
             * 店铺纬度
             * 顺丰
             * shop_lat 不必传
             */
            orderVo.setShopLat(new BigDecimal(orderReq.getSendAddress().getLat()));

            /**
             * 订单金额
             * 顺丰
             * total_price 必传
             * 用户订单总金额（单位：元）
             *
             */
            orderVo.setOrderMoney(new BigDecimal(10));

            /**
             * 	是否是预约单
             * 顺丰
             * is_appoint 必传
             * 是否是预约单	0：非预约单；1：预约单
             */
            orderVo.setIsAppoint(0);
//            if (orderReq.getTakeType().equals(TakeTypeEnum.APPOINTMENT.type)) {
//                orderVo.setIsAppoint(1);
//                /**
//                 * 用户期望上门时间
//                 * 顺丰
//                 * expect_pickup_time 不必传
//                 * 预约单，期望取货时间
//                 */
//                orderVo.setExpectedPickupTime(DateUtils.parseDate(orderReq.getTakeTime()));
//            }


            /**
             * 收货人姓名
             * 顺丰
             * user_name 必传
             *
             */
            orderVo.setReceiverName(orderReq.getReceiptAddress().getContact());

            /**
             * 收货人地址
             * 顺丰
             * user_address 不必传
             * 用户详细地址
             */
            orderVo.setReceiverAddress(orderReq.getReceiptAddress().getAddress());

            /**
             * 收货人地址纬度
             * 顺丰
             * user_lat 不必传
             * 用户地址纬度
             */
            orderVo.setReceiverLat(new BigDecimal(orderReq.getReceiptAddress().getLat()));

            /**
             * 收货人地址经度
             * 顺丰
             * user_lng 不必传
             * 用户地址经度
             *
             */
            orderVo.setReceiverLng(new BigDecimal(orderReq.getReceiptAddress().getLng()));


            /**
             * 收货人手机号
             * 顺丰
             * user_phone 必传
             */
            orderVo.setReceiverPhone(orderReq.getReceiptAddress().getPhone());


            /**
             * 小费
             * 顺丰
             * gratuity_fee 不必传
             * 小费（单位：元，精确小数点后一位）
             */
            orderVo.setTips(new BigDecimal(0));

            /**
             * 物品类型
             * 顺丰
             * 物品类型
             * product_type 必传
             * 顺丰：product_type1:快餐 2:送药 3:百货 4:脏衣服收 5:干净衣服派 6:生鲜 7:保8:高端饮9:现场勘验 10:快递 12:文件 13:蛋糕 14:鲜花 15:电子数码 16:服装鞋帽 17:汽车配件 18:珠宝
             * 20:披萨 21:中餐 22:水产 27:专人直送 32:中端饮品 33:便利店 34:面包糕点 35:火锅 36:证照 41:外部落地 99:其他
             */
            orderVo.setGoodsType(Integer.valueOf(orderReq.getProduct().getSfProductType()));

            /**
             * weight 必传
             * 物品重量（单位：g）
             */
            orderVo.setWeight(new BigDecimal(orderReq.getWeight()).multiply(new BigDecimal(10)));

            /**
             * 订单商品数量
             * 顺丰
             * product_num 必传
             * 订单商品数量
             */
            orderVo.setGoodsNum(1);

            /**
             * 商品类型个数
             * 顺丰
             * product_type_num 必传
             * 商品类型个数
             */
            orderVo.setGoodsTypeNum(1);
        } else if (DeliveryTypeEnums.UUPT.getType().equals(delivery.getType())) {
            orderVo.setLbClient(DeliveryTypeEnums.UUPT.getName());
            orderVo.setCityName(orderReq.getSendAddress().getCityName());
            orderVo.setOrderNo(orderReq.getOrderSn());
            orderVo.setOpenId(delivery.getShopId());
            orderVo.setGoodInfo(orderReq.getProduct().getUuptProductType());
          //  orderVo.setReceiverPhone(orderReq.getReceiptAddress().getPhone());
            if (StringUtils.isNotBlank(orderReq.getOrderSource())){
                if (orderReq.getOrderSource().equals("101")){
                    orderVo.setOrderSource("1");
                    orderVo.setOrderingSourceNo(orderReq.getPoiSeq());
                }else if (orderReq.getOrderSource().equals("102")||orderReq.getOrderSource().equals("103")){
                    orderVo.setOrderSource("2");
                    orderVo.setOrderingSourceNo(orderReq.getPoiSeq());
                } else if (orderReq.getOrderSource().equals("104")){
                    orderVo.setOrderSource("3");
                    orderVo.setOrderingSourceNo(orderReq.getPoiSeq());
                }
            }else {
                orderVo.setOrderSource("3");
            }
//            if (TakeTypeEnum.APPOINTMENT.type.equals(orderReq.getTakeType())) {
//                /**
//                 * * UUPTorder_type，订单类型（0实时订单 1预约取件时间）
//                 */
//                orderVo.setIsAppoint(1);
//                /**
//                 * 预约单，期望取货时间
//                 *   UUPTorder_type: expect_fetch_time，非必须
//                 */
//                orderVo.setExpectedPickupTime(DateUtils.parseDate(orderReq.getTakeTime()));
//
//                /**
//                 * 预约单，期望送达时间,非必须
//                 * 蜂鸟V3：require_receive_time，需要送达时间（毫秒）
//                 */
//                orderVo.setExpectedDeliveryTime(null);
//            }
            orderVo.setWeight(new BigDecimal(orderReq.getWeight()));
            if (orderReq.getPriceToken() != null) {
                orderVo.setPriceToken(orderReq.getPriceToken());
                orderVo.setOrderMoney(new BigDecimal(orderReq.getTotalMoney()));
                orderVo.setOrderActualMoney(new BigDecimal(orderReq.getNeedPaymoney()));
            }

        } else if (DeliveryTypeEnums.AIPT.getType().equals(delivery.getType())) {
            // 开始城市-发件,结束城市-收件
            orderVo.setLbClient(DeliveryTypeEnums.AIPT.getName());
            orderVo.setStartCity(orderReq.getSendAddress().getCityName());
            orderVo.setEndCity(orderReq.getReceiptAddress().getCityName());
            orderVo.setOrderNo(orderReq.getOrderSn());
//            if (delivery.getPreferredDelivery().equals(StatusEnum.SHOW.status)) {
            orderVo.setPhone(delivery.getPhone());
//            }
            orderVo.setGoodInfo(orderReq.getProduct().getName());
            orderVo.setOrderId(orderReq.getOrderId());
            orderVo.setExpectedPickupTime(DateUtils.parseDate(orderReq.getTakeTime()));
            orderVo.setWeight(new BigDecimal(orderReq.getWeight()));
        } else if (DeliveryTypeEnums.FENG_NIAO.getType().equals(delivery.getType())) {
            /**
             * 表示调用蜂鸟的api
             */
            orderVo.setLbClient(DeliveryTypeEnums.FENG_NIAO.getName());

            /**
             * 门店编号
             * shop_no 必传
             * 蜂鸟V3：chain_store_code
             */
            orderVo.setShopNo(delivery.getThirdShopId()); //"203361315");

            /**
             * 取货点地址
             * 蜂鸟V3：transport_address，取货点地址
             */
            orderVo.setShopAddress(sendAddress.getAddress());

            /**
             *
             * 第三方订单ID
             * 蜂鸟V3：partner_order_code
             */
            orderVo.setOrderNo(orderReq.getOrderSn());

            /**
             *
             * 	订单金额,必传
             * 蜂鸟V3:goods_total_amount_cent
             * 这个订单的货物的金额，单位元
             */
            orderVo.setOrderMoney(orderMoney);

            /**
             * 客户需要支付的金额,必传
             * 蜂鸟v3: goods_actual_amount_cent
             */
            orderVo.setOrderActualMoney(orderMoney);

            /**
             * * 蜂鸟V3：order_type，订单类型（1:即时单，3:预约单）
             */
            orderVo.setIsAppoint(0);
            /**
             * 预约单，期望取货时间
             *   蜂鸟V3: expect_fetch_time，非必须
             */
            orderVo.setExpectedPickupTime(null);

            /**
             * 预约单，期望送达时间,非必须
             * 蜂鸟V3：require_receive_time，需要送达时间（毫秒）
             */
            orderVo.setExpectedDeliveryTime(null);

//            if (TakeTypeEnum.APPOINTMENT.type.equals(orderReq.getTakeType())) {
//                /**
//                 * * 蜂鸟V3：order_type，订单类型（1:即时单，3:预约单）
//                 */
//                orderVo.setIsAppoint(3);
//                /**
//                 * 预约单，期望取货时间
//                 *   蜂鸟V3: expect_fetch_time，非必须
//                 */
//                orderVo.setExpectedPickupTime(DateUtils.parseDate(orderReq.getTakeTime()));
//                /**
//                 * 预约单，期望送达时间,非必须
//                 * 蜂鸟V3：require_receive_time，需要送达时间（毫秒）
//                 */
//                orderVo.setExpectedDeliveryTime(null);
//            }

            /**
             * 商家订单流水号
             */
            orderVo.setPoiSeq(orderReq.getPoiSeq());
            /**
             * 蜂鸟V3：
             * 商户订单来源（如 饿了么、美团等）
             * 手发单/未知来源: 0 或不传 美团: 2 口碑: 4 饿了么: 6 支付宝: 7 饿百: 8
             */
            if (StringUtils.isNotBlank(orderReq.getOrderSource())){
                if (orderReq.getOrderSource().equals("101")){
                    orderVo.setOrderSource("2");
                    orderVo.setPoiSeq("M"+orderReq.getPoiSeq());
                }else if (orderReq.getOrderSource().equals("102")){
                    orderVo.setOrderSource("6");
                }else if (orderReq.getOrderSource().equals("103")){
                    orderVo.setOrderSource("8");
                }else if (orderReq.getOrderSource().equals("104")){
                    orderVo.setOrderSource("0");
                }
            } else {
                orderVo.setOrderSource("0");
            }

            /**
             * 小费
             * 蜂鸟V3:order_tip_amount_cent
             * 小费（单位：元，精确小数点后一位）
             */
//            orderVo.setTips(orderReq.getTipAmount());

            /**
             * //
             * 订单重量
             * 蜂鸟V3:goods_weight,订单总重量(kg)
             */
            orderVo.setWeight(new BigDecimal(orderReq.getWeight()));

            /**
             * 顺丰，蜂鸟，蜂鸟V3
             * 顺丰正式单,	物品详情；数组结构
             * 蜂鸟，蜂鸟V3:货物明细
             */
            //  private List<ProductVo> productList;
            orderVo.setProductList(fnGoods);

            /**
             * 蜂鸟V3，
             * 商户ID
             */
            orderVo.setMerchantId(delivery.getShopId());//"3742995"); //"3640883");

            /**
             * 闪送，蜂鸟V3
             * 商户Token
             */
            orderVo.setAccessToken(delivery.getAuthToken());


            /**
             * 订单商品数量
             * 蜂鸟V3：goods_count
             * cargo_num，不必传
             */
            orderVo.setGoodsNum(1);

        } else if (DeliveryTypeEnums.MEI_TUAN.getType().equals(delivery.getType())) {
            orderVo.setLbClient(DeliveryTypeEnums.MEI_TUAN.getName());

            /**
             * 美团
             * delivery_id，必传
             * 即配送活动标识，由外部系统生成，不同order_id应对应不同的delivery_id-对应我们平台订单编号
             */
            orderVo.setDeliveryId(Long.valueOf(orderReq.getOrderNo()));

            /**
             * 美团
             * 第三方订单ID
             * 美团：order_id，必传，订单id，即该订单在合作方系统中的id-对应我们平台子订单号
             */
            orderVo.setOrderNo(orderReq.getOrderSn());

            /**
             * 美团
             * 美团：outer_order_source_desc，必传
             * 订单来源： 101.美团（外卖&闪购） 102.饿了么 103.京东到家 201.商家web网站 202.商家小程序-微信 203.商家小程序-支付宝 204.商家APP 205.商家热线 其他，请直接填写中文字符串，最长不超过20个字符 非「其他」需传代码
             * 我们平台->1->美团；2->饿了么
             */
            if (orderReq.getOrderSource() == null) {
                orderVo.setOrderSource("204");
            } else {
                if(orderReq.getOrderSource().equals("103")){
                    orderReq.setOrderSource("102");
                }else if (orderReq.getOrderSource().equals("104")){
                    orderVo.setOrderSource("103");
                }
                orderVo.setOrderSource(orderReq.getOrderSource());
            }
            /**
             * 美团
             * 美团：outer_order_source_no，不必传，原平台订单号，如订单来源为美团，该字段必填，且为美团平台生成的订单号
             */
            orderVo.setOrderingSourceNo(orderReq.getOrderingSourceNo());

            /**
             * * 门店编号
             * 美团：shop_id，必传， 取货门店id，即合作方向美团提供的门店id
             */
            orderVo.setShopNo(delivery.getThirdShopId());

            /**
             * 美团
             * 配送服务代码，详情见合同
             * 美团:delivery_serviceCode 必传
             * 配送服务代码，详情见合同
             */
            orderVo.setDeliveryServiceCode(100005); //配送服务代码，详情见合同，等确认后要修改

            /**
             * 美团
             * 订单金额
             * 美团：goods_value，必传，货物价格，单位为元
             */
            orderVo.setOrderMoney(orderMoney);

            /**
             * 美团
             * 订单重量（单位：Kg）
             * 美团：goods_weight，必传，货物重量，单位为kg
             */
            orderVo.setWeight(new BigDecimal(orderReq.getWeight()));

            /**
             * 美团
             * 预约单，期望取货时间
             * 美团：expected_pickup_time, 不必传，期望取货时间
             */
            orderVo.setExpectedPickupTime(null);


            /**
             * 美团
             * 是否是预约单
             * 美团：order_type，不必传，订单类型，默认为0 0: 即时单(尽快送达，限当日订单) 1: 预约单
             */
            orderVo.setIsAppoint(0);


            /**
             * 美团
             * 小费（单位：元）
             *  美团：tip_amount，不必传，加小费字段，加小费，精确到元，需要为1或1的倍数，上限20，允许每个运单最多加10次
             */
            orderVo.setTips(orderReq.getTipAmount());

            /**
             * 美团
             * 订单重量（单位：Kg）
             * 美团：goods_weight，必传，货物重量，单位为kg
             */
            orderVo.setWeight(new BigDecimal(orderReq.getWeight()));

            orderVo.setPoiSeq(orderReq.getPoiSeq());

            orderVo.setMtGoods(mtGoods);
            orderVo.setIsTest(1);
            if (isTest){
                orderVo.setIsTest(0);
            }
        } else if (DeliveryTypeEnums.MEI_TUAN_ZB.getType().equals(delivery.getType())) {
            orderVo.setLbClient(DeliveryTypeEnums.MEI_TUAN_ZB.getName());

            /**
             * 美团
             * 美团：outer_order_source_no，不必传，原平台订单号，如订单来源为美团，该字段必填，且为美团平台生成的订单号
             */
            orderVo.setOrderingSourceNo(orderReq.getZbOrderingSourceNo());
            /**
             *  美团众包token
             */
            orderVo.setZbToken(orderReq.getZbToken());

            if (StringUtils.isNotBlank(orderReq.getNeedPaymoney())){
                orderVo.setOrderActualMoney(new BigDecimal(orderReq.getNeedPaymoney()));
            }
        } else if (DeliveryTypeEnums.KUAI_FU.getType().equals(delivery.getType())) {
            orderVo.setLbClient(DeliveryTypeEnums.KUAI_FU.getName());

            orderVo.setAccessToken(delivery.getAuthToken());
            orderVo.setOpenId(delivery.getThirdShopId());

            /**
             * 第三方对接平台订单ID，长度不超过16位
             */
            orderVo.setOrderNo(orderReq.getOrderSn());

            /**
             * 美团
             * 美团：source，必传
             * 订单来源： 101.美团（外卖&闪购） 102.饿了么 103.京东到家 201.商家web网站 202.商家小程序-微信 203.商家小程序-支付宝 204.商家APP 205.商家热线 其他，请直接填写中文字符串，最长不超过20个字符 非「其他」需传代码
             * 我们平台->1->美团；2->饿了么
             */
            if (StringUtils.isNotBlank(orderReq.getPoiSeq())) {
                orderVo.setSerialNumber(orderReq.getPoiSeq());
            } else {
                orderVo.setSerialNumber("");
            }
            if (StringUtils.isNotBlank(orderReq.getOrderSource())){
                if (orderReq.getOrderSource().equals("101")){
                    orderVo.setOrderSource("美团");
                }else if (orderReq.getOrderSource().equals("102")){
                    orderVo.setOrderSource("饿了么");
                }else if (orderReq.getOrderSource().equals("103")){
                    orderVo.setOrderSource("饿百");
                }else if (orderReq.getOrderSource().equals("104")){
                    orderVo.setOrderSource("京东到家");
                }
            }
            if (orderReq.getTotalMoney() != null) {
                orderVo.setOrderMoney(new BigDecimal(orderReq.getTotalMoney()));
            }
            orderVo.setWeight(new BigDecimal(orderReq.getWeight()));
            orderVo.setGoodsType(Integer.valueOf(orderReq.getProduct().getKfProductType()));
            orderVo.setIsAppoint(0);
//            if (TakeTypeEnum.APPOINTMENT.type.equals(orderReq.getTakeType())) {
//                orderVo.setIsAppoint(1);
//                orderVo.setExpectedDeliveryTime(DateUtils.parseDate(orderReq.getTakeTime()));
//                // 普通订单是取件时间，外卖是送达时间
//                orderVo.setExpectedPickupTime(DateUtils.parseDate(orderReq.getTakeTime()));
//            }

        }else if (DeliveryTypeEnums.HUO_LA_LA.getType().equals(delivery.getType())){
            orderVo.setLbClient(DeliveryTypeEnums.HUO_LA_LA.getName());
            orderVo.setCityId(orderReq.getCityId());
            orderVo.setCityInfoRevision(orderReq.getCityInfoRevision());
            Date orderTime = new Date();
//            if (TakeTypeEnum.APPOINTMENT.type.equals(orderReq.getTakeType())) {
//                orderTime = DateUtils.parseDate(orderReq.getTakeTime());
//            }else {
//                orderTime = DateUtils.addMinutes(orderTime,10);
//            }
            orderTime = DateUtils.addMinutes(orderTime,10);
            orderVo.setOrderTime(orderTime.getTime()/1000);
            orderVo.setOrderVehicleId(orderReq.getOrderVehicleId());
            orderVo.setSpecReq(orderReq.getSpecReq());
            orderVo.setAccessToken(delivery.getAuthToken());
            orderVo.setPayType(4);
            orderVo.setOrderMoney(orderReq.getAmount());
            orderVo.setRemark(orderReq.getTakeRemark());
            if (orderReq.getMemberId() != null){
                orderVo.setMerchantId(orderReq.getMemberId().toString());
            }
            orderVo.setTotalPriceFen(orderReq.getTotalPriceFen());
         //   orderVo.setCallback(deliveryConfig.getHllOrderCallBackUrl());

        }else if (DeliveryTypeEnums.MEI_TUAN_SG_ZB.getType().equals(delivery.getType())) {
            orderVo.setLbClient(DeliveryTypeEnums.MEI_TUAN_SG_ZB.getName());

            /**
             * 美团
             * 美团：outer_order_source_no，不必传，原平台订单号，如订单来源为美团，该字段必填，且为美团平台生成的订单号
             */
            orderVo.setOrderingSourceNo(orderReq.getZbOrderingSourceNo());
            /**
             *  美团众包token
             */
            orderVo.setZbToken(orderReq.getZbToken());

            if (StringUtils.isNotBlank(orderReq.getNeedPaymoney())){
                orderVo.setOrderActualMoney(new BigDecimal(orderReq.getNeedPaymoney()));
            }
        }else if (DeliveryTypeEnums.FENG_NIAO_PT.getType().equals(delivery.getType())) {
            /**
             * 表示调用蜂鸟的api
             */
            orderVo.setLbClient(DeliveryTypeEnums.FENG_NIAO_PT.getName());

            /**
             * 门店编号
             * shop_no 必传
             * 蜂鸟V3：chain_store_code
             */
            orderVo.setShopNo(delivery.getThirdShopId()); //"203361315");

            /**
             * 取货点地址
             * 蜂鸟V3：transport_address，取货点地址
             */
            orderVo.setShopAddress(sendAddress.getAddress());

            /**
             *
             * 第三方订单ID
             * 蜂鸟V3：partner_order_code
             */
            orderVo.setOrderNo(orderReq.getOrderSn());

            /**
             *
             * 	订单金额,必传
             * 蜂鸟V3:goods_total_amount_cent
             * 这个订单的货物的金额，单位元
             */
            orderVo.setOrderMoney(orderMoney);

            /**
             * 客户需要支付的金额,必传
             * 蜂鸟v3: goods_actual_amount_cent
             */
            orderVo.setOrderActualMoney(orderMoney);

            /**
             * * 蜂鸟V3：order_type，订单类型（1:即时单，3:预约单）
             */
            orderVo.setIsAppoint(0);
            /**
             * 预约单，期望取货时间
             *   蜂鸟V3: expect_fetch_time，非必须
             */
            orderVo.setExpectedPickupTime(null);

            /**
             * 预约单，期望送达时间,非必须
             * 蜂鸟V3：require_receive_time，需要送达时间（毫秒）
             */
            orderVo.setExpectedDeliveryTime(null);

//            if (TakeTypeEnum.APPOINTMENT.type.equals(orderReq.getTakeType())) {
//                /**
//                 * * 蜂鸟V3：order_type，订单类型（1:即时单，3:预约单）
//                 */
//                orderVo.setIsAppoint(3);
//                /**
//                 * 预约单，期望取货时间
//                 *   蜂鸟V3: expect_fetch_time，非必须
//                 */
//                orderVo.setExpectedPickupTime(DateUtils.parseDate(orderReq.getTakeTime()));
//                /**
//                 * 预约单，期望送达时间,非必须
//                 * 蜂鸟V3：require_receive_time，需要送达时间（毫秒）
//                 */
//                orderVo.setExpectedDeliveryTime(null);
//            }

            /**
             * 商家订单流水号
             */
            orderVo.setPoiSeq(orderReq.getPoiSeq());
            /**
             * 蜂鸟V3：
             * 商户订单来源（如 饿了么、美团等）
             * 手发单/未知来源: 0 或不传 美团: 2 口碑: 4 饿了么: 6 支付宝: 7 饿百: 8
             */
            if (StringUtils.isNotBlank(orderReq.getOrderSource())){
                if (orderReq.getOrderSource().equals("101")){
                    orderVo.setOrderSource("2");
                    orderVo.setPoiSeq("M"+orderReq.getPoiSeq());
                }else if (orderReq.getOrderSource().equals("102")){
                    orderVo.setOrderSource("6");
                }else if (orderReq.getOrderSource().equals("103")){
                    orderVo.setOrderSource("8");
                }else if (orderReq.getOrderSource().equals("104")){
                    orderVo.setOrderSource("0");
                }
            } else {
                orderVo.setOrderSource("0");
            }

            /**
             * 小费
             * 蜂鸟V3:order_tip_amount_cent
             * 小费（单位：元，精确小数点后一位）
             */
//            orderVo.setTips(orderReq.getTipAmount());

            /**
             * //
             * 订单重量
             * 蜂鸟V3:goods_weight,订单总重量(kg)
             */
            orderVo.setWeight(new BigDecimal(orderReq.getWeight()));

            /**
             * 顺丰，蜂鸟，蜂鸟V3
             * 顺丰正式单,	物品详情；数组结构
             * 蜂鸟，蜂鸟V3:货物明细
             */
            //  private List<ProductVo> productList;
            orderVo.setProductList(fnGoods);

            /**
             * 蜂鸟V3，
             * 商户ID
             */
            orderVo.setMerchantId(delivery.getShopId());//"3742995"); //"3640883");

            /**
             * 闪送，蜂鸟V3
             * 商户Token
             */
            orderVo.setAccessToken(delivery.getAuthToken());


            /**
             * 订单商品数量
             * 蜂鸟V3：goods_count
             * cargo_num，不必传
             */
            orderVo.setGoodsNum(1);

        } else if (DeliveryTypeEnums.MA_KE_PT.getType().equals(delivery.getType())) {
            orderVo.setLbClient(DeliveryTypeEnums.MA_KE_PT.getName());
            /**
             * 门店id
             * 对应的猎豹平台门店编号
             */
            orderVo.setShopNo(orderReq.getLbShopCode());
            orderVo.setMaKePtProducts(maKePtProductVos);

            /**
             * 码科跑腿
             * 商户订单来源（1：美团 ，2：饿了么， 3：饿百零售， 4：手工单，5：有赞，6：京东，7：抖音）
             */
            if (StringUtils.isNotBlank(orderReq.getOrderSource())){
                // 美团/美团闪购
                if (orderReq.getOrderSource().equals("101")){
                    orderVo.setOrderSource("1");
                }else if (orderReq.getOrderSource().equals("102")){
                    // 饿了么
                    orderVo.setOrderSource("2");
                }else if (orderReq.getOrderSource().equals("103")){
                    // 饿百零售
                    orderVo.setOrderSource("3");
                }else if (orderReq.getOrderSource().equals("104")){
                    // 京东到家
                    orderVo.setOrderSource("6");
                }
                orderVo.setPoiSeq(orderReq.getPoiSeq());
            } else {
                // 手工单
                orderVo.setOrderSource("4");
                orderVo.setPoiSeq(orderReq.getDaySeq());
            }
            orderVo.setOrderNo(orderReq.getOrderSn());
        }
        return orderVo;
    }

    /**
     * 将有特殊符号的地址，将特殊符号去掉
     * @param address
     * @return
     */
    public static String checkAddress(String address){
        String replace = "";
        String regEx = "[ `~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）+|{}【】‘；：”“’。，、？]|\n|\r|\t";
        address = address.replaceAll(regEx,replace);
        return address;
    }
}