caimei365-manager/src/main/java/com/caimei/modules/order/service/NewOrderService.java

package com.caimei.modules.order.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.caimei.constants.UserType;
import com.caimei.exception.BusinessException;
import com.caimei.modules.bulkpurchase.dao.OrderInvoiceDao;
import com.caimei.modules.bulkpurchase.entity.OrderInvoice;
import com.caimei.modules.bulkpurchase.service.OrderInvoiceService;
import com.caimei.modules.coupon.dao.CmCouponClubDao;
import com.caimei.modules.coupon.dao.CmCouponDao;
import com.caimei.modules.coupon.entity.CmCoupon;
import com.caimei.modules.coupon.entity.CmCouponClub;
import com.caimei.modules.coupon.entity.CmCouponOrderRecord;
import com.caimei.modules.coupon.service.CmCouponService;
import com.caimei.modules.miniprogram.utils.UploadPicUtils;
import com.caimei.modules.order.dao.*;
import com.caimei.modules.order.entity.*;
import com.caimei.modules.order.utils.HttpClientUtils;
import com.caimei.modules.order.utils.NewOrderStatus;
import com.caimei.modules.order.utils.OrderUtil;
import com.caimei.modules.order.utils.RandomCode;
import com.caimei.modules.product.dao.CmPromotionDao;
import com.caimei.modules.product.dao.CmSecondHandDetailDao;
import com.caimei.modules.product.dao.ProductDao;
import com.caimei.modules.product.entity.CmPromotion;
import com.caimei.modules.product.entity.OrderProductLadderPrice;
import com.caimei.modules.product.entity.Product;
import com.caimei.modules.user.dao.CmUserDao;
import com.caimei.modules.user.dao.NewCmClubDao;
import com.caimei.modules.user.dao.NewCmShopDao;
import com.caimei.modules.user.entity.*;
import com.caimei.modules.user.service.CmUserBalanceRecordService;
import com.caimei.modules.user.service.CmUserService;
import com.caimei.modules.user.utils.ReturnedPurchaseStatus;
import com.caimei.modules.user.utils.UserUtils;
import com.caimei.po.ProductLadderPrice;
import com.caimei.po.neworder.CmShopOrder;
import com.caimei.utils.*;
import com.thinkgem.jeesite.common.config.Global;
import com.thinkgem.jeesite.common.persistence.Page;
import com.thinkgem.jeesite.common.service.CrudService;
import com.thinkgem.jeesite.common.utils.DateUtils;
import com.thinkgem.jeesite.common.utils.StringUtils;
import com.thinkgem.jeesite.modules.sys.utils.DictUtils;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.xml.bind.DatatypeConverter;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

@Service
@Transactional(readOnly = true)
public class NewOrderService extends CrudService<NewOrderDao, NewOrder> {

    @Resource
    private NewOrderDao newOrderDao;
    @Resource
    private NewOrderProductDao newOrderProductDao;
    @Resource
    private OrderInvoiceService orderInvoiceService;
    @Resource
    private OrderUserInfoService orderUserInfoService;
    @Resource
    private NewShopOrderDao newShopOrderDao;
    @Resource
    private NewCmClubDao newCmClubDao;
    @Resource
    private LogisticsBatchDao logisticsBatchDao;
    @Resource
    private LogisticsRecordDao logisticsRecordDao;
    @Resource
    private LogisticsInformationDao logisticsInformationDao;
    @Resource
    private OrderInvoiceDao orderInvoiceDao;
    @Resource
    private NewOrderConfigDao newOrderConfigDao;
    @Resource
    private ProductDao productDao;
    @Resource
    private NewCmShopDao newCmShopDao;
    @Resource
    private CmUserDao cmUserDao;
    @Resource
    private CmUserService cmUserService;
    @Resource
    private CmReturnedPurchaseProductDao cmReturnedPurchaseProductDao;
    @Resource
    private CmDiscernReceiptDao cmDiscernReceiptDao;
    @Resource
    private CmUserBalanceRecordService cmUserBalanceRecordService;
    @Resource
    private CmReturnedPurchaseDao cmReturnedPurchaseDao;
    @Resource
    private CmPayShopRecordDao cmPayShopRecordDao;
    @Resource
    private CmReceiptOrderRelationDao cmReceiptOrderRelationDao;
    @Autowired
    private CmReceiptOrderRelationService cmReceiptOrderRelationService;
    @Autowired
    private CmPromotionDao cmPromotionDao;
    @Autowired
    private CmSecondHandDetailDao cmSecondHandDetailDao;
    @Autowired
    private CmCouponDao cmCouponDao;
    @Autowired
    private CmCouponService cmCouponService;
    @Autowired
    private CmCouponClubDao cmCouponClubDao;

    @Transactional(readOnly = false)
    public void updateClauseContent(NewOrder newOrder) {
        newOrderDao.updateClauseContent(newOrder);
    }

