iamberry-common-parent/watero-rst-web/src/main/java/com/iamberry/rst/controllers/mq/JingdongTask.java

package com.iamberry.rst.controllers.mq;

import com.alibaba.fastjson.JSONObject;
//import com.iamberry.redis.RedisUtils;
import com.iamberry.rst.controllers.order.AdminJingdongAuthController;
import com.iamberry.rst.core.address.City;
import com.iamberry.rst.core.address.District;
import com.iamberry.rst.core.address.Province;
import com.iamberry.rst.core.cm.SalesOrder;
import com.iamberry.rst.core.cm.SalesOrderItem;
import com.iamberry.rst.core.order.OrderSyncLog;
import com.iamberry.rst.core.order.ProductColor;
import com.iamberry.rst.core.order.ProductCombinatInfo;
import com.iamberry.rst.core.sys.SysConfig;
import com.iamberry.rst.faces.address.AddressService;
import com.iamberry.rst.faces.cm.SalesOrderService;
import com.iamberry.rst.faces.sys.SysConfigService;
import com.iamberry.rst.service.order.mapper.OrderSyncLogMapper;
import com.iamberry.rst.service.product.mapper.ProductColorMapper;
import com.iamberry.rst.service.product.mapper.ProductMapper;
import com.iamberry.rst.util.GenerateKeyUtil;
import com.iamberry.rst.util.JingdongConfig;
import com.iamberry.wechat.tools.DateTimeUtil;
import com.jd.open.api.sdk.DefaultJdClient;
import com.jd.open.api.sdk.JdClient;
import com.jd.open.api.sdk.JdException;
import com.jd.open.api.sdk.domain.order.IOrderService.response.getmobilelist.OrderPrivacyModel;
import com.jd.open.api.sdk.domain.order.IOrderService.response.getmobilelist.ResponseData;
import com.jd.open.api.sdk.domain.order.OrderQueryJsfService.response.enGet.OrderResult;
import com.jd.open.api.sdk.domain.order.OrderQueryJsfService.response.enSearch.ItemInfo;
import com.jd.open.api.sdk.domain.order.OrderQueryJsfService.response.enSearch.OrderListResult;
import com.jd.open.api.sdk.domain.order.OrderQueryJsfService.response.enSearch.OrderSearchInfo;
import com.jd.open.api.sdk.domain.order.OrderQueryJsfService.response.enSearch.UserInfo;
import com.jd.open.api.sdk.domain.order.OrderShipmentService.response.shipment.OperatorResult;
import com.jd.open.api.sdk.request.order.PopOrderEnGetRequest;
import com.jd.open.api.sdk.request.order.PopOrderEnSearchRequest;
import com.jd.open.api.sdk.request.order.PopOrderGetmobilelistRequest;
import com.jd.open.api.sdk.request.order.PopOrderShipmentRequest;
import com.jd.open.api.sdk.response.order.PopOrderEnGetResponse;
import com.jd.open.api.sdk.response.order.PopOrderEnSearchResponse;
import com.jd.open.api.sdk.response.order.PopOrderGetmobilelistResponse;
import com.jd.open.api.sdk.response.order.PopOrderShipmentResponse;
import com.taobao.api.internal.util.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.*;

import static com.iamberry.rst.controllers.mq.TaobaoConfig.DB_JD_PULL_ORDER_LIMIT_TIME;
import static com.iamberry.rst.controllers.mq.TaobaoConfig.DB_JD_TOKEN_ID;

/**
 * https://jos.jd.com/apilistnewdetail?apiGroupId=55&apiId=14263&apiName=null
 * @author root
 */
@Component
@Lazy(false)
public class JingdongTask {

    private static Logger logger = LoggerFactory.getLogger(JingdongTask.class);

    /** 是否允许淘宝抓取订单,true表示允许，false表示不允许 */
    private static boolean isDebug = false;

    @Autowired
    private GenerateKeyUtil generateKeyUtil ;
    @Autowired
    private AddressService addressService;
    @Autowired
    private ProductColorMapper productColorMapper;
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private SalesOrderService salesOrderService;
    @Autowired
    private OrderSyncLogMapper orderSyncLogMapper;

    @Autowired
    private SysConfigService sysConfigService;

    static {
        String debug = System.getProperty("isJingdong");
        System.out.println("读取到的配置数据：" + debug);
        if ("true".equalsIgnoreCase(debug)) {
            isDebug = true;
        }
    }

    //每30分钟执行一次
//    @PostConstruct
    @Scheduled(fixedDelay = 1000 * 60 * 10, initialDelay = 3000)
    public void syncOrder() {
        if (!isDebug) {
            logger.info("【京东订单】debug模式，无法运行正式任务");
            return;
        }
        logger.info("【京东订单】开始抓取数据......");
        // 组装请求数据
        SysConfig sysConfigTime = sysConfigService.getSysConfigAll(DB_JD_PULL_ORDER_LIMIT_TIME);
        String startTime = sysConfigTime.getConfigParameter();
        if (StringUtils.isEmpty(startTime)) {
            startTime = DateTimeUtil.format(DateTimeUtil.addDay(-20), "yyyy-MM-dd HH:mm:ss");
            sysConfigTime.setConfigParameter(startTime);
            sysConfigService.updateSysConfig(sysConfigTime);
        }
        // 结束时间
        String endTime = DateTimeUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss");
        logger.info("开始时间：{}， 结束时间：{}", startTime, endTime);

        // 批次号
        String batchIdST = generateKeyUtil.getSalesBatchIdJD();
        // 循环抓取
        boolean hasNext = true;
        int pageNo = 1;
        try {
            int total = 0;
            // 开始循环
            while (hasNext) {
                logger.info("【京东订单】抓取第{}页的数据......", pageNo);
                // 抓取京东数据
                JdClient client = null;
                PopOrderEnSearchRequest orderSearchRequest = null;
                PopOrderEnSearchResponse rsp = null;
                try {
                    SysConfig sysConfig = sysConfigService.getSysConfigAll(DB_JD_TOKEN_ID);
                    client = new DefaultJdClient(TaobaoConfig.JINGDONG_API_URL, sysConfig.getConfigParameter(), TaobaoConfig.jd_appkey, TaobaoConfig.jd_secret);
                    orderSearchRequest = new PopOrderEnSearchRequest();
                    orderSearchRequest.setStartDate(startTime);
                    orderSearchRequest.setEndDate(endTime);
                    orderSearchRequest.setOrderState("WAIT_SELLER_STOCK_OUT,WAIT_SELLER_DELIVERY,WAIT_GOODS_RECEIVE_CONFIRM");//待出库和境外待发货, 一般仅存在前者
                    orderSearchRequest.setOptionalFields(initOrderOptionalFields());
                    orderSearchRequest.setPage("" + pageNo);
                    orderSearchRequest.setPageSize("" + 40L);
                    orderSearchRequest.setDateType(0);//按照最后修改时间查询
                    rsp = client.execute(orderSearchRequest);
                } catch (Exception e) {
                    logger.error("请求京东服务器异常：{}", e);
                }
                if (rsp == null) {
                    logger.error("【京东订单】请求京东服务器失败!");
                    return;
                }
                // 判断数据
                String code = rsp.getCode();
                if (!"0".equals(rsp.getCode())) {
                    logger.info("【京东订单】请求京东服务器，返回错误码：{}, 错误信息：{}", code, rsp.getMsg());
                    break;
                }
                logger.info("【京东订单】请求京东服务器，返回信息：{}", rsp.getMsg());

                OrderListResult orderResult = rsp.getSearchorderinfoResult();
                if (orderResult == null) {
                    break;
                }
                List<OrderSearchInfo> orderInfoList = orderResult.getOrderInfoList();
                if (orderInfoList == null || orderInfoList.size() == 0) {
                    logger.info("【京东订单】数据请求完毕, 数量为0");
                    break;
                }
                for (OrderSearchInfo orderSearchInfo : orderInfoList) {
                    //获取的详情数据和列表数据没什么区别， 直接使用列表数据即可
//                    Trade details = getOrderDetails(orderSearchInfo.getOrderId());
//                    if (details == null) {
//                        logger.error("【京东订单】{}获取订单详细数据失败", trade.getTid());
//                        return;
//                    }
                    // 组装数据
                    SalesOrder salesOrder = packageOrder(orderSearchInfo);
                    if (salesOrder != null) {
                        salesOrder.setSalesBatchId(batchIdST);
                        salesOrderService.addOrder(salesOrder, "创建订单(京东拉取订单)");
                        total ++;
                    }
                }
                // 迭代数据
                if (rsp.getSearchorderinfoResult().getOrderTotal() <= pageNo * 40) {
                    hasNext = false;
                } else {
                    hasNext = true;
                    pageNo ++;
                }
            }

            OrderSyncLog orderSyncLog = new OrderSyncLog();
            orderSyncLog.setSyncPlatId(1);
            orderSyncLog.setSyncLogType(1);
            orderSyncLog.setSyncLogMode(1);
            orderSyncLog.setSyncLogRecentNum(total); //同步总数量
            orderSyncLog.setSyncLogErrorNum(0); //同步失败数量
            orderSyncLog.setSyncLogMsg("拉取京东订单");   //备注
            orderSyncLogMapper.save(orderSyncLog);

            sysConfigTime.setConfigParameter(endTime);
            sysConfigService.updateSysConfig(sysConfigTime);

//            RedisUtils.put("JINGDONG_SYNC_TIME", endTime);
        } catch (Exception e) {
            logger.error("", e);
            OrderSyncLog orderSyncLog = new OrderSyncLog();
            orderSyncLog.setSyncPlatId(1);
            orderSyncLog.setSyncLogType(1);
            orderSyncLog.setSyncLogMode(1);
            orderSyncLog.setSyncLogRecentNum(1); //同步总数量
            orderSyncLog.setSyncLogErrorNum(1); //同步失败数量
            orderSyncLog.setSyncLogMsg("拉取京东订单");   //备注
            orderSyncLog.setSyncLogErrorMsg(e.getMessage());
            orderSyncLogMapper.save(orderSyncLog);
        }
    }