    @Override
    @Transactional(readOnly = false)
    public void save(NewOrder newOrder) {
        synchronized (NewOrderService.class) {
            NewOrder dbOrder = newOrderDao.findByOrderID(newOrder.getOrderID());
            boolean flag = false;// 是否新增标志
            if (newOrder.getOrderID() == null) {
                flag = true;
                newOrder.setOrderNo(OrderUtil.geneAdminOrderNo());
                newOrder.setSendOutStatus("1");
            }
            if (null == newOrder.getDiscountFee()) {//设置折扣
                newOrder.setDiscountFee(0d);
            }
            if (null == newOrder.getPromotionFullReduction()) {// 设置满减金额
                newOrder.setPromotionFullReduction(0d);
            }
            if (null == newOrder.getBalancePayFee()) {//设置余额
                newOrder.setBalancePayFee(0d);
            }
            if (newOrder.getPayFlag() == null) {//设置付款标识
                newOrder.setPayFlag("0");
            }
            if ("-1".equals(newOrder.getFreePostFlag())) { // 不包邮
                newOrder.setFreePostFlag("-1"); //`freePostFlag`'免邮标志  运费：-1到付，0包邮，1需要运费',
                newOrder.setFreight(-1D);//到付运费 = 0
            }
            if ("0".equals(newOrder.getFreePostFlag())) { // 包邮
                newOrder.setFreight(0D);//包邮运费 = 0
            }
            if (newOrder.getHasActProduct() == null) {
                newOrder.setHasActProduct("0");
            }
            if (newOrder.getOnlinePayFlag() == null) {
                newOrder.setOnlinePayFlag("0");
            }
            if (!StringUtils.equals("1", newOrder.getConfirmFlag())) {
                newOrder.setConfirmFlag("0");
            }
            if (newOrder.getAffirmPaymentFlag() == null) {
                newOrder.setAffirmPaymentFlag("0");
            }
            // 协销订单设置会所信息
            if (newOrder.getBpOrderUserinfo() != null && newOrder.getBpOrderUserinfo().getClubId() != null) {
                newOrder.setClubID(newOrder.getBpOrderUserinfo().getClubId().intValue());
                NewCmClub club = newCmClubDao.get(newOrder.getBpOrderUserinfo().getClubId().toString());
                if (null != club) {
                    newOrder.setUserID(club.getUserID());
                    //新增订单时设置协销Id
                    if (flag) {
                        if (club.getSpID() != null) {
                            //上线的协销Id
                            Integer spId = newCmClubDao.findSpId(club.getSpID());
                            if (spId != null) {
                                newOrder.setSpID(spId);
                            } else {
                                //设置协销为默认协销经理
                                newOrder.setSpID(1342);
                            }
                        } else {
                            //设置协销为默认协销经理
                            newOrder.setSpID(1342);
                        }
                    }
                }
            }

            //采购中选中保存的订单商品
            List<NewOrderProduct> orderProducts = newOrder.getOrderProduct();
            double preferential = 0d;
            double discountFee = 0d;
            double productTotalFee = 0D;
            Set promotionsIds = new HashSet();
            for (NewOrderProduct o : orderProducts) {
                if (o.getPromotionsId() != null && o.getDiscount() >= 100d) {
                    promotionsIds.add(o.getPromotionsId());
                }
                Double copCostPrice = getOrderProductCostPrice(o, newOrder.getUserID());
                o.setCostPrice(copCostPrice);
                //o.setShopProductAmount(copCostPrice * (o.getNum() + o.getPresentNum()));//商品费  =  成本价快照
                // 赠送数单独列出来
                o.setShopProductAmount(copCostPrice * o.getNum());
                discountFee += (o.getDiscountFee() == null ? 0 : o.getDiscountFee()); //主订单统计经理折扣
                preferential += (o.getPreferential() == null ? 0 : o.getPreferential()); //主订单统计优惠
                o.setCommentFlag("0");//未评论
                o.setUseBalanceAmount(0D);//余额
                o.setIsGiftProduct("0");//【旧】赠品标识
                Product product = productDao.get(o.getProductID() + "");
                o.setProductUnit(product.getUnit());
                o.setProductImage(AppUtils.getProductImageURL(product.getMainImage(), 0, ""));
                Integer shopID = o.getShopID() == null ? product.getShopID() : o.getShopID();
                String name = "";

                NewCmShop shop = newCmShopDao.get(shopID + "");
                if (shop != null) {
                    name = shop.getName();
                }
                o.setShopName(name);
                productTotalFee += o.getPrice() * o.getNum();//商品总金额 = 商品 price * 购买数量
            }
            if (productTotalFee != 0D) {
                newOrder.setProductTotalFee(productTotalFee);
            }
            newOrder.setPreferential(preferential);
            double divDiscountFee = Math.abs(newOrder.getDiscountFee() - discountFee); //经理折扣出现误差
            if (newOrder.getDiscountFee() != null && Math.abs(newOrder.getDiscountFee() - discountFee) < 1) {
                double i = divDiscountFee / orderProducts.size();
                for (NewOrderProduct o : orderProducts) {
                    o.setDiscountFee(o.getDiscountFee() + i);
                    o.setOrderPromotionsId(null);
                }
            }
            newOrder.setPayStatus("1");
            newOrder.setZeroCostFlag(0);
            newOrder.setCouponAmount(newOrder.getCouponAmount() == null ? 0d : newOrder.getCouponAmount());
            if (flag) {
                // 新增
                newOrderDao.insert(newOrder);
            } else {
                // 修改
                newOrderDao.update(newOrder);
            }
            //优惠券相关
            CmCouponOrderRecord orderRecord = newOrderDao.findOrderCouponRecord(newOrder.getOrderID());
            if (orderRecord != null && newOrder.getClubCouponId() == null) {
                //修改订单时,不使用优惠券
                newOrderDao.deleteCouponOrderRecord(orderRecord.getId());
            }
            if (newOrder.getClubCouponId() != null && newOrder.getClubCouponId() > 0) {
                CmCoupon coupon = newOrderDao.findClubCouponById(newOrder.getClubCouponId());
                if (coupon != null) {
                    if (orderRecord == null) {
                        orderRecord = new CmCouponOrderRecord();
                        orderRecord.setCouponAmount(coupon.getCouponAmount());
                        orderRecord.setTouchPrice(coupon.getTouchPrice());
                        orderRecord.setClubCouponId(newOrder.getClubCouponId());
                        orderRecord.setOrderId(newOrder.getOrderID());
                        orderRecord.setCreateDate(new Date());
                        orderRecord.setCouponType(coupon.getCouponType());
                        newOrderDao.insertCouponOrderRecord(orderRecord);
                    } else {
                        orderRecord.setClubCouponId(newOrder.getClubCouponId());
                        orderRecord.setCouponAmount(coupon.getCouponAmount());
                        orderRecord.setTouchPrice(coupon.getTouchPrice());
                        orderRecord.setCouponType(coupon.getCouponType());
                        newOrderDao.updateCouponOrderRecord(orderRecord);
                    }
                }
            }
            // 促销订单
            List<CmPromotion> promotionsList = new ArrayList<>();
            if (promotionsIds.size() > 0) {
                promotionsList = newOrderDao.findPromotionsByIds(promotionsIds);
                newOrderDao.deleterPomotionsOrder(newOrder.getOrderID());
                if (promotionsList != null && promotionsList.size() > 0) {
                    for (CmPromotion promotion : promotionsList) {
                        Integer promotionId = Integer.parseInt(promotion.getId());
                        promotion.setOrderId(newOrder.getOrderID());
                        promotion.setPromotionsId(promotionId);
                        //只针对活动满减满赠
                        if ("2".equals(promotion.getMode()) || "3".equals(promotion.getMode())) {
                            //凑单金额
                            AtomicReference<BigDecimal> poolAmount = new AtomicReference<>(BigDecimal.ZERO);
                            orderProducts.forEach(o -> {
                                if (o.getDiscount() >= 100d) {
                                    CmPromotion cmPromotion = cmPromotionDao.findProductPromotion(o.getShopID().toString(), o.getProductID().longValue());
                                    if (cmPromotion != null && cmPromotion.getId().equals(promotion.getId())) {
                                        poolAmount.set(MathUtil.add(poolAmount, o.getTotalFee()));
                                        poolAmount.set(MathUtil.add(poolAmount, o.getTotalAddedValueTax()));
                                    }
                                }
                            });
                            //判断是否达到满减满赠要求
                            if (MathUtil.compare(poolAmount.get(), promotion.getTouchPrice()) > -1) {
                                // 新增
                                promotion.setId(null);
                                newOrderDao.insertPromotionsRecord(promotion);
                            }
                        } else {
                            // 新增
                            promotion.setId(null);
                            newOrderDao.insertPromotionsRecord(promotion);
                        }
                    }
                    orderProducts.forEach(o -> {
                        CmPromotion cmPromotion = cmPromotionDao.findProductPromotion(o.getShopID().toString(), o.getProductID().longValue());
                        if (null != cmPromotion) {
                            CmPromotion orderPromotions = newOrderDao.getDbPromotionsByOrderId(newOrder.getOrderID(), Integer.valueOf(cmPromotion.getId()));
                            if (null != orderPromotions) {
                                o.setOrderPromotionsId(Integer.valueOf(orderPromotions.getId()));
                            }
                        }
                    });
                }
            }

            newOrder.setPromotions(promotionsList);
            //查询是否存在余额记录
            boolean isUpdateUserMoney = false;
            CmUserBalanceRecord balanceRecord = new CmUserBalanceRecord();
            balanceRecord.setOrderId(newOrder.getOrderID());
            List<CmUserBalanceRecord> record = cmUserBalanceRecordService.getBalanceRecord(balanceRecord);
            if (record != null && record.size() > 0) {
                record.forEach(r -> {
                    r.setDelFlag("1");
                    r.setRemark("修改订单，自动更新余额抵扣，此条记录作废--后台");
                    cmUserBalanceRecordService.updateBalanceRecord(r);
                });
                // 更新用户余额
                cmUserDao.updateAbleUserMoney(newOrder.getBpOrderUserinfo());
                isUpdateUserMoney = true;
            }
            if (newOrder.getBalancePayFee() != null && newOrder.getBalancePayFee() > 0) {
                if (!isUpdateUserMoney) {
                    // 更新用户余额
                    cmUserDao.updateAbleUserMoney(newOrder.getBpOrderUserinfo());
                }
                //添加余额收支记录
                CmUserBalanceRecord cmUserBalanceRecord = new CmUserBalanceRecord();
                cmUserBalanceRecord.setUserId(newOrder.getUserID());
                cmUserBalanceRecord.setType("2");
                cmUserBalanceRecord.setBalanceType("1");
                cmUserBalanceRecord.setAddDate(new Date());
                cmUserBalanceRecord.setAmount(String.valueOf(newOrder.getBalancePayFee()));
                cmUserBalanceRecord.setOrderId(newOrder.getOrderID());
                cmUserBalanceRecord.setDelFlag("0");
                cmUserBalanceRecordService.insertUserBalanceRecord(cmUserBalanceRecord);
            }

            //订单客户
            OrderUserInfo orderUserInfo = newOrder.getBpOrderUserinfo();

            //发票信息
            OrderInvoice orderInvoice = newOrder.getOrderInvoice();
            orderUserInfo.setOrderId(Long.valueOf(newOrder.getOrderID()));
            if (null != orderInvoice) {
                //type '发票类型0不开发票 1普通发票 2增值税发票'
                orderInvoice.setOrderId(Long.valueOf(newOrder.getOrderID()));
                if ("2".equals(orderInvoice.getType())) {
                    newOrder.setInvoiceFlag("1");
                    orderInvoice.setInvoiceTitleType(null);
                } else if ("1".equals(orderInvoice.getType())) {
                    orderInvoice.setRegisteredAddress(null);
                    orderInvoice.setRegisteredPhone(null);
                    orderInvoice.setOpenBank(null);
                    orderInvoice.setBankAccountNo(null);
                    newOrder.setInvoiceFlag("1");
                }
                OrderInvoice invoice = orderInvoiceDao.getWithorderId(newOrder.getOrderID().toString());
                orderInvoice.setInvoiceContent("明细");
                if (StringUtils.isNotBlank(orderInvoice.getType()) && !"0".equals(orderInvoice.getType())) {
                    if (flag || invoice == null) {
                        orderInvoiceService.save(orderInvoice);
                    } else {
                        orderInvoice.setId(invoice.getId());
                        orderInvoiceService.updateByID(orderInvoice);
                    }
                } else if (invoice != null) {
                    orderInvoiceDao.delete(invoice);
                }

            }
            if ("6".equals(newOrder.getOrderSubmitType())) {  // 协销帮个人下的订单
                orderUserInfo = orderUserInfoService.findByOrderID(newOrder.getOrderID());
            }
            orderUserInfoService.saveWithcity(orderUserInfo);
            //数据库中的订单商品
            NewOrderProduct newOrderProduct = new NewOrderProduct();
            newOrderProduct.setOrderID(newOrder.getOrderID());
            List<NewOrderProduct> dbOrderProducts = newOrderProductDao.findAllList(newOrderProduct);

            StringBuilder productName = new StringBuilder();
            if (flag) {
                //新增加的订单,那么删除原有的子订单 和订单商品信息
                newOrderProductDao.deleteByOrderID(newOrder.getOrderID());
                newShopOrderDao.deleteByOrderID(newOrder.getOrderID());
                OrderUtil.orderSplit(newOrder);
                // 重新生成这些子订单 和订单商品信息
                for (NewShopOrder shopOrder : newOrder.getNewShopOrders()) {
                    shopOrder.setOrderID(newOrder.getOrderID());
                    shopOrder.setOrderNo(newOrder.getOrderNo());
                    shopOrder.setUserID(newOrder.getUserID());
                    newShopOrderDao.insert(shopOrder);
                    Double shopProductAmount = 0D;
                    Double shopTaxFee = 0D;
                    double promotionsTouchPrice = 0d;
                    double promotionsReducedPrice = 0d;
                    double shopTouchPrice = 0d;
                    double shopReducedPrice = 0d;
                    double needPayAmount = shopOrder.getNeedPayAmount();
                    for (NewOrderProduct orderProduct : shopOrder.getNewOrderProducts()) {
                        productName.append(orderProduct.getName());
                        // 没有折扣时促销才生效
                        if (orderProduct.getDiscount() >= 100d) {
                            if (null != promotionsList && promotionsList.size() > 0) {
                                for (CmPromotion promotion : promotionsList) {
                                    if ("3".equals(promotion.getType())) {
                                        shopOrder.setOrderPromotionsId(orderProduct.getOrderPromotionsId());
                                        if ("2".equals(promotion.getMode())) {
                                            promotionsTouchPrice = promotion.getTouchPrice();
                                            promotionsReducedPrice = promotion.getReducedPrice();
                                            shopTouchPrice += (orderProduct.getNum() * orderProduct.getPrice());
                                        }
                                    }
                                    // 单品
                                    if ("1".equals(promotion.getType())) {
                                        // 优惠价
                                        if ("1".equals(promotion.getMode())) {
                                            shopReducedPrice += (orderProduct.getPrice() - promotion.getTouchPrice()) * orderProduct.getNum();
                                        }
                                        // 单品满减
                                        if ("2".equals(promotion.getMode())) {
                                            if (orderProduct.getPrice() * orderProduct.getNum() > promotion.getTouchPrice()) {
                                                shopReducedPrice += promotion.getReducedPrice();
                                                needPayAmount -= promotion.getReducedPrice();
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        orderProduct.setOrderID(newOrder.getOrderID());
                        orderProduct.setOrderNo(newOrder.getOrderNo());
                        orderProduct.setShopOrderID(shopOrder.getShopOrderID());
                        orderProduct.setShopOrderNo(shopOrder.getShopOrderNo());
                        shopTaxFee += orderProduct.getShouldPayTotalTax();
                        shopProductAmount += orderProduct.getShopProductAmount();
                        if (orderProduct.getLadderPriceFlag() == null) {
                            orderProduct.setLadderPriceFlag(0);
                        }
                        newOrderProductDao.insert(orderProduct);
                        //插入阶梯价格列表
                        insertLadderPrice(orderProduct);
                    }
                    if (shopTouchPrice > promotionsTouchPrice) {
                        shopReducedPrice += promotionsReducedPrice;
                        needPayAmount -= promotionsReducedPrice;
                    }
                    shopOrder.setPromotionFullReduction(shopReducedPrice);
                    shopOrder.setNeedPayAmount(needPayAmount);
                    shopOrder.setShopProductAmount(shopProductAmount);
                    shopOrder.setShopPostFee(0D);
                    shopOrder.setShopTaxFee(shopTaxFee);
                    shopOrder.setShouldPayShopAmount(shopProductAmount + shopTaxFee);
                    shopOrder.setPayedShopAmount(0D);
                    shopOrder.setShopOtherFee(0D);
                    newShopOrderDao.update(shopOrder);
                }
            } else {
                // 重新保存逻辑
                //把从页面上传过来的orderProduct   根据 shopID 来分组
                Map<Integer, List<NewOrderProduct>> orderProductMap = new HashMap<>();
                for (NewOrderProduct op : newOrder.getOrderProduct()) {
                    if (orderProductMap.containsKey(op.getShopID())) {
                        orderProductMap.get(op.getShopID()).add(op);
                    } else {
                        List<NewOrderProduct> l = new ArrayList<>();
                        l.add(op);
                        orderProductMap.put(op.getShopID(), l);
                    }
                }
                // orderProduct 分组完成
                //开始更新shopOrder
                List<NewShopOrder> dbShopOrders = newShopOrderDao.findListByOrderID(newOrder.getOrderID());
                int shopOrderNoIndex = 0;  //记录子订单的最大编号 , 新添加的子订单编号一次往后增加
                //删除多余的shopOrder记录
                for (NewShopOrder s : dbShopOrders) {
                    // 说明这个重新选择的orderProduct已经不包含这个供应商shopID的商品了
                    if (!orderProductMap.containsKey(s.getShopID())) {
                        newShopOrderDao.delete(s);
                    }
                    s.setSendOutStatus("1");
                    int shopOrderIndex = Integer.parseInt(s.getShopOrderNo().substring(s.getShopOrderNo().length() - 2));
                    shopOrderNoIndex = shopOrderNoIndex < shopOrderIndex ? shopOrderIndex : shopOrderNoIndex;
                }
                //更新其余的shopOrder的信息
                A:
                for (Map.Entry<Integer, List<NewOrderProduct>> entry : orderProductMap.entrySet()) {
                    for (NewShopOrder s : dbShopOrders) {
                        if (s.getShopID().intValue() == entry.getKey().intValue()) {
                            OrderUtil.updateShopOrderInfo(s, entry.getValue(), newOrder.getPromotions());
                            newShopOrderDao.update(s);
                            continue A;
                        }
                    }
                    NewShopOrder newShopOrder = new NewShopOrder();
                    OrderUtil.updateShopOrderInfo(newShopOrder, entry.getValue(), newOrder.getPromotions());
                    newShopOrder.setShopOrderNo(OrderUtil.getshopOrderNo(newOrder.getOrderNo(), ++shopOrderNoIndex));
                    newShopOrder.setSendOutStatus("1");
                    newShopOrder.setOrderNo(newOrder.getOrderNo());
                    newShopOrder.setOrderID(newOrder.getOrderID());
                    newShopOrder.setUserID(newOrder.getUserID());
                    newShopOrder.setOrderSubmitType(Integer.parseInt(dbOrder.getOrderSubmitType()));
                    newShopOrder.setOrderTime(dbOrder.getOrderTime());
                    newShopOrder.setSpID(dbOrder.getSpID());
                    newShopOrder.setMainSpID(dbOrder.getMainSpID());
                    newShopOrder.setAutoOverTimeMills(0L);
                    newShopOrder.setAutoReceiveTimeMills(0L);
                    newShopOrder.setClubID(newOrder.getClubID());
                    newShopOrder.setCanRefundAmount(0D);
                    newShopOrder.setRefundAmount(0D);
                    newShopOrder.setRefundStatus(0);
                    newShopOrder.setOrderBeanAmount(0);
                    newShopOrder.setUseBeanFlag(0);
                    newShopOrder.setUseBeanAmount(0);
                    newShopOrder.setStatus(1);//子订单待确认
                    newShopOrder.setAccountAmount(0D);
                    newShopOrder.setCanRefundFlag(1);
                    newShopOrder.setBuyStatus("1");
                    newShopOrder.setPayStatus("1");
                    if ("0".equals(newOrder.getFreePostFlag())) {
                        newShopOrder.setFee(0D);//运费
                    }
                    if ("-1".equals(newOrder.getFreePostFlag())) {
                        newShopOrder.setFee(-1D);//运费
                    }
                    newShopOrder.setOutStoreNum(0);
                    newShopOrder.setDelFlag("0");
                    newShopOrder.setPayFlag("0");
                    newShopOrder.setSplitFlag("1");// 订单默认可拆分
                    newShopOrderDao.insert(newShopOrder);
                    for (NewOrderProduct product : orderProducts) {
                        if (product.getShopID().intValue() == newShopOrder.getShopID().intValue()) {
                            product.setShopOrderID(newShopOrder.getShopOrderID());
                            product.setShopOrderNo(newShopOrder.getShopOrderNo());
                            product.setOrderPromotionsId(product.getOrderPromotionsId());
                        }
                    }
                }

                List<NewShopOrder> shopOrders = newShopOrderDao.findListByOrderID(newOrder.getOrderID());
                Map<Integer, Integer> dbShopInfoID = new HashMap<>(); //用来存放数据库中这个订单原来的子订单中  供应商的信息 key = shopID value = shopOrderNo
                Map<Integer, String> dbShopInfoNo = new HashMap<>(); //用来存放数据库中这个订单原来的子订单中  供应商的信息 key = shopID value = shopOrderID
                for (NewShopOrder so : shopOrders) {
                    dbShopInfoID.put(so.getShopID(), so.getShopOrderID());
                    dbShopInfoNo.put(so.getShopID(), so.getShopOrderNo());
                }
                if (CollectionUtils.isNotEmpty(orderProducts)) {
                    loop:
                    for (NewOrderProduct product : orderProducts) {
                        if (product.getOrderProductID() != null) {  //修改：表单所有ID不为空的修改
                            if (CollectionUtils.isNotEmpty(dbOrderProducts)) {
                                for (NewOrderProduct dbProduct : dbOrderProducts) {
                                    if (dbProduct.getProductID().intValue() == product.getProductID().intValue() && product.getProductType().equals(dbProduct.getProductType())) {
                                        product.setOrderID(newOrder.getOrderID());
                                        Double copCostPrice = getOrderProductCostPrice(product, newOrder.getUserID());
                                        product.setCostPrice(copCostPrice);
                                        // product.setShopProductAmount(copCostPrice * (product.getNum() + product.getPresentNum()));//商品费  =  成本价快照
                                        // 赠送数单独列出来
                                        product.setShopProductAmount(copCostPrice * product.getNum());
                                        newOrderProductDao.update(product);
                                        //更新订单商品阶梯价格
                                        updateLadderPrice(product);
                                    }
                                }
                            }
                        } else { // 表单订单商品ID为空  可能是新增  但是 增加的是同样的商品的话 会覆盖原来的商品 也相当于是 修改
                            // 可能存在一种情况  就是原来存在的商品  又被重新添加了一次
                            // 这时,页面传过来的商品的 product.getOrderProductID() == null
                            // 所以 不能直接通过 product.getOrderProductID() == null 条件来决定是否insert
                            // 还需要对比一下productID
                            if (CollectionUtils.isNotEmpty(dbOrderProducts)) {
                                for (NewOrderProduct dbProduct : dbOrderProducts) {
                                    if (dbProduct.getProductID().intValue() == product.getProductID().intValue() && product.getProductType().equals(dbProduct.getProductType())) {
                                        product.setOrderID(newOrder.getOrderID());
                                        product.setOrderNo(dbProduct.getOrderNo());
                                        product.setShopOrderID(dbProduct.getShopOrderID());
                                        product.setShopOrderNo(dbProduct.getShopOrderNo());
                                        product.setOrderProductID(dbProduct.getOrderProductID());
                                        Double copCostPrice = getOrderProductCostPrice(dbProduct, newOrder.getUserID());
                                        product.setCostPrice(copCostPrice);
                                        product.setLadderPriceFlag(product.getLadderPriceFlag() == null ? dbProduct.getLadderPriceFlag() : product.getLadderPriceFlag());
                                        product.setIsActProduct(product.getIsActProduct() == null ? dbProduct.getIsActProduct() : product.getIsActProduct());
                                        product.setIncludedTax(product.getIncludedTax() == null ? dbProduct.getIncludedTax() : product.getIncludedTax());
                                        product.setInvoiceType(product.getInvoiceType() == null ? dbProduct.getInvoiceType() : product.getInvoiceType());
                                        // product.setShopProductAmount(copCostPrice * (product.getNum() + product.getPresentNum()));//商品费  =  成本价快照
                                        // 赠送数单独列出来
                                        product.setShopProductAmount(copCostPrice * product.getNum());
                                        newOrderProductDao.update(product);
                                        //更新订单商品阶梯价格
                                        updateLadderPrice(product);
                                        continue loop;
                                    }
                                }
                            }
                            product.setOrderNo(newOrder.getOrderNo());
                            product.setOrderID(newOrder.getOrderID());
                            if (dbShopInfoID.containsKey(product.getShopID())) {
                                //数据库子订单中包含了这个供应商 就不需要添加子订单
                                product.setShopOrderID(dbShopInfoID.get(product.getShopID()));
                                product.setShopOrderNo(dbShopInfoNo.get(product.getShopID()));
                            }
                            if (product.getLadderPriceFlag() == null) {
                                product.setLadderPriceFlag(0);
                            }
                            newOrderProductDao.insert(product);
                            //插入阶梯价格列表
                            insertLadderPrice(product);
                        }
                    }
                }
                //删除
                if (CollectionUtils.isNotEmpty(orderProducts)) {
                    for (NewOrderProduct dbProduct : dbOrderProducts) {
                        boolean b = true;//删除
                        for (NewOrderProduct product : orderProducts) {
                            if (dbProduct.getProductID().intValue() == product.getProductID().intValue() && product.getProductType().equals(dbProduct.getProductType())) {
                                b = false;//不删除
                                break;
                            }
                        }
                        //删除：数据库有，表单没有的
                        if (b) {
                            dbProduct.setDelFlag(DateUtils.formatDate(new Date(), "yyyyMMddHHmmssSSSS"));
                            newOrderProductDao.delete(dbProduct);
                        }
                    }
                }
            }


            //如果不包邮 增加运费商品子订单（先删除掉相关订单和订单商品）运费商品ID 999
            Integer freightProductID = 999;
            NewShopOrder freightShopOrder = new NewShopOrder();
            NewOrderProduct freightOrderProduct = new NewOrderProduct();

            //根据主订单号和运费商品查出订单商品
            List<NewOrderProduct> freightOrderProductList = newOrderProductDao.findFreightOrderProductList(newOrder.getOrderID(), freightProductID);

            if (newOrder.getShopNote() != null) {
                List<NewShopOrder> so = newShopOrderDao.findListByOrderID(newOrder.getOrderID());
                Arrays.asList(newOrder.getShopNote()).stream().forEach(note -> {
                    if (StringUtils.isNoneEmpty(note) && note.contains("=")) {
                        String shopID = note.split("=")[1];
                        String text = note.split("=")[0];
                        if (StringUtils.isNotEmpty(shopID)) {
                            NewShopOrder shopOrder = so.stream().filter(sOrder -> sOrder.getShopID().intValue() == Integer.valueOf(shopID)).findAny().get();
                            shopOrder.setNote(text);
                            newShopOrderDao.updateNote(shopOrder);
                        }
                    }
                });
            }
            for (NewOrderProduct bean : freightOrderProductList) {
                freightShopOrder.setShopOrderID(bean.getShopOrderID());
                freightOrderProduct.setOrderProductID(bean.getOrderProductID());
                newShopOrderDao.delete(freightShopOrder);
                newOrderProductDao.delete(freightOrderProduct);
            }
            if (newOrder.getFreePostFlag() != null && newOrder.getFreePostFlag().equals("1")) {
                setFreightShopOrder(newOrder);
            }
            List<NewShopOrder> shopOrders = newShopOrderDao.findListByOrderID(newOrder.getOrderID());
            String shopOrderIDs = "";
            for (int i = 0; i < shopOrders.size(); i++) {
                if (i == shopOrders.size() - 1) {
                    shopOrderIDs = shopOrderIDs + shopOrders.get(i).getShopOrderID();
                } else {
                    shopOrderIDs = shopOrderIDs + shopOrders.get(i).getShopOrderID() + ",";
                }
            }
            newOrder.setShopOrderIDs(shopOrderIDs);
            newOrderDao.update(newOrder);

            //下单短信推送
            try {
                if (flag && "0".equals(newOrder.getRebateFlag())) {
                    CmUser user = cmUserDao.get(newOrder.getUserID().toString());
                    if (user != null && StringUtils.isNotBlank(user.getBindMobile())) {
                        String wwwServer = Global.getConfig("wwwServer");
                        String shortLink = getShortLink(8, 3, wwwServer + "user/order/detail.html?orderId=" + newOrder.getOrderID());
                        String name = productName.toString();
                        if (name.length() > 10) {
                            name = name.substring(0, 10);
                        }
                        String content = "您已成功下单“" + name + "...”等" + newOrder.getProductCount() + "件商品，订单编号：" + newOrder.getOrderNo() + "，订单等待支付，支付完成后采美将尽快安排发货。" +
                                "您可关注采美公众号或者访问采美微信小程序和网站查看并支付订单。平台公众号：微信搜索“采美365网”; 微信小程序：微信搜索“采美采购商城”；网址：www.caimei365.com/t/" + shortLink;
                        boolean sendSms = getSendSms(3, user.getBindMobile(), content);
                        if (!sendSms) {
                            logger.info("下单推送失败,orderId>>>>" + newOrder.getOrderID());
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }

    public String getShortLink(int length, int markId, String url) {
        String shortLink = RandomCode.generateShortLink(length);
        Integer id = newOrderDao.findBYShortLink(shortLink);
        if (id != null && id > 0) {
            getShortLink(length, markId, url);
        }
        newOrderDao.insertShortLink(markId, shortLink, url);
        return shortLink;
    }

    public boolean getSendSms(int markId, String mobile, String content) throws Exception {
        String config = Global.getConfig("cm.config");
        //测试环境手机号允许发短信
        List<String> list = new ArrayList<>();
        list.add("15917362709");
        list.add("15814011616");
        list.add("13100721916");
        list.add("15113936829");
        if (config.equals("product") || list.contains(mobile)) {
            if (StringUtils.isNotBlank(mobile) && mobile.length() == 11) {
                String regex = "^(1[3-9]\\d{9}$)";
                Pattern pattern = Pattern.compile(regex);
                Matcher matcher = pattern.matcher(mobile);
                if (matcher.matches()) {
                    Map<String, Object> map = new HashMap<>(2);
                    map.put("content", content);
                    map.put("mobile", mobile);
                    String coreServer = Global.getConfig("caimei.core");
                    String url = coreServer + "/tools/sms/send";
                    String result = HttpRequest.sendPost(url, map);
                    JSONObject parseObject = JSONObject.parseObject(result);
                    Integer code = parseObject.getInteger("code");
                    if (code != 0) {
                        logger.info("短信发送失败,手机号>>>>" + mobile);
                    } else {
                        newOrderDao.updateSendNum(markId, 1);
                        return true;
                    }
                }
            }
        }
        return false;
    }

    private void insertLadderPrice(NewOrderProduct orderProduct) {
        List<OrderProductLadderPrice> orderProductLadderPriceList = new ArrayList<>();
        if (orderProduct.getLadderPriceFlag() == 1) {
            //使用阶梯价格的订单商品保存下单时的阶梯价格列表
            List<ProductLadderPrice> ladderPriceList = productDao.findProductLadderPrice(orderProduct.getProductID(), 3);
            ladderPriceList.forEach(ladderPrice -> {
                OrderProductLadderPrice orderProductLadderPrice = new OrderProductLadderPrice();
                orderProductLadderPrice.setOrderProductId(orderProduct.getOrderProductID());
                orderProductLadderPrice.setBuyNum(ladderPrice.getBuyNum());
                orderProductLadderPrice.setBuyPrice(new BigDecimal(ladderPrice.getBuyPrice()));
                orderProductLadderPrice.setCreateDate(new Date());
                orderProductLadderPrice.setLadderNum(ladderPrice.getLadderNum().intValue());
                orderProductLadderPriceList.add(orderProductLadderPrice);
            });
        }
        if (!CollectionUtils.isEmpty(orderProductLadderPriceList)) {
            orderProductLadderPriceList.forEach(ladderPrice -> {
                newOrderProductDao.insertOrderProductLadderPrice(ladderPrice);
            });
        }
    }

    private void updateLadderPrice(NewOrderProduct product) {
        if (product.getLadderPriceFlag() == 1) {
            List<ProductLadderPrice> ladderPriceList = productDao.findProductLadderPrice(product.getProductID(), 3);
            List<OrderProductLadderPrice> orderProductLadderPriceList = newOrderProductDao.findladderPriceList(product.getOrderProductID());
            AtomicReference<Boolean> equalsFlag = new AtomicReference<>(true);
            //判断新的阶梯价格列表和订单商品的阶梯价格列表是否相同
            if (ladderPriceList.size() == orderProductLadderPriceList.size()) {
                ladderPriceList.forEach(ladderPrice -> {
                    orderProductLadderPriceList.forEach(orderProductLadderPrice -> {
                        if (ladderPrice.getLadderNum().equals(orderProductLadderPrice.getLadderNum())) {
                            if (!ladderPrice.getBuyNum().equals(orderProductLadderPrice.getBuyNum()) || ladderPrice.getBuyPrice() != orderProductLadderPrice.getBuyPrice().doubleValue()) {
                                equalsFlag.set(false);
                            }
                        }
                    });
                });
            }
            if (!equalsFlag.get()) {
                //若不相同，则更新订单商品表的阶梯价格列表
                newOrderProductDao.deleteLadderPrice(product.getOrderProductID());
                List<OrderProductLadderPrice> newLadderPriceList = new ArrayList<>();
                ladderPriceList.forEach(ladderPrice -> {
                    OrderProductLadderPrice orderProductLadderPrice = new OrderProductLadderPrice();
                    orderProductLadderPrice.setOrderProductId(product.getOrderProductID());
                    orderProductLadderPrice.setBuyNum(ladderPrice.getBuyNum());
                    orderProductLadderPrice.setBuyPrice(new BigDecimal(ladderPrice.getBuyPrice()));
                    orderProductLadderPrice.setCreateDate(new Date());
                    orderProductLadderPrice.setLadderNum(ladderPrice.getLadderNum().intValue());
                    newLadderPriceList.add(orderProductLadderPrice);
                });
                if (!CollectionUtils.isEmpty(newLadderPriceList)) {
                    newLadderPriceList.forEach(ladderPrice -> {
                        newOrderProductDao.insertOrderProductLadderPrice(ladderPrice);
                    });
                }
            }
        }
    }


    /***
     * 获取成本价
     * @param o 订单商品
     * @return
     */
    public double getOrderProductCostPrice(NewOrderProduct o, Integer userID) {
        //获取产品表的成本
        Product product = productDao.get(String.valueOf(o.getProductID()));
        Float costPrice = 0.0f;//成本价
        //判断是否选中固定成本价
        if (null != product.getCostPrice() && org.apache.commons.lang3.StringUtils.equals("1", product.getCostCheckFlag()) && StringUtils.isNotEmpty(product.getCostPrice())) {
            String costPriceStr = product.getCostPrice();
            if (StringUtils.isNotEmpty(costPriceStr)) {
                costPrice = Float.parseFloat(costPriceStr);
            }
        }
        //判断是否选中比例成本价
        else if (null != product.getCostProportional() && org.apache.commons.lang3.StringUtils.equals("2", product.getCostCheckFlag()) && StringUtils.isNotEmpty(product.getCostProportional())) {
            double price = o.getDiscountPrice();
            if (userID != null) {
                CmUser cmUser = cmUserDao.get(userID.toString());
                if ("3".equals(cmUser.getRegisterUserTypeID()) ||
                        "23".equals(cmUser.getRegisterUserTypeID()) ||
                        "33".equals(cmUser.getRegisterUserTypeID())) {
                    price = o.getDiscountPrice(); //会员价
                }
            }
            if (o.getProductType() == 1 || o.getProductType() == 2) {
                // 赠品订单过来售价为0，去数据库获取该商品原始售价
                Double tempPrice = cmPromotionDao.getPresentPriceById(o.getProductID());
                if (null != tempPrice && tempPrice > 0) {
                    price = tempPrice;
                }
            }
            CmPromotion promotions = cmPromotionDao.findPromotionsByProductId(o.getProductID());
            //不含税可开票/未知商品计算税费
            if (("0".equals(product.getIncludedTax()) && ("1".equals(product.getInvoiceType()) || "2".equals(product.getInvoiceType()))) || "2".equals(product.getIncludedTax()) || "".equals(product.getIncludedTax())) {
                BigDecimal addedValueTax = BigDecimal.ZERO;
                if (promotions != null && "1".equals(promotions.getType()) && "1".equals(promotions.getMode())) {
                    addedValueTax = MathUtil.div(MathUtil.mul(promotions.getTouchPrice(), o.getTaxRate()), BigDecimal.valueOf(100));
                    price = MathUtil.add(promotions.getTouchPrice(), addedValueTax).doubleValue();
                } else {
                    addedValueTax = MathUtil.div(MathUtil.mul(price, o.getTaxRate()), BigDecimal.valueOf(100));
                    price = MathUtil.add(price, addedValueTax).doubleValue();
                }
            } else if (promotions != null && "1".equals(promotions.getType()) && "1".equals(promotions.getMode())) {
                price = promotions.getTouchPrice();
            }
            //通过比例成本价计算
            costPrice = MathUtil.mul(MathUtil.div(product.getCostProportional(), 100), price).floatValue();
            //赠品重新计算供应商税费
            if ((o.getProductType() == 1 || o.getProductType() == 2)
                    && o.getSupplierTaxRate() != null && o.getSupplierTaxRate() > 0
                    && (("0".equals(product.getIncludedTax()) && ("1".equals(product.getInvoiceType()) || "2".equals(product.getInvoiceType())))
                    || "2".equals(product.getIncludedTax()) || "".equals(product.getIncludedTax()))) {
                Double singleShouldPayTotalTax = (costPrice * o.getSupplierTaxRate()) / 100;
                o.setSingleShouldPayTotalTax(singleShouldPayTotalTax);
                o.setShouldPayTotalTax(singleShouldPayTotalTax * o.getNum());
            }
        }
        return costPrice;
    }

    /**
     * @return
     * @Author ye.qin
     * @Description //TODO 设置运费子订单
     * @Date 2019\5\23 0023 18:11
     * @Param
     */
    private void setFreightShopOrder(NewOrder newOrder) {
        NewOrder pOrder = newOrder;
        Product product = productDao.get(Global.getConfig("freightProductID"));
        newOrder = newOrderDao.get(newOrder.getOrderID().toString());
        NewShopOrder newShopOrder = new NewShopOrder();
        int i = newShopOrderDao.findShopOrderNum(newOrder.getOrderID()) + 1;
        newShopOrder.setShopOrderNo(OrderUtil.getshopOrderNo(newOrder.getOrderNo(), i));
        newShopOrder.setOrderNo(newOrder.getOrderNo());
        newShopOrder.setOrderID(newOrder.getOrderID());
        newShopOrder.setUserID(newOrder.getUserID());
        newShopOrder.setOrderType(Integer.valueOf(newOrder.getOrderType()));
        newShopOrder.setOrderSubmitType(Integer.valueOf(newOrder.getOrderSubmitType()));
        newShopOrder.setPresentNum(0);
        newShopOrder.setItemCount(1);
        newShopOrder.setShopID(product.getShopID());   //运费商品供应商ID默认998
        newShopOrder.setFee(newOrder.getFreight());
        newShopOrder.setProductAmount(newOrder.getFreight());
        newShopOrder.setTotalAmount(newOrder.getFreight());
        newShopOrder.setNeedPayAmount(newOrder.getFreight());
        newShopOrder.setDiscountAmount(0D);
        if ("1".equals(pOrder.getPostageOrderFlag())) {
            newShopOrder.setPayFlag("1");
            newShopOrder.setPayStatus("3");
        } else {
            newShopOrder.setPayFlag("0");
            newShopOrder.setPayStatus("1");
        }
        newShopOrder.setOrderTime(newOrder.getOrderTime());
        newShopOrder.setSendOutStatus("3");
        newShopOrder.setTotalAddedValueTax(0D);
        newShopOrder.setCanRefundAmount(0D);
        newShopOrder.setOutStoreNum(1);
        newShopOrder.setRefundAmount(0D);
        newShopOrder.setRefundStatus(0);
        newShopOrder.setClubID(newOrder.getClubID());
        newShopOrder.setSpID(newOrder.getSpID());
        newShopOrder.setMainSpID(newOrder.getMainSpID());
        newShopOrder.setAutoOverTimeMills(0L);
        newShopOrder.setAutoReceiveTimeMills(0L);
        newShopOrder.setOrderBeanAmount(0);
        newShopOrder.setUseBeanFlag(0);
        newShopOrder.setUseBeanAmount(0);
        newShopOrder.setAccountAmount(0D);
        newShopOrder.setCanRefundFlag(1);
        newShopOrder.setBuyStatus("1");
        newShopOrder.setDelFlag("0");
        newShopOrder.setPayFlag("0");
        newShopOrder.setSplitFlag("1");// 订单默认可拆分
        newShopOrder.setZeroCostFlag(0);// 子订单0成本标识

        newShopOrderDao.insert(newShopOrder);

        //插入订单商品
        NewOrderProduct orderProduct = new NewOrderProduct();
        orderProduct.setOrderNo(newOrder.getOrderNo());
        orderProduct.setOrderID(newOrder.getOrderID());
        orderProduct.setShopOrderID(newShopOrder.getShopOrderID());
        orderProduct.setShopOrderNo(newShopOrder.getShopOrderNo());
        orderProduct.setShopID(product.getShopID());
        orderProduct.setProductID(999);
        orderProduct.setNum(1);
        orderProduct.setPresentNum(0);
        orderProduct.setOutStoreType("0");
        orderProduct.setProps(product.getProps());
        orderProduct.setProductNo(product.getProductCode());
        orderProduct.setPrice(newOrder.getFreight());
        orderProduct.setNormalPrice(newOrder.getFreight());
        orderProduct.setPrice0(newOrder.getFreight());
        orderProduct.setPrice1(newOrder.getFreight());
        orderProduct.setTotalAmount(newOrder.getFreight());
        orderProduct.setTotalFee(newOrder.getFreight());
        orderProduct.setShouldPayFee(newOrder.getFreight());
        orderProduct.setDiscount(100D);
        orderProduct.setDiscountPrice(newOrder.getFreight());
        orderProduct.setTaxRate(0D);
        orderProduct.setAddedValueTax(0D);
        orderProduct.setTotalAddedValueTax(0D);
        orderProduct.setShouldPayTotalTax(0D);
        orderProduct.setShopFee(0D);
        orderProduct.setOtherFee(0D);
        orderProduct.setCmFee(newOrder.getFreight());
        orderProduct.setSingleShopFee(0D);
        orderProduct.setSingleOtherFee(0D);
        orderProduct.setSingleCmFee(newOrder.getFreight());
        orderProduct.setTotalBeans(0D);
        orderProduct.setUseBalanceAmount(0D);
        orderProduct.setUseBeanAmount(0);
        orderProduct.setNotOutStore(0);
        orderProduct.setCmbeanPrice(0);
        orderProduct.setBuyAgainFlag("0");
        orderProduct.setShopName(product.getShopName());
        orderProduct.setName(product.getName());
        orderProduct.setCostPrice(newOrder.getFreight());
        orderProduct.setLadderPriceFlag(0);
        orderProduct.setIncludedTax(product.getIncludedTax());
        orderProduct.setInvoiceType(product.getInvoiceType());
        newOrderProductDao.insert(orderProduct);
    }

    @Override
    public NewOrder get(String id) {
        NewOrder newOrder = super.get(id);
        CmUser user = cmUserDao.get(newOrder.getUserID().toString());
        if (user != null) {
            //查询用户余额,机构名
            newOrder.setBuyer(user.getName());
            Double ableUserMoney = user.getAbleUserMoney() == null ? 0d : user.getAbleUserMoney();
            newOrder.setAbleUserMoney(ableUserMoney);
        }
        List<Integer> l = new ArrayList<>();
        l.add(newOrder.getOrderID());
        List<Integer> orderIds = cmDiscernReceiptDao.findRebateOrderID(l);
        if (orderIds.contains(newOrder.getOrderID()))
            newOrder.setRebateOrder("1");
        else
            newOrder.setRebateOrder("0");
        if (null != newOrder) {
            if (newOrder.getCouponAmount() > 0) {
                CmCouponOrderRecord couponRecord = newOrderDao.findOrderCouponRecord(newOrder.getOrderID());
                if (couponRecord != null) {
                    newOrder.setClubCouponId(couponRecord.getClubCouponId());
                    newOrder.setCouponOrderRecord(couponRecord);
                }
            }
            //获取订单客户
            OrderUserInfo orderUserInfo = orderUserInfoService.findByOrderID(newOrder.getOrderID());
            NewCmClub club = newCmClubDao.getclubByUserId(newOrder.getUserID());
            if (null != orderUserInfo) {
                newOrder.setBpOrderUserinfo(orderUserInfo);
                if (club != null) {
                    //使用机构名称
                    orderUserInfo.setName(club.getName());
                }
            }
            //获取订单商品
            List<NewOrderProduct> list = new ArrayList<>();
            List<NewShopOrder> shopOrders = newShopOrderDao.findListByOrderID(newOrder.getOrderID());
            if (CollectionUtils.isNotEmpty(shopOrders)) {
                for (NewShopOrder shopOrder : shopOrders) {
                    List<NewOrderProduct> pList = newOrderProductDao.findListByShopOrderID(shopOrder.getShopOrderID());
                    pList.forEach(orderProduct -> {
                        if (orderProduct.getLadderPriceFlag() == 1) {
                            // 查询订单商品阶梯价格
                            List<OrderProductLadderPrice> ladderPriceList = newOrderProductDao.findladderPriceList(orderProduct.getOrderProductID());
                            if (null != ladderPriceList && ladderPriceList.size() > 0) {
                                IntStream.range(0, ladderPriceList.size()).forEach(i -> {
                                    if (i == ladderPriceList.size() - 1) {
                                        ladderPriceList.get(i).setBuyNumRangeShow("≥" + ladderPriceList.get(i).getBuyNum());
                                    } else {
                                        String buyNumRangeShow = ladderPriceList.get(i).getBuyNum() + "~" + (ladderPriceList.get(i + 1).getBuyNum() - 1);
                                        ladderPriceList.get(i).setBuyNumRangeShow(buyNumRangeShow);
                                    }
                                });
                                orderProduct.setOrderProductLadderPriceList(ladderPriceList);
                            }
                        }
                        //充值定金商品
                        if (6060 == orderProduct.getProductID()) {
                            newOrder.setRechargeGoods(1);
                        }
                    });
                    list.addAll(pList);
                    shopOrder.setNewOrderProducts(pList);
                    if (pList.stream().anyMatch(p -> p.getProductID().intValue() == 999))
                        shopOrder.setPostFeeCos("1");
                    pList.stream().forEach(item -> {
                        if (NewOrderStatus.hasReturn(newOrder.getStatus())) {
                            Integer returningNum = newOrderProductDao.getReturningNum(item.getOrderProductID());
                            Integer returnedNum = newOrderProductDao.getReturnedNum(item.getOrderProductID());
                            item.setReturningNum(returningNum);
                            item.setReturnedNum(returnedNum);
                        }
                        /**确认收货信息*/
                        if (NewOrderStatus.hasReceived(newOrder.getStatus())) {
                            Integer receivedNum = newOrderProductDao.getReceivedNum(item.getOrderProductID());
                            item.setReceivedNum(receivedNum);
                        }
                        String domain = SysConfig.getStringConfig("crm.server.domain");
                        item.setProductImage(AppUtils.getProductImageURL(item.getProductImage(), AppKeys.ORIGINAL_PICTURE, domain));
                        if (item != null && item.getOrderPromotionsId() != null && item.getOrderPromotionsId() > 0) {
                            item.setProductPromotion(cmPromotionDao.findOrderPromotions(item.getOrderPromotionsId()));
                        }
                    });
                    Double payed = cmPayShopRecordDao.sumByShopOrderID(shopOrder.getShopOrderID());
                    shopOrder.setPayed(payed);
                    //查询是否存在店铺促销活动
                    CmPromotion shopPromotion = null;
                    if (shopOrder.getOrderPromotionsId() != null && shopOrder.getOrderPromotionsId() > 0) {
                        shopPromotion = cmPromotionDao.findOrderPromotions(shopOrder.getOrderPromotionsId());
                        shopOrder.setShopPromotion(shopPromotion);
                    }
                }
                newOrder.setNewShopOrders(shopOrders);
            }
            if (CollectionUtils.isNotEmpty(list)) {
                newOrder.setOrderProduct(list);
                double freight = 0D;
                double totalAddedValueTax = 0D;
                for (NewOrderProduct op : list) {
                    if (op.getProductID().intValue() == 999) { //邮费商品
                        freight += op.getPrice();
                    }
                    totalAddedValueTax += op.getTotalAddedValueTax();
                }
                if ("1".equals(newOrder.getFreePostFlag())) newOrder.setFreight(freight);
                newOrder.setTotalAddedValueTax(totalAddedValueTax);
            }
            shopOrders.sort((so1, so2) -> {
                //给子订单排序  邮费排在最后  其余的按shopOrderID  asc
                if ("1".equals(so1.getPostFeeCos())) return 1;
                return so1.getShopOrderID() - so2.getShopOrderID();
            });
            //获取订单发票
            OrderInvoice orderInvoice = orderInvoiceDao.getWithorderId(newOrder.getOrderID() + "");
            if (null != orderInvoice) {
                newOrder.setOrderInvoice(orderInvoice);
            }
        }
        return newOrder;
    }

    /**
     * @return
     * @Author ye.qin
     * @Description //TODO 获取主订单详情
     * @Date 2019\5\24 0024 10:45
     * @Param
     */
    public NewOrder getNewOrder(CmReturnedPurchase cmReturnedPurchase) {
        NewOrder newOrder = new NewOrder();
        if (null != cmReturnedPurchase) {
            newOrder = newOrderDao.get(cmReturnedPurchase.getOrderID().toString());
            if (newOrder.getCouponAmount() > 0) {
                CmCouponOrderRecord couponRecord = newOrderDao.findOrderCouponRecord(newOrder.getOrderID());
                if (couponRecord != null) {
                    newOrder.setClubCouponId(couponRecord.getClubCouponId());
                    newOrder.setCouponOrderRecord(couponRecord);
                }
            }
            //获取订单客户
            OrderUserInfo orderUserInfo = orderUserInfoService.findByOrderID(cmReturnedPurchase.getOrderID());
            NewCmClub club = newCmClubDao.getclubByUserId(newOrder.getUserID());
            if (null != orderUserInfo) {
                orderUserInfo = cmUserService.getBalance(orderUserInfo);
                newOrder.setBpOrderUserinfo(orderUserInfo);
                if (club != null) {
                    //使用机构名称
                    orderUserInfo.setName(club.getName());
                }
            }
            List<NewShopOrder> shopOrders = newShopOrderDao.findListByOrderID(cmReturnedPurchase.getOrderID());
            if (CollectionUtils.isNotEmpty(shopOrders)) {
                for (NewShopOrder shopOrder : shopOrders) {
                    //获取退货退款记录
                    CmReturnedPurchaseProduct bean = new CmReturnedPurchaseProduct();
                    bean.setShopOrderID(shopOrder.getShopOrderID());
                    List<CmReturnedPurchaseProduct> cmReturnedPurchaseProductList = cmReturnedPurchaseProductDao.getCmReturnedPurchaseProductList(bean);
                    //获取订单商品
                    List<NewOrderProduct> list = newOrderProductDao.findListByShopOrderID(shopOrder.getShopOrderID());
                    if (CollectionUtils.isNotEmpty(list)) {
                        for (NewOrderProduct newOrderProduct : list) {
                            if (null == newOrderProduct.getReturnedPurchaseProductNum()) {
                                newOrderProduct.setReturnedPurchaseProductNum(0);
                            }
                            if (null == newOrderProduct.getReturningPurchaseProductNum()) {
                                newOrderProduct.setReturningPurchaseProductNum(0);
                            }
                            if (null == newOrderProduct.getCancelProductNum()) {
                                newOrderProduct.setCancelProductNum(0);
                            }
                            for (CmReturnedPurchaseProduct cmReturnedPurchaseProduct : cmReturnedPurchaseProductList) {
                                Boolean isFirstReturn = false;
                                if (newOrderProduct.getShopOrderID().equals(cmReturnedPurchaseProduct.getShopOrderID())
                                        && newOrderProduct.getProductID().equals(cmReturnedPurchaseProduct.getProductID())) {
                                    if (cmReturnedPurchaseProduct.getStatus().equals(String.valueOf(ReturnedPurchaseStatus.RETURNING_PURCHASE.getCode()))) {
                                        newOrderProduct.setReturningPurchaseProductNum(newOrderProduct.getReturningPurchaseProductNum() + cmReturnedPurchaseProduct.getActualReturnedNum());
                                    } else if (cmReturnedPurchaseProduct.getStatus().equals(String.valueOf(ReturnedPurchaseStatus.RETURNED_PURCHASE.getCode()))) {
                                        newOrderProduct.setReturnedPurchaseProductNum(newOrderProduct.getReturnedPurchaseProductNum() + cmReturnedPurchaseProduct.getActualReturnedNum());
                                    }
                                    newOrderProduct.setCancelProductNum(newOrderProduct.getCancelProductNum() + cmReturnedPurchaseProduct.getActualCancelNum());
                                } else {
                                    //是该订单商品第一次退货退款
                                    isFirstReturn = true;
                                }
                                newOrderProduct.setFirstReturn(isFirstReturn);
                            }
                        }
                    }
                    if (CollectionUtils.isNotEmpty(list)) {
                        shopOrder.setNewOrderProducts(list);
                    }
                    //判断是否是运费订单（前端不予操作）(供应商ID TODO)
                    Product product = productDao.get(Global.getConfig("freightProductID"));
                    if (shopOrder.getShopID().equals(product.getShopID())) {
                        shopOrder.setDefaultStatus(true);
                    }
                }
                newOrder.setNewShopOrders(shopOrders);
            }


            //获取订单发票
            OrderInvoice orderInvoice = orderInvoiceDao.getWithorderId(cmReturnedPurchase.getOrderID() + "");
            if (null != orderInvoice) {
                newOrder.setOrderInvoice(orderInvoice);
            }
        }
        return newOrder;
    }

    public NewOrder findByOrderID(Integer orderID) {
        return newOrderDao.findByOrderID(orderID);
    }

    @Transactional(readOnly = false)
    public void confirmOrder(Integer orderID) {
        NewOrder order = newOrderDao.findByOrderID(orderID);
        order.setConfirmFlag("1");//确认订单标识 后台确认 1
        order.setStatus("11");//订单状态变成 ==> 待收款待付款 11

        //修改订单状态（余额抵扣）
        if (order.getPayableAmount() != null) {
            if (order.getPayableAmount() == 0 && order.getBalancePayFee() != null && order.getBalancePayFee() > 0) {
                order.setStatus(NewOrderStatus.YISHOU_DAIFA.getCode());
                order.setReceiptStatus("3");
            } else if (order.getPayableAmount() != 0 && order.getBalancePayFee() != null && order.getBalancePayFee() > 0) {
                order.setStatus(NewOrderStatus.BUSHOU_DAIFA.getCode());
                order.setReceiptStatus("2");
            }
        }
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String curDateStr = sdf.format(date);
        order.setConfirmTime(curDateStr);
        if (order.getBalancePayFee() != null && order.getBalancePayFee() > 0) {
            saveDiscernReceipt(order.getBalancePayFee(), orderID);
        }
        newOrderDao.update(order);
    }

    /**
     * 保存余额到收款记录
     *
     * @param balancePayFee 余额抵扣金额
     */
    private void saveDiscernReceipt(Double balancePayFee, Integer orderId) {
        String curDateStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        //保存余额到收款记录
        CmDiscernReceipt discernReceipt = new CmDiscernReceipt();
        discernReceipt.setPayWay("3");
        discernReceipt.setPayType("16");
        discernReceipt.setReceiptType("1");
        discernReceipt.setReceiptStatus("3");
        discernReceipt.setReceiptAmount(balancePayFee.toString());
        discernReceipt.setConfirmType("4");
        discernReceipt.setReceiptDate(curDateStr);
        discernReceipt.setConfirmDate(curDateStr);
        discernReceipt.setReviewDate(curDateStr);
        discernReceipt.setDelFlag("0");
        cmDiscernReceiptDao.insert(discernReceipt);
        CmReceiptOrderRelation relation = new CmReceiptOrderRelation();
        relation.setReceiptID(discernReceipt.getId());
        relation.setOrderID(orderId.toString());
        relation.setAssociateAmount(balancePayFee.toString());
        relation.setRelationType("2");
        relation.setDelFlag("0");
        cmReceiptOrderRelationDao.insert(relation);
    }

    @Transactional(readOnly = false)
    public void update(NewOrder order) {
        newOrderDao.update(order);
    }

    @Transactional(readOnly = false)
    public void cancelOrder(Integer orderID) {
        NewOrder order = newOrderDao.findByOrderID(orderID);
        //余额退回原账户
        CmUser user = cmUserDao.get(order.getUserID().toString());
        if (order.getBalancePayFee() > 0) {
            setBalance(user, order.getBalancePayFee(), order);
            //取消收支记录
            CmUserBalanceRecord cmUserBalanceRecord = new CmUserBalanceRecord();
            cmUserBalanceRecord.setUserId(order.getUserID());
            cmUserBalanceRecord.setOrderId(order.getOrderID());
            cmUserBalanceRecord.setRemark("取消订单，余额记录无效-后台");
            cmUserBalanceRecord.setDelFlag("1");
            cmUserBalanceRecordService.updateBalanceRecord(cmUserBalanceRecord);
        }
        order.setStatus("6");//订单状态变成交易关闭 6
        newOrderDao.updateStatus(order);
        //二手订单取消订单,标记未售
        if ("1".equals(order.getSecondHandOrderFlag())) {
            List<NewOrderProduct> orderProducts = newOrderProductDao.findListByOrderID(orderID);
            for (NewOrderProduct orderProduct : orderProducts) {
                cmSecondHandDetailDao.updatSecondHnadBySold(orderProduct.getProductID());
            }
        }
        //采美豆退回
        if (order.getUserBeans() != null && order.getUserBeans() > 0) {
            UserBeansHistory beansHistory = new UserBeansHistory();
            beansHistory.setUserId(order.getUserID());
            beansHistory.setOrderId(order.getOrderID());
            beansHistory.setBeansType(9);
            beansHistory.setType(1);
            beansHistory.setNum(order.getUserBeans());
            beansHistory.setPushStatus(0);
            beansHistory.setAddTime(new Date());
            newCmClubDao.insertBeansHistory(beansHistory);
            int userBeans = user.getUserBeans() + order.getUserBeans();
            cmUserDao.updateUserBeans(order.getUserID(), userBeans);
        }
        //取消订单短信推送
        try {
            if (user != null && StringUtils.isNotBlank(user.getBindMobile()) && "0".equals(order.getRebateFlag())) {
                String wwwServer = Global.getConfig("wwwServer");
                String shortLink = getShortLink(8, 11, wwwServer + "user/order/detail.html?orderId=" + orderID);
                String content = "您已成功取消订单（订单编号：" + order.getOrderNo() + "），订单金额￥" + order.getPayTotalFee() + "。您可关注采美公众号或者访问采美微信小程序和网站查看订单。" +
                        "平台公众号：微信搜索“采美365网”; 微信小程序：微信搜索“采美采购商城”；网址：www.caimei365.com/t/" + shortLink;
                boolean sendSms = getSendSms(11, user.getBindMobile(), content);
                if (!sendSms) {
                    logger.info("取消订单推送失败,订单id>>>>" + orderID);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        //客服确认注册机构,一天内取消有效
        if (user != null && "94".equals(user.getClubStatus())) {
            Integer userId = user.getUserID();
            Date confirmTime = cmUserDao.findByConfirmTime(userId);
            if (confirmTime != null) {
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(confirmTime);
                calendar.add(Calendar.DATE, 1);
                if (calendar.getTime().compareTo(new Date()) > 0) {
                    cmUserDao.updateByClubStatus(93, userId);
                    newCmClubDao.updateByStatus(93, userId);
                }
            }
        }
        //优惠券退回
        if (order.getCouponAmount() > 0 && !"0".equals(order.getStatus())) {
            CmCouponOrderRecord couponRecord = newOrderDao.findOrderCouponRecord(order.getOrderID());
            if (couponRecord != null) {
                CmCouponClub couponClub = cmCouponClubDao.get(couponRecord.getClubCouponId().toString());
                couponClub.setOrderId(null);
                couponClub.setReturnedId(0);
                couponClub.setSource("3");
                couponClub.setStatus("1");
                couponClub.setCreateDate(new Date());
                couponClub.setUseDate(null);
                couponClub.setDelFlag("0");
                cmCouponClubDao.insert(couponClub);
            }
        }
    }

    /**
     * @return
     * @Author ye.qin
     * @Description //TODO 设置余额
     * @Date 2019\6\20 0020 16:40
     * @Param
     */
    @Transactional(readOnly = false)
    public void setBalance(CmUser user, Double amount, NewOrder order) {
        if (UserType.isMaker(Integer.parseInt(user.getRegisterUserTypeID()))) {
            return;
        }
        if (UserType.isClub(Integer.parseInt(user.getRegisterUserTypeID()))) {
            user = cmUserDao.get(user.getCompanyUserID().toString());
        }
        String status = order.getStatus();//0待确认
        logger.info("----------------------->原余额：" + user.getUserMoney() + "==原可用余额：" + user.getAbleUserMoney());
        //减操作不更新可用余额
        if (amount < 0d) {
            if (!"0".equals(status)) {//待确认状态不需要修改余额，因为本身存在冻结余额不需要重复退回
                user.setUserMoney(user.getUserMoney() + amount);
            }
        } else {
            if (!"0".equals(status)) {//待确认状态不需要修改余额，因为本身存在冻结余额不需要重复退回
                user.setUserMoney(user.getUserMoney() + amount);
            }
            user.setAbleUserMoney(user.getAbleUserMoney() + amount);
        }
        logger.info("----------------------->设置余额：" + amount);
        logger.info("----------------------->当前余额：" + user.getUserMoney() + "==当前可用余额：" + user.getAbleUserMoney());
        cmUserDao.updateMoney(user);
    }

    /**
     * 发货
     *
     * @param deliveryData    子订单对应订单商品的Map{shopOrderID : [orderProductList], }
     * @param orderProducts   发货的订单商品集合
     * @param orderProductMap 发货的orderProductID 发货数量集合
     * @param logisticsInfo   物流公司单号MAP
     * @param remarks         备注
     */
    @Transactional(readOnly = false)
    public String delivery
    (Map<Integer, List<NewOrderProduct>> deliveryData, List<NewOrderProduct> orderProducts, Map<Integer, Integer> orderProductMap, Map<String, List<String>> logisticsInfo, String
            remarks, String remarkImage) throws Exception {
        //更新这一次发货的子订单信息
        Integer orderID = null;
        for (Map.Entry<Integer, List<NewOrderProduct>> entry : deliveryData.entrySet()) {
            NewShopOrder shopOrder = newShopOrderDao.get(entry.getKey() + "");
            Integer outStoreNum = shopOrder.getOutStoreNum();
            if (null == outStoreNum) {
                outStoreNum = 0;
            }
            int num = entry.getValue().stream().mapToInt(NewOrderProduct::getThisTimePostNum).sum();
            if (outStoreNum + num > (shopOrder.getItemCount() + shopOrder.getPresentNum())) {
                throw new Exception("发货数量异常");
            }
            shopOrder.setOutStoreNum(outStoreNum + num);//更新子订单总的出库数量
            if (shopOrder.getOutStoreNum() < shopOrder.getItemCount()) {
                //部分发货
                shopOrder.setSendOutStatus("2");
            } else {
                //发货完成 状态为待收货
                shopOrder.setSendOutStatus("3");
                // 子订单发货完成以后  计算系统自动收货时间
                long curTimeMills = System.currentTimeMillis();
                long autoCloseTimeMills = curTimeMills;
                NewOrderConfig cfg = newOrderConfigDao.getValueByKey(CmOrderConfigEnum.AUTO_RECEIPT_TIME.getCode());
                if (cfg == null || null == cfg.getValue() || cfg.getValue() == 0) {
                    autoCloseTimeMills = 0;
                } else {
                    autoCloseTimeMills += cfg.getValue() * 60 * 1000;
                }
                shopOrder.setAutoReceiveTimeMills(autoCloseTimeMills);
            }
            shopOrder.setSplitFlag("0");//发货以后拆单标识订单无法拆分
            shopOrder.setOutStoreTimes(shopOrder.getOutStoreTimes() + 1); //发货批次加一
            newShopOrderDao.update(shopOrder);
            orderID = shopOrder.getOrderID();
        }
        //同步更新主订单的发货状态
        NewOrder order = newOrderDao.findByOrderID(orderID);
        String sendOutStatus = order.getSendOutStatus();
        List<NewShopOrder> shopOrders = newShopOrderDao.findListByOrderID(order.getOrderID());

        String statusSuffix = "";
        if (shopOrders.stream().allMatch(s -> "3".equals(s.getSendOutStatus()))) {
            //所有的子订单都已经完成发货了
            statusSuffix = "3";
            order.setSendOutStatus("3");
        } else {
            //代码走到这里订单肯定是有发货了  整个订单里面的商品没有全部发完  那就是部分发货了
            statusSuffix = "2";
            order.setSendOutStatus("2");
        }
        if (order.getStatus().length() == 2) {
            order.setStatus(order.getStatus().substring(0, 1) + statusSuffix);
        } else {
            logger.info("=====> 主订单状态异常  ---- 发货方法中 ==" + order.getStatus());
            throw new Exception("主订单状态异常");
        }
        newOrderDao.update(order);
        //新增发货批次记录
        LogisticsBatch lb = new LogisticsBatch();
        lb.setShopOrderID(null); //5.0.0现在根据主订单去发货了
        lb.setOrderID(orderID);
        lb.setMailer("0");//邮寄者  0 采美   1 供应商  后台邮寄者为采美
        lb.setUpdateDate(new Date());
        lb.setDeliveryTime(new Date());
        lb.setRemark(remarks);
        lb.setRemarkImage(remarkImage);
        logisticsBatchDao.insert(lb);

        for (NewOrderProduct o : orderProducts) {
            newOrderProductDao.updateForDelivery(o);
            LogisticsRecord l = new LogisticsRecord();
            l.setLogisticsBatchID(Integer.valueOf(lb.getId()));
            l.setShopOrderID(o.getShopOrderID());
            l.setOrderID(o.getOrderID());
            l.setOrderProductID(o.getOrderProductID());
            l.setBuyNum(o.getNum());
            l.setNum(orderProductMap.get(o.getOrderProductID()));
            l.setProductID(o.getProductID());
            l.setProductName(o.getName());
            l.setImage(o.getImage());
            logisticsRecordDao.insert(l);
        }

        for (Map.Entry<String, List<String>> e : logisticsInfo.entrySet()) {
            for (String nu : e.getValue()) {
                LogisticsInformation l = new LogisticsInformation();
                l.setLogisticsBatchID(Integer.valueOf(lb.getId()));
                l.setType("");// 类型：1 采美365  2 呵呵商城 3 大宗采购 todo
                l.setShopOrderID(null);
                l.setOrderID(orderID);
                l.setNu(nu);
                /*
                 * 快递单当前的状态（0：在途，即货物处于运输过程中；
                 * 1：揽件，货物已由快递公司揽收并且产生了第一条跟踪信息；
                 * 2：疑难，货物寄送过程出了问题；
                 * 3：签收，收件人已签收；
                 * 4：退签，即货物由于用户拒签、超区等原因退回，而且发件人已经签收；
                 * 5：派件，即快递正在进行同城派件；
                 * 6：退回，货物正处于退回发件人的途中；）
                 */
                l.setState("1");
                l.setRemarks(remarks);
                String value = DictUtils.getDictValue(e.getKey(), "kd_type", ""); // 物流公司代码
                l.setLogisticsCompanyName(e.getKey());//物流公司名称
                l.setLogisticsCompanyCode(value);//物流公司代码
                l.setShopID(null);
                l.setShopOrderID(null);
                l.setUpdateDate(new Date());
                logisticsInformationDao.insert(l);
            }
        }

        try {
            //发货短信推送
            CmUser user = cmUserDao.get(order.getUserID().toString());
            if (user != null && StringUtils.isNotBlank(user.getBindMobile()) && "0".equals(order.getRebateFlag())) {
                String wwwServer = Global.getConfig("wwwServer");
                boolean sendSms = false;
                if ("2".equals(order.getSendOutStatus()) && "1".equals(sendOutStatus)) {
                    //部分发货
                    String shortLink = getShortLink(8, 7, wwwServer + "user/order/detail.html?orderId=" + order.getOrderID());
                    String content = "您的订单（订单编号：" + order.getOrderNo() + "）已部分发货。您可关注采美公众号或者访问采美微信小程序和网站查看订单。平台公众号：微信搜索“采美365网”; " +
                            "微信小程序：微信搜索“采美采购商城”；网址：www.caimei365.com/t/" + shortLink;
                    sendSms = getSendSms(7, user.getBindMobile(), content);
                } else if ("3".equals(order.getSendOutStatus())) {
                    //已发货
                    String shortLink = getShortLink(8, 8, wwwServer + "user/order/detail.html?orderId=" + order.getOrderID());
                    String content = "您的订单（订单编号：" + order.getOrderNo() + "）已发货完毕。您可关注采美公众号或者访问采美微信小程序和网站查看订单。平台公众号：微信搜索“采美365网”; " +
                            "微信小程序：微信搜索“采美采购商城”；网址：www.caimei365.com/t/" + shortLink;
                    sendSms = getSendSms(8, user.getBindMobile(), content);
                }
                if (!sendSms) {
                    logger.info("发货短信推送失败,订单id>>>>" + order.getOrderID());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return lb.getId();
    }

    /**
     * 手动拆单
     *
     * @param shopOrderID         拆分的子订单编号
     * @param oldOrderProductList 原有的orderProduct
     * @param newOrderProductList 拆单新增的orderProduct
     * @return 新拆分的子订单ID
     */
    @Transactional(readOnly = false)
    public Integer splitOrder(Integer shopOrderID, List<NewOrderProduct> oldOrderProductList, List<NewOrderProduct> newOrderProductList, List<NewCmFinanceReceipts> cfrBakList) throws BusinessException {
        NewShopOrder dbShopOrder = newShopOrderDao.get(shopOrderID + "");
        newShopOrderDao.shopOrderBak(newShopOrderDao.get(shopOrderID + "")); //子订单拆分前备份
        NewShopOrder newShopOrder = newShopOrderDao.get(shopOrderID + "");
        newShopOrder.setShopOrderID(null);
        newShopOrder.setShopID(1000);// shopID = 1000 数据库固定数据表示采美
        List<NewShopOrder> so = newShopOrderDao.findListByOrderID(dbShopOrder.getOrderID());
        int bigNum = 0; //记录最大子订单编号
        for (NewShopOrder s : so) {
            int shopOrderIndex = Integer.valueOf(s.getShopOrderNo().substring(s.getShopOrderNo().length() - 2));
            bigNum = bigNum < shopOrderIndex ? shopOrderIndex : bigNum;
        }
        if (dbShopOrder.getFee() == null || dbShopOrder.getFee().intValue() == -1) {
            newShopOrder.setFee(-1d); // 邮费到付
        } else {
            double fee = dbShopOrder.getFee() / 2;
            dbShopOrder.setFee(fee); // 订单拆分后 邮费均分
            newShopOrder.setFee(fee);
        }
        dbShopOrder.setSplitFlag("0");// 拆分后订单无法再次拆分
        newShopOrder.setSplitFlag("0");
        OrderUtil.updateShopOrderInfo(dbShopOrder, oldOrderProductList, null); // 根据拆分后的订单商品重新统计子订单信息
        newShopOrderDao.updateByShopOrderID(dbShopOrder);// 更新原来的子订单
        OrderUtil.updateShopOrderInfo(newShopOrder, newOrderProductList, null);
        newShopOrder.setShopOrderNo(OrderUtil.getshopOrderNo(dbShopOrder.getOrderNo(), ++bigNum));
        newShopOrderDao.insert(newShopOrder);// 插入新增的拆分订单
        String orderProductIDs = "";
        boolean flag = false;
        for (NewOrderProduct o : oldOrderProductList) {
            if ("1".equals(o.getDelFlag())) {
                newOrderProductDao.delete(o);
            } else {
                newOrderProductDao.update(o);
            }
        }
        for (NewOrderProduct n : newOrderProductList) {
            n.setShopOrderID(newShopOrder.getShopOrderID());
            n.setShopOrderNo(newShopOrder.getShopOrderNo());
            NewCmShop shop = newCmShopDao.get(String.valueOf(n.getShopID()));
            if (shop != null) {
                n.setShopName(shop.getName());
            }
            if (n.getLadderPriceFlag() == null) {
                n.setLadderPriceFlag(0);
            }
            newOrderProductDao.insert(n);
            orderProductIDs = orderProductIDs + ("," + n.getOrderProductID().toString());
        }
        List<NewShopOrder> shopOrderList = newShopOrderDao.findListByOrderID(dbShopOrder.getOrderID());
        boolean f = true;
        for (NewShopOrder s : shopOrderList) {
            if ("1".equals(s.getSplitFlag())) {
                f = false;
                break;
            }
        }
        NewOrder order = newOrderDao.findByOrderID(newShopOrder.getOrderID());
        if (f) {
            order.setSplitFlag("0");// 所有的子订单都已经拆单过 主订单 的拆单标识也要改变
        }
        String shopOrderIDs = "";
        for (int i = 0; i < shopOrderList.size(); i++) {
            if (i == shopOrderList.size() - 1) {
                shopOrderIDs = shopOrderIDs + shopOrderList.get(i).getShopOrderID();
            } else {
                shopOrderIDs += shopOrderList.get(i).getShopOrderID() + ",";
            }
        }
        order.setShopOrderIDs(shopOrderIDs);
        newOrderDao.update(order);
        return newShopOrder.getShopOrderID();
    }

    /**
     * 更新普通订单
     *
     * @param newOrder
     */
    @Transactional(readOnly = false)
    public void updateNormalOrder(NewOrder newOrder) {
        newOrder.setPayTotalFee(MathUtil.sub(newOrder.getOrderTotalFee(), newOrder.getBalancePayFee()).doubleValue());
        newOrderDao.update(newOrder);
        //采购中选中保存的订单商品
        List<NewOrderProduct> orderProducts = newOrder.getOrderProduct();
        //数据库中的订单商品
        NewOrderProduct newOrderProduct = new NewOrderProduct();
        newOrderProduct.setOrderID(newOrder.getOrderID());
        List<NewOrderProduct> dbOrderProducts = newOrderProductDao.findAllList(newOrderProduct);

        // 重新保存逻辑
        //把从页面上传过来的orderProduct   根据 shopID 来分组
        Map<Integer, List<NewOrderProduct>> orderProductMap = new HashMap<>();
        for (NewOrderProduct op : newOrder.getOrderProduct()) {
            if (orderProductMap.containsKey(op.getShopID())) {
                orderProductMap.get(op.getShopID()).add(op);
            } else {
                List<NewOrderProduct> l = new ArrayList<>();
                l.add(op);
                orderProductMap.put(op.getShopID(), l);
            }
        }
        // orderProduct 分组完成
        //开始更新shopOrder
        List<NewShopOrder> dbShopOrders = newShopOrderDao.findListByOrderID(newOrder.getOrderID());
        int shopOrderNoIndex = 0;  //记录子订单的最大编号 , 新添加的子订单编号一次往后增加
        //删除多余的shopOrder记录
        for (NewShopOrder s : dbShopOrders) {
            // 说明这个重新选择的orderProduct已经不包含这个供应商shopID的商品了
            if (!orderProductMap.containsKey(s.getShopID()))
                newShopOrderDao.delete(s);
            int shopOrderIndex = Integer.valueOf(s.getShopOrderNo().substring(s.getShopOrderNo().length() - 2));
            shopOrderNoIndex = shopOrderNoIndex < shopOrderIndex ? shopOrderIndex : shopOrderNoIndex;
        }
        //更新其余的shopOrder的信息
        A:
        for (Map.Entry<Integer, List<NewOrderProduct>> entry : orderProductMap.entrySet()) {
            for (NewShopOrder s : dbShopOrders) {
                if (s.getShopID().intValue() == entry.getKey().intValue()) {
                    OrderUtil.updateShopOrderInfo(s, entry.getValue(), null);
                    newShopOrderDao.update(s);
                    continue A;
                }
            }
            NewShopOrder newShopOrder = new NewShopOrder();
            OrderUtil.updateShopOrderInfo(newShopOrder, entry.getValue(), null);
            newShopOrder.setShopOrderNo(OrderUtil.getshopOrderNo(newOrder.getOrderNo(), ++shopOrderNoIndex));
            newShopOrder.setOrderNo(newOrder.getOrderNo());
            newShopOrder.setOrderID(newOrder.getOrderID());
            newShopOrder.setOutStoreNum(0);
            newShopOrderDao.insert(newShopOrder);
            for (NewOrderProduct product : orderProducts) {
                if (product.getShopID().intValue() == newShopOrder.getShopID().intValue()) {
                    product.setShopOrderID(newShopOrder.getShopOrderID());
                    product.setShopOrderNo(newShopOrder.getShopOrderNo());
                }
            }
        }

        List<NewShopOrder> shopOrders = newShopOrderDao.findListByOrderID(newOrder.getOrderID());
        Map<Integer, Integer> dbShopInfoID = new HashMap<>(); //用来存放数据库中这个订单原来的子订单中  供应商的信息 key = shopID value = shopOrderNo
        Map<Integer, String> dbShopInfoNo = new HashMap<>(); //用来存放数据库中这个订单原来的子订单中  供应商的信息 key = shopID value = shopOrderID
        for (NewShopOrder so : shopOrders) {
            dbShopInfoID.put(so.getShopID(), so.getShopOrderID());
            dbShopInfoNo.put(so.getShopID(), so.getShopOrderNo());
        }
        if (CollectionUtils.isNotEmpty(orderProducts)) {
            for (NewOrderProduct product : orderProducts) {
                if (product.getLadderPriceFlag() == null) {
                    product.setLadderPriceFlag(0);
                }
                if (product.getOrderProductID() == null) {//新增：表单订单商品ID为空
                    product.setOrderNo(newOrder.getOrderNo());
                    product.setOrderID(newOrder.getOrderID());
                    if (dbShopInfoID.containsKey(product.getShopID())) {
                        //数据库子订单中包含了这个供应商 就不需要添加子订单
                        product.setShopOrderID(dbShopInfoID.get(product.getShopID()));
                        product.setShopOrderNo(dbShopInfoNo.get(product.getShopID()));
                    }
                    newOrderProductDao.insert(product);
                } else {//修改：表单所有ID不为空的修改
                    if (CollectionUtils.isNotEmpty(dbOrderProducts)) {
                        for (NewOrderProduct dbProduct : dbOrderProducts) {
                            if (StringUtils.equals(dbProduct.getId(), product.getId())) {
                                product.setOrderID(newOrder.getOrderID());
                                newOrderProductDao.update(product);
                            }
                        }
                    }
                }
            }
        }
        //删除
        if (CollectionUtils.isNotEmpty(orderProducts)) {
            for (NewOrderProduct dbProduct : dbOrderProducts) {
                boolean b = true;//删除
                for (NewOrderProduct product : orderProducts) {
                    if (dbProduct.getProductID().intValue() == product.getProductID().intValue()) {
                        b = false;//不删除
                        break;
                    }
                }
                //删除：数据库有，表单没有的
                if (b) {
                    dbProduct.setDelFlag(DateUtils.formatDate(new Date(), "yyyyMMddHHmmssSSSS"));
                    newOrderProductDao.delete(dbProduct);
                }
            }
        }
    }

    @Transactional(readOnly = false)
    public void deleteOrder(NewOrder order) {
        order.setDelFlag("1");
        newOrderDao.update(order);
        if (order.getNewShopOrders() == null) return;
        for (NewShopOrder so : order.getNewShopOrders()) {
            so.setDelFlag("1");
            newShopOrderDao.update(so);
        }
    }

    @Transactional(readOnly = false)
    public void updateOrderStatus(String orderId, String orderStatus) {
        newShopOrderDao.updateOrderStatus(orderId, orderStatus);
    }

    @Override
    public Page<NewOrder> findPage(Page<NewOrder> page, NewOrder entity) {
        Page<NewOrder> pageResult = super.findPage(page, entity);
        List<NewOrder> results = pageResult.getList();
        List<Integer> oId = results.stream().map(NewOrder::getOrderID).collect(Collectors.toList());
        //看看这些订单有哪些是返佣订单 返回他们的orderID
        List<Integer> orderIds = null;
        if (CollectionUtils.isNotEmpty(oId)) {
            orderIds = cmDiscernReceiptDao.findRebateOrderID(results.stream().map(NewOrder::getOrderID).collect(Collectors.toList()));
        }
        //从查询到的订单列表中 找到正在退款中的订单集合
        List<Integer> orderIdsInReturn = null;
        List<Integer> orderIdsInApplyReturn = null;//查询可以申请退款的订单ID
        if (CollectionUtils.isNotEmpty(oId)) {
            orderIdsInReturn = cmReturnedPurchaseDao.findOrderIDInReturnPurchase(oId);
            orderIdsInApplyReturn = cmReturnedPurchaseDao.findOrderIDsInApplyReturnFlag(oId);
        }
        for (NewOrder order : results) {
            CmUser user = cmUserDao.get(order.getUserID().toString());
            Double ableUserMoney = user.getAbleUserMoney() == null ? 0d : user.getAbleUserMoney();
            order.setAbleUserMoney(ableUserMoney);
            if ((orderIds != null && orderIds.contains(order.getOrderID())) || "1".equals(order.getRebateFlag())) {
                order.setRebateOrder("1");
            } else {
                order.setRebateOrder("0");
                List<Integer> ids = cmReceiptOrderRelationDao.toAudit(order.getOrderID());
                if (ids != null && ids.size() > 0) {
                    order.setToAudit("1");
                }
            }
            if (orderIdsInReturn != null && orderIdsInReturn.contains(order.getOrderID())) {
                order.setReturnedPurchaseStatus("1");
            } else {
                order.setReturnedPurchaseStatus("0");
            }
            if (orderIdsInApplyReturn != null && orderIdsInApplyReturn.contains(order.getOrderID())) {
                order.setApplyReturnedPurchaseFlag("0");
            } else {
                order.setApplyReturnedPurchaseFlag("1");
            }

            List<NewShopOrder> shopOrders = order.getNewShopOrders();
            if (shopOrders != null && shopOrders.size() == 1) {
                order.setShopName(shopOrders.get(0).getShopName());
            }
            int count = 0;
            for (NewShopOrder shopOrder : order.getNewShopOrders()) {
                shopOrder.setOrderID(order.getOrderID());
                shopOrder.setOrderNo(order.getOrderNo());
                shopOrder.setOrderType(Integer.parseInt(order.getOrderType()));
                shopOrder.setReceiver(order.getReceiver());
                shopOrder.setOrderSource(order.getOrderSource());
                shopOrder.setOrderTime(order.getOrderTime());
                shopOrder.setBuyer(order.getBuyer());
                if (shopOrder.getShopID() != 998) {
                    count++;
                }

                Integer shopOrderID = shopOrder.getShopOrderID();//子订单ID
                //通过子订单ID查询子订单信息
                NewShopOrder newShopOrder = newShopOrderDao.get(String.valueOf(shopOrderID));
                if (null != newShopOrder) {
                    shopOrder.setFee(newShopOrder.getFee());
                    shopOrder.setShouldPayProduct(newShopOrder.getShouldPayProduct());
                    List<NewOrderProduct> pList = newOrderProductDao.findListByShopOrderID(shopOrderID);
                    pList.forEach(orderProduct -> {
                        //充值定金商品
                        if (6060 == orderProduct.getProductID()) {
                            order.setRechargeGoods(1);
                        }
                    });
                } else {
                    shopOrder.setFee(0d);
                    shopOrder.setShouldPayProduct(0d);
                }
            }
            //一个子订单只有一个商品时,不可拆分
            if (order.getProductCount() == null) {
                order.setProductCount(1);
            }
            if (order.getProductCount() <= count) {
                order.setSplitFlag("0");
            }

            //是否抹平支付过（抹平最多只允许存在一次）
            CmDiscernReceipt cmDiscernReceipt = cmDiscernReceiptDao.findSmoothoutInfo(order.getOrderID().toString());
            if (null != cmDiscernReceipt) {
                order.setAssociationType(cmDiscernReceipt.getAssociationType());
                String confirmType = cmDiscernReceipt.getConfirmType();
                order.setConfirmType(confirmType);

                // 是否是一比款收了多个订单
                if (StringUtils.equals(confirmType, "1") || StringUtils.equals(confirmType, "2") || StringUtils.equals(confirmType, "3")) {
                    List<CmReceiptOrderRelation> byReceiptList = cmReceiptOrderRelationService.findByReceiptID(cmDiscernReceipt.getId());
                    if (CollectionUtils.isNotEmpty(byReceiptList) && byReceiptList.size() > 1) {
                        order.setReceiptOrderFlag(true);
                    }
                }
            }

            // 订单已收款才会出现抹平或者多收退余额，（已收再退款或者撤销退款订单即使存在抹平也需要当未抹平重新计算付款）
            //            抹平明细
            String receiptStatus = order.getReceiptStatus();
            if (StringUtils.equals("3", receiptStatus)) {
                if (null != cmDiscernReceipt) {
                    String confirmType = cmDiscernReceipt.getConfirmType();
                    order.setConfirmType(confirmType);
                    double associateAmount = cmDiscernReceiptDao.getAssociateAmount(String.valueOf(order.getOrderID()));
                    order.setOrderReceivedAmount(associateAmount);
                    //大额退余额
                    if (StringUtils.equals("3", confirmType)) {
                        String id = cmDiscernReceipt.getId();
                        double returnBalanceAmount = cmDiscernReceiptDao.getReturnBalanceAmount(id);
                        order.setReturnBalanceAmount(returnBalanceAmount);
                    }
                }
            }
        }
        return pageResult;
    }

    /**
     * 判断是否是游客
     *
     * @param userId
     * @return
     */
    public boolean isVisitor(String userId) {
        if (userId == null) {
            return true;
        }
        CmUser user = cmUserDao.get(userId);
        //会所权限（会所企业、经理、员工等没上线或没审核）、普通权限（游客、系统普通用户）用户都可能存在游客价格显示
        Integer permission = UserUtils.userPermission(user);//查看用户权限类型0 未登录身份 游客身份 1 登录普通用户身份  2 登录会所身份  4 登录协销身份
        if (permission == 0 || permission == 1) {
            List<CmShopOrder> userPayOrder = cmUserDao.getUserPayOrder(user.getUserID());
            if (!org.springframework.util.CollectionUtils.isEmpty(userPayOrder) && userPayOrder.size() > 0) {
                //用户存在已支付的订单（不为游客）
                return false;
            } else {
                //用户没有已付款完成的订单（游客）
                return true;
            }
        } else {
            return false;//非游客价
        }
    }

    @Transactional(readOnly = false)
    public void postageOrderSave(NewOrder newOrder) {
        //后台添加订单状态为0；待确认
        if (StringUtils.isEmpty(newOrder.getStatus())) {
            newOrder.setStatus("13");
        }
        //后台添加订单订单提交类型；后台提交4
        if (StringUtils.isEmpty(newOrder.getOrderSubmitType())) {
            newOrder.setOrderSubmitType("4");
        }
        //如果是[5:外单]类型则订单状态直接为交易完成
        if (StringUtils.equals("5", newOrder.getOrderSource())) {
            newOrder.setConfirmFlag("1");//标记为确认订单
        }
        if (newOrder.getOrderID() == null) {
            //  lwt  订单的下单时间和单号 都再订单保存后再展示
            newOrder.setOrderNo(OrderUtil.geneAdminOrderNo());
            newOrder.setOrderTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            newOrder.setOrderType("0"); // 订单类型 协销订单 0 普通订单 1
            newOrder.setOrderSubmitType("4");
            newOrder.setSplitFlag("0"); //订单不可拆分
        }
        newOrder.setClauseContent("");
        newOrder.setClauseName("");
        newOrder.setFreePostFlag("1");
        newOrder.setPostageOrderFlag("1");
        newOrder.setSendOutStatus("3");
        newOrder.setPayStatus("3");
        newOrder.setReceiptStatus("1");
        boolean flag = false;//是否新增标志
        if (newOrder.getOrderID() == null) {
            flag = true;
            newOrder.setOrderNo(OrderUtil.geneAdminOrderNo());
        }
        if (null == newOrder.getDiscountFee()) {//设置折扣
            newOrder.setDiscountFee(0d);
        }
        if (null == newOrder.getBalancePayFee()) {//设置余额
            newOrder.setBalancePayFee(0d);
        }
        if (newOrder.getPayFlag() == null) {//设置付款标识
            newOrder.setPayFlag("0");
        }
        if (newOrder.getHasActProduct() == null) {
            newOrder.setHasActProduct("0");
        }
        if (newOrder.getOnlinePayFlag() == null) {
            newOrder.setOnlinePayFlag("0");
        }
        if (!StringUtils.equals("1", newOrder.getConfirmFlag())) {
            newOrder.setConfirmFlag("0");
        }
        // 协销订单设置会所信息
        if (newOrder.getBpOrderUserinfo() != null && newOrder.getBpOrderUserinfo().getClubId() != null) {
            newOrder.setClubID(newOrder.getBpOrderUserinfo().getClubId().intValue());
            NewCmClub club = newCmClubDao.get(newOrder.getBpOrderUserinfo().getClubId().toString());
            if (null != club) {
                newOrder.setUserID(club.getUserID());
            }
        }
        newOrder.setPreferential(0D);
        newOrder.setProductTotalFee(newOrder.getFreight());
        newOrder.setOrderTotalFee(newOrder.getFreight());
        newOrder.setPayTotalFee(newOrder.getFreight());
        newOrder.setPayableAmount(newOrder.getFreight());
        newOrder.setDiscountFee(0D);
        newOrder.setBalancePayFee(0D);
        if (newOrder.getOrderID() == null) {
            newOrderDao.insert(newOrder);
        } else {
            newOrderDao.update(newOrder);
        }
        OrderUserInfo orderUserInfo = newOrder.getBpOrderUserinfo();
        if (flag) {//新增
            orderUserInfo.setOrderId(Long.valueOf(newOrder.getOrderID()));
        }
        orderUserInfoService.saveWithcity(orderUserInfo);
        //如果不包邮 增加运费商品子订单（先删除掉相关订单和订单商品）运费商品ID 999
        Integer freightProductID = 999;
        NewShopOrder freightShopOrder = new NewShopOrder();
        NewOrderProduct freightOrderProduct = new NewOrderProduct();
        //根据主订单号和运费商品查出订单商品
        List<NewOrderProduct> freightOrderProductList = newOrderProductDao.findFreightOrderProductList(newOrder.getOrderID(), freightProductID);
        for (NewOrderProduct bean : freightOrderProductList) {
            freightShopOrder.setShopOrderID(bean.getShopOrderID());
            freightOrderProduct.setOrderProductID(bean.getOrderProductID());
            newShopOrderDao.delete(freightShopOrder);
            newOrderProductDao.delete(freightOrderProduct);
        }
        if (newOrder.getFreePostFlag() != null && newOrder.getFreePostFlag().equals("1")) {
            setFreightShopOrder(newOrder);
        }
        List<NewShopOrder> shopOrders = newShopOrderDao.findListByOrderID(newOrder.getOrderID());
        String shopOrderIDs = "";
        for (int i = 0; i < shopOrders.size(); i++) {
            if (i == shopOrders.size() - 1) {
                shopOrderIDs = shopOrderIDs + shopOrders.get(i).getShopOrderID();
            } else {
                shopOrderIDs = shopOrderIDs + shopOrders.get(i).getShopOrderID() + ",";
            }
        }
        newOrder.setShopOrderIDs(shopOrderIDs);
        newOrderDao.update(newOrder);
    }

    public NewOrder editDiscountFee(NewOrder newOrder) {
        NewOrder order = newOrderDao.get(String.valueOf(newOrder.getOrderID()));
        return order;
    }

    @Transactional(readOnly = false)
    public void saveDiscountFee(NewOrder newOrder) {
        NewOrder order = newOrderDao.get(String.valueOf(newOrder.getOrderID()));
        newOrder.setPayTotalFee(order.getPayTotalFee() + order.getDiscountFee() - newOrder.getDiscountFee());
        newOrder.setPayableAmount(order.getPayableAmount() + order.getDiscountFee() - newOrder.getDiscountFee());
        newOrder.setDiscountFee(newOrder.getDiscountFee());
        newOrderDao.update(newOrder);
    }

    public Map<String, Object> shopOrderLink(Integer shopOrderId) {
        Map<String, Object> map = new HashMap<>();
        //小程序信息
        String appId = "wxf3cd4ae0cdd11c36";
        String appSecret = "f5707c40c07adf0e2110c58ce6a4f4b3";
        String link = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET";
        link = link.replace("APPID", appId).replace("APPSECRET", appSecret);
        String result = "";
        try {
            result = HttpRequest.sendGet(link);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Map<String, Object> objectMap = JSON.parseObject(result, Map.class);
        Integer errcode = (Integer) objectMap.get("errcode");
        if (null != errcode && 0 != errcode) {
            String errmsg = (String) objectMap.get("errmsg");
            map.put("success", false);
            map.put("msg", errmsg);
        }
        String access_token = (String) objectMap.get("access_token");
        String requestUrl = "https://api.weixin.qq.com/wxa/getwxacodeunlimit?access_token=" + access_token;
        try {
            JSONObject paramJson = new JSONObject();
            paramJson.put("scene", shopOrderId);
            paramJson.put("page", "pages/supplier/login/share-info");
            paramJson.put("width", "280px");
            byte[] bytes = HttpClientUtils.post(requestUrl, paramJson.toJSONString());
            String encode = DatatypeConverter.printBase64Binary(bytes);
            map.put("success", true);
            map.put("imageBuffer", encode);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }

    public Map<String, Object> gatheringData(Integer orderId) {
        Map<String, Object> map = new HashMap<>();
        map.put("success", true);
        NewOrder order = newOrderDao.get(orderId.toString());
        //订单金额
        map.put("payTotalFee", order.getPayTotalFee());
        //应付金额
        map.put("payableAmount", order.getPayableAmount());
        //余额抵扣
        map.put("balancePayFee", order.getBalancePayFee());
        //已收款
        double associateAmount = cmDiscernReceiptDao.getAssociateAmount(orderId.toString());
        map.put("associateAmount", associateAmount);
        CmDiscernReceipt cmDiscernReceipt = cmDiscernReceiptDao.findSmoothoutInfo(order.getOrderID().toString());
        if (null != cmDiscernReceipt) {
            //抹平备注
            map.put("balanceAccountsRemark", cmDiscernReceipt.getBalanceAccountsRemark());
        }
        return map;
    }

    @Transactional(readOnly = false)
    public void smoothOutCollection(CmDiscernReceipt discernReceipt) {
        NewOrder order = newOrderDao.get(discernReceipt.getOrderID());
        order.setReceiptStatus("3");
        if ("21".equals(order.getStatus())) {
            order.setStatus("31");
        } else if ("22".equals(order.getStatus())) {
            order.setStatus("32");
        } else {
            order.setStatus("33");
        }
        newOrderDao.update(order);
        CmDiscernReceipt cmDiscernReceipt = cmDiscernReceiptDao.findDiscernReceipt(discernReceipt.getOrderID());
        //已收款金额
        double associateAmount = cmDiscernReceiptDao.getAssociateAmount(discernReceipt.getOrderID());
        if (order.getPayableAmount() > associateAmount) {
            //小额抹平确认
            cmDiscernReceipt.setConfirmType("1");
        } else {
            //大额抹平确认
            cmDiscernReceipt.setConfirmType("2");
        }
        cmDiscernReceipt.setBalanceAccountsRemark(discernReceipt.getBalanceAccountsRemark());
        cmDiscernReceiptDao.update(cmDiscernReceipt);
    }

    @Transactional(readOnly = false)
    public void balanceDeduction(Integer orderID) {
        NewOrder order = newOrderDao.findByOrderID(orderID);
        CmUser user = cmUserDao.get(order.getUserID().toString());
        //已付金额
        Double amountPaid = cmReceiptOrderRelationDao.findPayFeeByOrderID(orderID.toString());
        BigDecimal pendingPayments = MathUtil.sub(order.getPayTotalFee(), amountPaid);
        if (MathUtil.compare(user.getAbleUserMoney(), 0) > 0) {
            //本次余额支付金额
            BigDecimal balancePayFee = BigDecimal.ZERO;
            if (MathUtil.compare(user.getAbleUserMoney(), pendingPayments) < 0) {
                if ("1".equals(order.getSendOutStatus())) {
                    order.setStatus("21");
                } else if ("2".equals(order.getSendOutStatus())) {
                    order.setStatus("22");
                } else {
                    order.setStatus("23");
                }
                order.setReceiptStatus("2");
                balancePayFee = BigDecimal.valueOf(user.getAbleUserMoney());
            } else {
                if (!"0".equals(order.getStatus())) {
                    if ("1".equals(order.getSendOutStatus())) {
                        order.setStatus("31");
                    } else if ("2".equals(order.getSendOutStatus())) {
                        order.setStatus("32");
                    } else {
                        order.setStatus("33");
                    }
                }
                order.setReceiptStatus("3");
                balancePayFee = pendingPayments;
            }
            order.setBalancePayFee(MathUtil.add(order.getBalancePayFee(), balancePayFee).doubleValue());
            order.setPayableAmount(MathUtil.sub(order.getPayableAmount(), balancePayFee).doubleValue());
            newOrderDao.update(order);
            //修改账户余额
            user.setUserMoney(MathUtil.sub(user.getUserMoney(), balancePayFee).doubleValue());
            //保存收款记录
            saveDiscernReceipt(balancePayFee.doubleValue(), orderID);
            user.setAbleUserMoney(MathUtil.sub(user.getAbleUserMoney(), balancePayFee).doubleValue());
            cmUserDao.updateMoney(user);
            //保存余额收支记录
            CmUserBalanceRecord cmUserBalanceRecord = new CmUserBalanceRecord();
            cmUserBalanceRecord.setUserId(order.getUserID());
            cmUserBalanceRecord.setType("2");
            cmUserBalanceRecord.setBalanceType("1");
            cmUserBalanceRecord.setAddDate(new Date());
            cmUserBalanceRecord.setAmount(String.valueOf(balancePayFee));
            cmUserBalanceRecord.setOrderId(order.getOrderID());
            cmUserBalanceRecord.setDelFlag("0");
            cmUserBalanceRecordService.insertUserBalanceRecord(cmUserBalanceRecord);
        }
    }

    /**
     * 更新付款状态和0成本标识
     *
     * @param newOrder
     */
    @Transactional(readOnly = false)
    public void updatePayStatus(NewOrder newOrder) {
        newOrderDao.updateOrderStatus(newOrder);
    }

    /**
     * 获取上线协销人员，排除采美默认协销经理
     *
     * @return NewCmSp
     */
    public List<NewCmSp> findServiceProviderList() {
        return newOrderDao.findServiceProviderList();
    }

    @Transactional(readOnly = false)
    public void modifyRebate(Integer orderId) {
        newOrderDao.updateByRebateFlag(orderId);
    }

    public List<LogisticsRecord> qualificationList(Integer logisticsBatchId) {
        List<LogisticsRecord> logisticsRecords = logisticsRecordDao.findByLogisticsBatchID(logisticsBatchId);
        String wwwServer = Global.getConfig("wwwServer");
        logisticsRecords.forEach(item -> {
            item.setImage(AppUtils.getImageURL("product", item.getImage(), 0, wwwServer));
            List<CmFile> fileList = newOrderDao.findQualificationFile(item.getId());
            if (fileList != null && fileList.size() > 0) {
                item.setIsFile(true);
            }
        });
        return logisticsRecords;
    }

    public LogisticsRecord qualificationForm(Integer recordId) {
        LogisticsRecord logisticsRecord = logisticsRecordDao.findByRecordId(recordId);
        List<CmFile> fileList = newOrderDao.findQualificationFile(String.valueOf(recordId));
        logisticsRecord.setFileList(fileList);
        List<String> images = newOrderDao.findQualificationImage(recordId);
        logisticsRecord.setImageList(images);
        return logisticsRecord;
    }

    @Transactional(readOnly = false)
    public void saveQualification(LogisticsRecord logisticsRecord) {
        logisticsRecordDao.updateLogisticsRecord(logisticsRecord);
        //商品资质图片
        String[] images = logisticsRecord.getImages();
        newOrderDao.deleteQualificationImage(logisticsRecord.getRecordId());
        if (images != null && images.length > 0) {
            for (String image : images) {
                if (StringUtils.isNotBlank(image)) {
                    image = UploadPicUtils.saveImageToServer(image);
                    newOrderDao.insertQualificationImage(logisticsRecord.getRecordId(), image);
                }
            }
        }
        //商品资质文件
        String[] files = logisticsRecord.getFiles();
        newOrderDao.deleteQualificationFile(logisticsRecord.getRecordId());
        if (files != null && files.length > 0) {
            for (String file : files) {
                if (StringUtils.isNotBlank(file)) {
                    String[] split = file.split("---");
                    String fileName = split[0];
                    String ossName = split[1];
                    newOrderDao.insertQualificationFile(logisticsRecord.getRecordId(), fileName, ossName);
                }
            }
        }
    }

    public List<LogisticsRecord> qualificationInfo(Integer logisticsBatchId) {
        List<LogisticsRecord> logisticsRecords = logisticsRecordDao.findByLogisticsBatchID(logisticsBatchId);
        String wwwServer = Global.getConfig("wwwServer");
        Iterator<LogisticsRecord> iterator = logisticsRecords.iterator();
        while (iterator.hasNext()) {
            LogisticsRecord item = iterator.next();
            item.setImage(AppUtils.getImageURL("product", item.getImage(), 0, wwwServer));
            List<CmFile> fileList = newOrderDao.findQualificationFile(item.getId());
            item.setFileList(fileList);
            List<String> images = newOrderDao.findQualificationImage(item.getRecordId());
            item.setImageList(images);
            boolean isFile = (fileList == null || fileList.size() == 0);
            boolean isImage = (images == null || images.size() == 0);
            if (StringUtils.isBlank(item.getSn()) && isFile && isImage) {
                iterator.remove();
            }
        }
        return logisticsRecords;
    }

    public Map<String, Object> clubCouponList(Integer userId) {
        Map<String, Object> map = new HashMap<>();
        map.put("code", 0);
        List<CmCoupon> couponList = cmCouponDao.findClubCouponList(userId);
        cmCouponService.setCouponCopywriting(couponList);
        map.put("couponList", couponList);
        return map;
    }

    @Transactional(readOnly = false)
    public Boolean updateClubCoupon(Integer clubCouponId, Integer orderId) {
        CmCoupon coupon = newOrderDao.findClubCouponById(clubCouponId);
        if (coupon == null) {
            return false;
        }
        cmCouponDao.updateClubCoupon(clubCouponId, orderId);
        return true;
    }
}