    public com.jd.open.api.sdk.domain.order.OrderQueryJsfService.response.enGet.OrderSearchInfo getOrderDetails(Long tid) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            SysConfig sysConfig = sysConfigService.getSysConfigAll(DB_JD_TOKEN_ID);
            JdClient client = new DefaultJdClient(TaobaoConfig.JINGDONG_API_URL, sysConfig.getConfigParameter(), TaobaoConfig.jd_appkey, TaobaoConfig.jd_secret);
            PopOrderEnGetRequest request = new PopOrderEnGetRequest();
            request.setOrderId(tid);
            request.setOptionalFields(initOrderOptionalFields());
            PopOrderEnGetResponse rsp = client.execute(request);
            String code = rsp.getCode();
            logger.info("查询京东订单详情返回信息：code:{}, msg:{}", rsp.getCode(), rsp.getMsg());
            if ("0".equals(code)) {
                OrderResult orderDetailInfo = rsp.getOrderDetailInfo();
                com.jd.open.api.sdk.domain.order.OrderQueryJsfService.response.enGet.OrderSearchInfo orderInfo = orderDetailInfo.getOrderInfo();
                return orderInfo;
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    public String initOrderOptionalFields() {
        return "orderId,venderId,orderType,payType,orderTotalPrice,orderSellerPrice,orderPayment,freightPrice,sellerDiscount,orderState,orderStateRemark,deliveryType," +
                "invoiceEasyInfo," +
                "invoiceCode,invoiceInfo,invoiceCode,orderRemark,orderStartTime,orderEndTime," +
                "consigneeInfo," +
                "itemInfoList," +
                "couponDetailList," +
                "venderRemark,balanceUsed,pin,returnOrder,paymentConfirmTime,waybill,logisticsId," +
                "vatInfo," +
                "modified,directParentOrderId,parentOrderId,customs,customsModel,orderSource,storeOrder,idSopShipmenttype,scDT,serviceFee," +
                "pauseBizInfo," +
                "taxFee,tuiHuoWuYou,orderSign,storeId,realPin,orderMarkDesc,open_id,xid,open_id_buyer,xid_buyer";
    }


    /**
     * 京东发货
     * @param orderId
     * @param logiCoprId
     * @param logiNo
     */
    public OperatorResult orderShipment(String orderId, String logiCoprId, String logiNo){

        SysConfig sysConfig = sysConfigService.getSysConfigAll(DB_JD_TOKEN_ID);
        JdClient client = new DefaultJdClient(JingdongConfig.JINGDONG_API_URL, sysConfig.getConfigParameter(), JingdongConfig.jd_appkey, JingdongConfig.jd_secret);
        PopOrderShipmentRequest req = new PopOrderShipmentRequest();
        req.setOrderId(Long.parseLong(orderId));
        req.setLogiCoprId(logiCoprId);
        req.setLogiNo(logiNo);
        try {
            PopOrderShipmentResponse rsp = client.execute(req);
            logger.info("京东订单发货回录：订单:{}, code:{}, msg:{}", orderId, rsp.getCode(), rsp.getMsg());
            if ("0".equals(rsp.getCode())) {
                OperatorResult sopjosshipmentResult = rsp.getSopjosshipmentResult();
                return sopjosshipmentResult;
            }
        } catch (Exception e) {
            e.printStackTrace();
            //京东发货异常
            logger.error("京东发货接口异常：{}", e);
        }
        return null;
    }


    public OrderPrivacyModel getMobile(String orderId) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            SysConfig sysConfig = sysConfigService.getSysConfigAll(DB_JD_TOKEN_ID);
            PopOrderGetmobilelistResponse rsp = null;
            JdClient client = new DefaultJdClient(TaobaoConfig.JINGDONG_API_URL, sysConfig.getConfigParameter(), TaobaoConfig.jd_appkey, TaobaoConfig.jd_secret);
            PopOrderGetmobilelistRequest request = new PopOrderGetmobilelistRequest();
            request.setAppName("爱贝源官方旗航店");
//            request.setRegion("https://jd.com");
            request.setOrderId(orderId);
            request.setExpiration(30);
            request.setOrderType("POP");
            rsp = client.execute(request);
            if ("0".equals(rsp.getCode())) {
                ResponseData result = rsp.getResult();
                logger.info("result code:{}, message:{}", result.getCode(), result.getMessage());
                if ("200".equals(result.getCode() + "")) {
                    logger.info("查询京东订单收货人电话：data.code: {}, data.message:{}", result.getCode(), result.getMessage());
                    Map<String, OrderPrivacyModel> data = result.getData();
                    OrderPrivacyModel orderPrivacyModel = data.get(orderId);
                    return orderPrivacyModel;
                }
            }
            logger.info("查询京东订单收货人手机号返回错误信息：{}", rsp.getMsg());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 数据还需要完善地址库编码、成本价格
     * @param trade
     * @return
     */
    private SalesOrder packageOrder(OrderSearchInfo trade) {
        logger.info("packageOrder orderState:" + trade.getOrderState());
        // 处理京东仓自发货场景
        boolean waitGoodsReceiveConfirm = "WAIT_GOODS_RECEIVE_CONFIRM".equals(trade.getOrderState()) || "等待确认收货".equals(trade.getOrderStateRemark());

        String tid = trade.getOrderId();

        SalesOrder order = new SalesOrder();
        order.setSalesOrderId(tid);
        order.setSalesDealCode(tid);
        order.setSalesExOrderId(tid);
        order.setSalesDiscountMoney(changeY2F(StringUtils.isEmpty(trade.getSellerDiscount()) ? "0" : trade.getSellerDiscount()));
        order.setSalesDeliver(waitGoodsReceiveConfirm ? 2 : 1);

        //获取收货人手机号
        OrderPrivacyModel orderPrivacyModel = getMobile(trade.getOrderId());

        //收货人信息
        UserInfo consigneeInfo = trade.getConsigneeInfo();
        order.setSalesOpenId(orderPrivacyModel == null ? consigneeInfo.getMobile() : orderPrivacyModel.getConsMobilePhone());
        order.setSalesPledgeMoney(0);
        order.setSalesRemainDeposit(0);
        order.setSalesOrderStatus(1);
        order.setSalesStatus(waitGoodsReceiveConfirm ? 4 : 0);
        order.setSalesShippingStatus(waitGoodsReceiveConfirm ? 1 :  0);
        order.setSalesPayStatus(2);
        order.setSalesProcessStatus(1);
        order.setSalesIsSend(waitGoodsReceiveConfirm ? 1 : 0);
        order.setSalesIsLocked(0);
        order.setSalesIsSeparate(0);
        order.setSalesIsShip(1);
        order.setSalesProcessRefund(0);
        order.setSalesSendType(waitGoodsReceiveConfirm ? 3 : 2);
        order.setSalesSalesTime(DateTimeUtil.parse(trade.getOrderStartTime()));
        // 地址
        StringJoiner address = new StringJoiner(" ");
        String addrDetail = consigneeInfo.getFullAddress().replaceFirst(consigneeInfo.getProvince(), "").replaceFirst(consigneeInfo.getCity(), "").replaceFirst(consigneeInfo.getCounty(), "");
        if (!StringUtils.isEmpty(consigneeInfo.getProvince())) {
            address.add(consigneeInfo.getProvince());
        }
        if (!StringUtils.isEmpty(consigneeInfo.getCity())) {
            address.add(consigneeInfo.getCity());
        }
        if (!StringUtils.isEmpty(consigneeInfo.getCounty())) {
            address.add(consigneeInfo.getCounty());
        }
        if (!StringUtils.isEmpty(addrDetail)) {
            address.add(addrDetail);
        }
        order.setSalesAddressInfo(address.toString());

        //京东不返回邮编
        order.setSalesAddressPostcode("000000");
        order.setSalesAddressName(consigneeInfo.getFullname());
        order.setSalesAddressTel(orderPrivacyModel == null ? consigneeInfo.getMobile() : orderPrivacyModel.getConsMobilePhone());
        order.setSalesAmount(changeY2F(trade.getOrderTotalPrice()));
        order.setSalesPayMoney(changeY2F(trade.getOrderPayment()));
        order.setSalesPayType(getSalesPayType(trade.getPayType()));
        //京东没有返回流水号，默认用订单号
        order.setSalesPaymentNo(tid);
        order.setSalesWaitMoney(0);
        order.setSalesShippingFee(changeY2F(trade.getFreightPrice()));
        order.setSalesLastMoney(0);
        order.setSalesPayTime(StringUtils.isEmpty(trade.getPaymentConfirmTime()) ? null : DateTimeUtil.parse(trade.getPaymentConfirmTime()));
        order.setSalesCreateTime(DateTimeUtil.parse(trade.getOrderStartTime()));
        order.setSalesAdminRemark(trade.getVenderRemark());
        order.setSalesUserRemark(trade.getOrderRemark());
        order.setSalesCompanyId(1);
        order.setSalesStoreId(40);
        order.setSalesType(1);
        order.setSalesAddType(4);
        order.setSalesAdminId(10135);
        order.setSalesReturnStatus(1);
        order.setSalesIsSublist(1);
        order.setSalesExOrderId(trade.getOrderId());
        order.setSalesErrorState(1);
        order.setSalesQuality(1);
        order.setSalesPostFirm("jd");
        // 保存物流单号
        if (waitGoodsReceiveConfirm) {
            order.setSalesPostNum(trade.getWaybill());
        }
        order.setSalesOrderItemList(new ArrayList<>(trade.getItemInfoList().size()));
        // 订单项
        int warranty = 0;
        for (ItemInfo tradeOrder : trade.getItemInfoList()) {
            SalesOrderItem item = new SalesOrderItem();
            //京东返回，无退款状态
            item.setItemWarrantyStatus(0);
//            if (!"NO_REFUND".equalsIgnoreCase(tradeOrder.getRefundStatus())) {
//                warranty = 1;
//                item.setItemWarrantyStatus(1);
//            }
            if (StringUtils.isEmpty(tradeOrder.getOuterSkuId())) {
                return null;
            }
            ProductColor productColor = productColorMapper.getProductColorByBar(tradeOrder.getOuterSkuId());
            if(productColor.getProductIsSplit() == 1){
                List<ProductCombinatInfo> productCombinatList = productMapper.combinatList(productColor.getColorProductId());
                if(productCombinatList == null || productCombinatList.size() < 1){
                    logger.error("商城订单编号："+productColor.getColorProductId()+"-订单项中的SKU未查询到组合产品，SKU编号："+productColor.getColorProductId()+"; ");
                    break;
                }
                int totalFeeInt = changeY2F(tradeOrder.getJdPrice());
                Integer advProductCombinatFree = totalFeeInt/productCombinatList.size();
                for (int m = 0;m<productCombinatList.size();m++) {
                    ProductCombinatInfo productCombinatInfo = productCombinatList.get(m);
                    ProductColor sonPc = productColorMapper.getProductColorByBar(productCombinatInfo.getColorBar());
                    SalesOrderItem salesOrderItem = new SalesOrderItem();
                    item.setItemWarrantyStatus(0);
//                    if (!tradeOrder.getRefundStatus().equalsIgnoreCase("NO_REFUND")) {
//                        warranty = 1;
//                        salesOrderItem.setItemWarrantyStatus(1);
//                    }
                    salesOrderItem.setItemOtherId(trade.getOrderId());
                    Integer sonNum = Integer.parseInt(tradeOrder.getItemTotal())*productCombinatInfo.getCombinatItemNum();
                    //计算价格
                    Integer itemDiscountAllFeeInt = 0;
                    if((m+1) >= productCombinatList.size()){
                        itemDiscountAllFeeInt = totalFeeInt;
                    }else{
                        itemDiscountAllFeeInt = advProductCombinatFree;
                        totalFeeInt = totalFeeInt - itemDiscountAllFeeInt;
                    }
                    Integer itemDiscountFeeInt = itemDiscountAllFeeInt/sonNum;
                    //产品市场价
                    salesOrderItem.setItemProductPrice(itemDiscountFeeInt);
                    //产品折扣价
                    salesOrderItem.setItemProductDiscount(itemDiscountFeeInt);
                    //小结
                    salesOrderItem.setItemTotal(itemDiscountAllFeeInt);
                    //产品数量
                    salesOrderItem.setItemNum(sonNum);
                    //colorBar
                    salesOrderItem.setItemColorBar(sonPc.getColorBar());
                    //产品id
                    salesOrderItem.setItemProductId(sonPc.getColorProductId());
                    salesOrderItem.setItemColorId(sonPc.getColorId());
                    salesOrderItem.setItemProductType(sonPc.getProductType());
                    salesOrderItem.setItemProductName(sonPc.getProductName());
                    //产品颜色
                    salesOrderItem.setItemProductColor(sonPc.getColorName());
                    //商品简称
                    salesOrderItem.setProductAbbreviation(sonPc.getProductAbbreviation());
                    //所属产品简称
                    salesOrderItem.setColorAbbreviation(sonPc.getColorAbbreviation());
                    //重量
                    salesOrderItem.setColorIsWeight(sonPc.getColorIsWeight());
                    //是否是水机 1:水机 2;其它产品
                    salesOrderItem.setColorIsMachine(sonPc.getColorIsMachine());
                    //产品来源 1：产品颜色表，2：配件表
                    salesOrderItem.setItemIsSource(1);
                    order.getSalesOrderItemList().add(salesOrderItem);
                }
            }else{
                item.setItemOtherId(trade.getOrderId());
                item.setItemNum(Integer.parseInt(tradeOrder.getItemTotal()));
                item.setItemColorBar(tradeOrder.getOuterSkuId());
                item.setItemProductPrice(changeY2F(tradeOrder.getJdPrice())/item.getItemNum());
                item.setItemProductDiscount(changeY2F(tradeOrder.getJdPrice())/item.getItemNum());
                item.setItemIsSource(1);
                item.setItemReturnNum(0);
                //小结
                item.setItemTotal(changeY2F(tradeOrder.getJdPrice()));
                item.setItemProductId(productColor.getColorProductId());
                item.setItemColorId(productColor.getColorId());
                item.setItemProductType(productColor.getProductType());
                item.setItemProductName(productColor.getProductName());
                //产品颜色
                item.setItemProductColor(productColor.getColorName());
                //商品简称
                item.setProductAbbreviation(productColor.getProductAbbreviation());
                //所属产品简称
                item.setColorAbbreviation(productColor.getColorAbbreviation());
                //重量
                item.setColorIsWeight(productColor.getColorIsWeight());
                //是否是水机 1:水机 2;其它产品
                item.setColorIsMachine(productColor.getColorIsMachine());
                //产品来源 1：产品颜色表，2：配件表
                item.setItemIsSource(1);
                // 填充数据
                order.getSalesOrderItemList().add(item);
            }
        }
        order.setSalesWarrantyStatus(warranty);
        logger.info("拉取订单组长的数据：{}", order.toString());
        return order;
    }

    /**
     * 映射到数据库中
     *
     * @param payType 京东出参: 1货到付款, 2邮局汇款, 3自提, 4在线支付, 5公司转账, 6银行卡转账
     * @return {@link SalesOrder} salesPayType 付款方式
     */
    private Integer getSalesPayType(String payType) {
        Map<String, Integer> mapper = new HashMap<>(6);
        mapper.put("1-货到付款", 10);
        mapper.put("2-邮局汇款", 30);
        mapper.put("3-自提", 31);
        mapper.put("4-在线支付", 32);
        mapper.put("5-公司转账", 33);
        mapper.put("6-银行卡转账", 12);

        Integer value = mapper.get(payType);

        // 如果没有匹配上的，默认支付宝
        if (value == null) {
            return 5;
        }

        return value;
    }

    private static int changeY2F(String price) {
        double p = Double.parseDouble(price);
        return (int)(p * 100);
    }

}