kmall-haikong/kmall-admin/src/main/java/com/kmall/admin/service/impl/OrderServiceImpl.java

package com.kmall.admin.service.impl;

import cn.hutool.core.lang.UUID;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.type.TypeReference;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.Maps;
import com.google.gson.Gson;
import com.google.gson.internal.LinkedTreeMap;
import com.kmall.admin.cuspay.biz.ali.AliCusDeclareBiz;
import com.kmall.admin.cuspay.biz.wx.WxCusDeclareBiz;
import com.kmall.admin.dao.*;
import com.kmall.admin.dao.alarm.Mall2LowPriceWarningDao;
import com.kmall.admin.dao.mk.Mk2GoodsTopicPriceDao;
import com.kmall.admin.dao.mk.Mk2MemberBirthdayDao;
import com.kmall.admin.dao.mk.store.MkStorePromOrderRealDao;
import com.kmall.admin.dao.mk.store.MkStorePromTypeDao;
import com.kmall.admin.dao.mk.store.StoreTopicDao;
import com.kmall.admin.dao.vip.Mall2MemberConsumptionRecordsDao;
import com.kmall.admin.dao.vip.Mall2MemberPointsDao;
import com.kmall.admin.dao.vip.Mall2PointsRulesDao;
import com.kmall.admin.dto.*;
import com.kmall.admin.entity.*;
import com.kmall.admin.entity.haikong.*;
import com.kmall.admin.entity.mk.MkActivitiesEntity;
import com.kmall.admin.entity.mk.MkActivitiesScoreEntity;
import com.kmall.admin.entity.mk.store.MkStorePromOrderRealEntity;
import com.kmall.admin.entity.record.NewRetailOrderRestoreStockRecordEntity;
import com.kmall.admin.entity.vip.Mall2MemberConsumptionRecordsEntity;
import com.kmall.admin.entity.vip.Mall2MemberPointsEntity;
import com.kmall.admin.entity.vip.Mall2PointsRulesEntity;
import com.kmall.admin.fromcomm.dao.SysConfigDao;
import com.kmall.admin.fromcomm.entity.SysUserEntity;
import com.kmall.admin.haikong.constant.*;
import com.kmall.admin.haikong.dto.*;
import com.kmall.admin.haikong.utils.ListUtils;
import com.kmall.admin.haikong.vo.*;
import com.kmall.admin.haikong.client.HaiKongMemberTemplate;
import com.kmall.admin.haikong.client.HaiKongWarehouseTemplate;
import com.kmall.admin.haikong.client.VmcShopTemplate;
import com.kmall.admin.haikong.config.HaiKongProperties;
import com.kmall.admin.haikong.utils.Response;
import com.kmall.admin.service.*;
import com.kmall.admin.service.haikong.*;
import com.kmall.admin.service.mk.MkActivitiesScoreService;
import com.kmall.admin.service.mk.MkActivitiesService;
import com.kmall.admin.service.mk.store.MkStoreCampMinusService;
import com.kmall.admin.service.mk.store.MkStoreTicketDiscountService;
import com.kmall.admin.service.record.NewRetailOrderRestoreStockRecordService;
import com.kmall.admin.service.vip.Mall2PointsRulesService;
import com.kmall.admin.utils.CalculateTax;
import com.kmall.admin.utils.ShiroUtils;
import com.kmall.admin.utils.data.response.ResponseMessage;
import com.kmall.admin.utils.data.response.ResponseMessageData;
import com.kmall.admin.utils.jackson.JacksonUtil;
import com.kmall.admin.utils.oms.OmsSign;
import com.kmall.admin.utils.pdf.BarcodeUtil;
import com.kmall.admin.websocket.WebSocketServer;
import com.kmall.api.entity.OrderGoodsRestoreVo;
import com.kmall.api.entity.OrderGoodsVo;
import com.kmall.api.entity.OrderVo;
import com.kmall.api.util.CommonUtil;
import com.kmall.common.constant.Dict;
import com.kmall.common.utils.*;
import com.kmall.common.utils.print.ticket.item.*;
import com.kmall.common.utils.wechat.WechatMicropayApiResult;
import com.kmall.common.utils.wechat.WechatRefundApiResult;
import com.kmall.common.utils.wechat.WechatReverseApiResult;
import com.kmall.manager.manager.alipay.AliPayMicropayApiResult;
import com.kmall.manager.manager.alipay.AliPayRequestParams;
import com.kmall.manager.manager.alipay.AliPayUtil;
import com.kmall.manager.manager.dto.PayOriginInfoDTO;
import com.kmall.manager.manager.express.kdn.KdniaoUtil;
import com.kmall.manager.manager.express.sf.ServiceException;
import com.kmall.manager.manager.express.sf.entity.RouteEntity;
import com.kmall.manager.manager.express.sf.entity.RouteResponseEntity;
import com.kmall.manager.manager.express.sf.entity.SfRouteServiceResponseEntity;
import com.kmall.manager.manager.express.sf.properties.SFPropertiesBuilder;
import com.kmall.manager.manager.express.sf.properties.SFUtil;
import com.kmall.manager.manager.merch.OmsMerchProperties;
import com.kmall.manager.manager.merch.OmsMerchPropertiesBuilder;
import com.kmall.manager.manager.print.ticket.PrintTicketPropertiesBuilder;
import com.kmall.manager.manager.print.ticket.TicketPrintUtil;
import com.kmall.manager.manager.redis.JedisUtil;
import com.kmall.manager.manager.wechat.WechatUtil;
import com.kmall.manager.manager.wechat.wxglobal.dto.WechatGlobalRefundApiResult;
import okhttp3.Request;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.net.InetAddress;
import java.net.URLDecoder;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;
import java.util.stream.Collectors;


@Service("orderService")
public class OrderServiceImpl implements OrderService {

    private final Logger LOGGER = LoggerFactory.getLogger(OrderServiceImpl.class);

    @Autowired
    private OmsMerchProperties omsMerchProperties;

    @Autowired
    private OrderDao orderDao;
    @Autowired
    private ShippingDao shippingDao;
    @Autowired
    private OrderGoodsDao orderGoodsDao;
    @Autowired
    private OrderGoodsService orderGoodsService;
    @Autowired
    private ProductStoreRelaService productStoreRelaService;
    @Autowired
    private NewRetailOrderRestoreStockRecordService newRetailOrderRestoreStockRecordService;
    @Autowired
    private SysPrinterDao printerDao;
    @Autowired
    private UserDao userDao;
    @Autowired
    private UserCouponDao userCouponDao;
    @Autowired
    private ProductStoreRelaDao productStoreRelaDao;
    @Autowired
    private OrderProcessRecordDao orderProcessRecordDao;
    @Autowired
    private OrderRefundDao orderRefundDao;
    @Autowired
    private StoreDao storeDao;
    @Autowired
    private OfflineCartDao offlineCartDao;
    @Autowired
    private GoodsDao goodsDao;
    @Autowired
    private MerchDao merchDao;
    @Autowired
    private MngChangeDao mngChangeDao;
    @Autowired
    private StoreMngChangeDao storeMngChangeDao;
    @Autowired
    private ThirdMerchExpressDao thirdMerchExpressDao;
    @Autowired
    private MkStorePromOrderRealDao mkStorePromOrderRealDao;
    @Autowired
    private UserCampMinusDao userCampMinusDao;
    @Autowired
    private UserService userService;
    @Autowired
    private SysConfigDao sysConfigDao;
    @Autowired
    private ProductDao productDao;
    @Autowired
    private GoodsService goodsService;

    @Autowired
    private OrderWXPayRecordService orderWXPayRecordService;
    @Autowired
    private StoreService storeService;
    @Autowired
    private PickUpCodeService pickUpCodeService;
    @Autowired
    private MkStoreCampMinusService mkStoreCampMinusService;
    @Autowired
    private MkStoreTicketDiscountService mkStoreTicketDiscountService;

    @Autowired
    private CashierDao cashierDao; // 收银机查询
    @Autowired
    private CashierLoginRecordDao cashierLoginRecordDao; // 收银员登录记录
    @Autowired
    private SaleRecordDao saleRecordDao; // 销售记录
    @Autowired
    private StoreTopicDao storeTopicDao; // 查询是否有门店活动
    @Autowired
    private Mk2GoodsTopicPriceDao mk2GoodsTopicPriceDao; // 门店商品价格
    @Autowired
    private Mall2PointsRulesDao pointsRulesDao; // 积分规则
    @Autowired
    private Mall2PointsRulesService mall2PointsRulesService;
    @Autowired
    private Mall2MemberPointsDao memberPointsDao; // 用户积分
    @Autowired
    private Mall2MemberConsumptionRecordsDao memberConsumptionRecordsDao; // 会员消费记录
    @Autowired
    private MkStorePromTypeDao storePromTypeDao; // 优惠类型
    @Autowired
    private Mk2MemberBirthdayDao memberBirthdayDao; // 生日优惠
    @Autowired
    private MerchUserDao merchUserDao;
    @Autowired
    private Mall2LowPriceWarningDao lowPriceWarningDao;

    @Autowired
    private OrderRefundService orderRefundService;
    @Autowired
    private OrderExceptionRecordService orderExceptionRecordService;

    @Autowired
    private AddressInfoService addressInfoService;
    @Autowired
    private HaiKongMemberTemplate haiKongMemberTemplate;

    @Autowired
    private HaiKongWarehouseTemplate haiKongWarehouseTemplate;

    @Autowired
    private HaiKongProperties haiKongProperties;
    /**
     * 免税mall接口工具类
     */
    @Autowired
    private VmcShopTemplate vmcShopTemplate;

    @Autowired
    private MkActivitiesService mkActivitiesService;

    /**
     * 满赠
     */
    @Autowired
    private MkActivitiesFullGiftService mkActivitiesFullGiftService;

    /**
     * 优惠券
     */
    @Autowired
    private MkActivitiesCouponService mkActivitiesCouponService;

    /**
     * 限时特价
     */
    @Autowired
    private MkActivitiesPromotionService mkActivitiesPromotionService;

    /**
     * 日志记录
     */
    @Autowired
    private InterfaceSendLogDao interfaceSendLogDao;

    /**
     * 同步订单消费信息，重发业务
     */
    @Autowired
    private HaiKongMemberOrderSyncResendService haiKongMemberOrderSyncResendService;

    /**
     * 会员积分变动业务
     */
    @Autowired
    private HaiKongMemberScoreChangeRecordService haiKongMemberScoreChangeRecordService;

    /**
     * 会员积分变动商品详情
     */
    @Autowired
    private HaiKongMemberScoreChangeDetailRecordService haiKongMemberScoreChangeDetailRecordService;

    /**
     * 接口重发信息
     */
    @Autowired
    private HaiKongResendMsgDao haiKongResendMsgDao;

    /**
     * 获取发货、收货人地址
     */
    @Autowired
    private AddressDao addressDao;

    @Autowired
    private MkActivitiesScoreService mkActivitiesScoreService;

    /**
     * 微信海关申报
     */
    @Autowired
    private WxCusDeclareBiz wxCusDeclareBiz;

    /**
     * 取货码信息表
     */
    @Autowired
    private PickUpCodeDao pickUpCodeDao;

    /**
     * 支付宝海关申报
     */
    @Autowired
    private AliCusDeclareBiz aliCusDeclareBiz;

    @Autowired
    private Environment environment;

    @Autowired
    private HaiKongSendOrderInfoRecordService haiKongSendOrderInfoRecordService;

    @Autowired
    private HaiKongSendOrderInfoDetailRecordService haiKongSendOrderInfoDetailRecordService;

    @Override
    public OrderEntity queryObject(Long id) {
        return orderDao.queryObject(id);
    }

    @Override
    public Double getTotalActualPrice(String merchOrderSn) {
        return orderDao.getTotalActualPrice(merchOrderSn);
    }

    @Override
    public List<OrderEntity> queryList(Map<String, Object> map) {
        return orderDao.queryList(map);
    }

    @Override
    public int queryTotal(Map<String, Object> map) {
        return orderDao.queryTotal(map);
    }

    @Override
    public int save(OrderEntity order) {
        return orderDao.save(order);
    }

    @Override
    public int update(OrderEntity order) {
        return orderDao.update(order);
    }

    /**
     * 取消订单
     *
     * @param order
     */
    @Override
    public void cancelOrder(OrderEntity order) {
        boolean needUpdateStock = true;
        if (order.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_0.getItem())) {
            order.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_101.getItem()));
        }
        orderDao.update(order);
        if (!needUpdateStock) {
            return;
        }
        // 更新库存
        updateStock(order, "管理后台取消订单");
        // 释放优惠券
        UserCouponEntity couponVo = userCouponDao.queryByOrderId(order.getId());
        if (null != couponVo) {
            userCouponDao.cancelOrder(couponVo);
        }
        //释放促销满减券
        UserCampMinusEntity userCampMinusVo = userCampMinusDao.queryUserCampByOrderId(order.getId());
        if (null != userCampMinusVo) {
            userCampMinusDao.cancelUserCampOrder(userCampMinusVo);
        }
    }

    @Override
    public int delete(Long id) {
        return orderDao.delete(id);
    }

    @Override
    public int deleteBatch(Long[] ids) {
        return orderDao.deleteBatch(ids);
    }

    @Override
    public int confirm(Long id) {
        OrderEntity orderEntity = queryObject(id);
        Integer shippingStatus = orderEntity.getShippingStatus();//发货状态
        Integer payStatus = orderEntity.getPayStatus();//付款状态
        if (2 != payStatus) {
            throw new RRException("此订单未付款，不能确认收货！");
        }
        if (4 == shippingStatus) {
            throw new RRException("此订单处于退货状态，不能确认收货！");
        }
        if (0 == shippingStatus) {
            throw new RRException("此订单未发货，不能确认收货！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_301.getItem())) {
            throw new RRException("此订单已完成！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_0.getItem())) {
            throw new RRException("此订单待付款！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_100.getItem())) {
            throw new RRException("此订单付款中！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_101.getItem())) {
            throw new RRException("此订单已取消！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_102.getItem())) {
            throw new RRException("此订单已删除！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_201.getItem())) {
            throw new RRException("此订单还未发货！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_401.getItem())) {
            throw new RRException("此订单已退款！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_402.getItem())) {
            throw new RRException("此订单已退款！");
        }
        orderEntity.setShippingStatus(2);
        orderEntity.setOrderStatus(301);
        orderEntity.setConfirmTime(new Date());
        orderDao.update(orderEntity);
        return 0;
    }

    @Override
    public int sendGoods(OrderEntity order) {
        Integer payStatus = order.getPayStatus();//付款状态
        if (2 != payStatus) {
            throw new RRException("此订单未付款！");
        }

        ShippingEntity shippingEntity = shippingDao.queryObject(order.getShippingId());
        if (null != shippingEntity) {
            order.setShippingName(shippingEntity.getName());
        }
        order.setOrderStatus(300);//订单已发货
        order.setShippingStatus(1);//已发货
        return orderDao.update(order);
    }

    @Override
    public Ticket printMsg(Long id) {
        OrderEntity orderEntity = queryInfos(id);

        List<OrderGoodsEntity> orderGoodsEntityList = orderEntity.getOrderGoodsEntityList();
        // 获取门店
        StoreEntity storeEntity = storeDao.queryObject(orderEntity.getStoreId());
        // 获取清关信息
        OrderProcessRecordEntity orderProcessRecordEntity =
                orderProcessRecordDao.queryObjectByOrderSn(orderEntity.getOrderSn());

        // 小票头
        TicketHead head = new TicketHead();
        head.setTitle(OmsMerchPropertiesBuilder.instance().getMerchName() + storeEntity.getStoreName());
        //        head.setMemberId(orderEntity.getUserName().toString());
        head.setOrderId(orderEntity.getOrderSn());
        head.setTradeTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE").format(new Date()));

        // 商品信息
        Integer goodsTotal = 0; // 商品总个数
        BigDecimal total = Constant.ZERO; // 商品总计
        BigDecimal taxTotal = Constant.ZERO; //税费总计
        List<Goods> goodsList = new ArrayList<>();
        for (OrderGoodsEntity orderGoods : orderGoodsEntityList) {
            goodsTotal += orderGoods.getNumber();
            total = total.add(orderGoods.getRetailPrice().multiply(new BigDecimal(orderGoods.getNumber())))
                    .setScale(2, BigDecimal.ROUND_HALF_UP);

            BigDecimal currentTax = orderGoods.getGoodsRate().multiply(orderGoods.getRetailPrice().multiply(new BigDecimal(orderGoods.getNumber())))
                    .setScale(2, BigDecimal.ROUND_HALF_UP);
            taxTotal = taxTotal.add(currentTax);

            Goods goods = new Goods(orderGoods.getGoodsName(),
                    orderGoods.getRetailPrice().toString(),
                    currentTax.toString(),
                    orderGoods.getNumber().toString(),
                    new BigDecimal(orderGoods.getNumber()).multiply(orderGoods.getRetailPrice()).setScale(2, RoundingMode.HALF_UP).toString());
            goodsList.add(goods);
            LOGGER.info(goods.toString());
        }


        // 收银信息
        CashInfo cashInfo = new CashInfo();
        cashInfo.setGoodsTotal(goodsTotal.toString());
        cashInfo.setTotal(total.setScale(2, BigDecimal.ROUND_HALF_UP).toString());
        cashInfo.setTaxTotal(taxTotal.setScale(2, BigDecimal.ROUND_HALF_UP).toString());
        cashInfo.setReceipts(orderEntity.getActualPrice().setScale(2, BigDecimal.ROUND_HALF_UP).toString());
        cashInfo.setOddChange("0.00");
        cashInfo.setCoupon(orderEntity.getCouponPrice().setScale(2, BigDecimal.ROUND_HALF_UP).toString());
        cashInfo.setFreight(
                new BigDecimal(orderEntity.getFreightPrice()).setScale(2, BigDecimal.ROUND_HALF_UP).toString());
        cashInfo.setPaymentMode("微信支付");

        // 海关清单
        CusListing cusListing = new CusListing();
        cusListing.setOrderId(orderEntity.getOrderSn());
        if (!orderEntity.getOrderBizType().equalsIgnoreCase(Dict.orderBizType.item_11.getItem())) {
            cusListing.setWaybillId(orderProcessRecordEntity.getLogisticsNo());
            cusListing.setInvtNo(orderProcessRecordEntity.getInvtNo());
            cusListing.setConsignee(orderEntity.getConsignee());
            cusListing.setConsigneeTel(orderEntity.getMobile());
        }
        cusListing.setOriginAddress(PrintTicketPropertiesBuilder.instance().getAddress());
        cusListing.setDeliveryAddress(storeEntity.getStoreAddress());


        return TicketPrintUtil.print(head, goodsList, cashInfo, cusListing);
    }

    @Override
    public Ticket printMsg(Long id, String sessionId) throws Exception {
        OrderEntity orderEntity = queryInfos(id);

        List<OrderGoodsEntity> orderGoodsEntityList = orderEntity.getOrderGoodsEntityList();
        // 获取门店
        StoreEntity storeEntity = storeDao.queryObject(orderEntity.getStoreId());
        // 获取清关信息
        OrderProcessRecordEntity orderProcessRecordEntity =
                orderProcessRecordDao.queryObjectByOrderSn(orderEntity.getOrderSn());

        // 小票头
        TicketHead head = new TicketHead();
        head.setTitle(storeEntity.getStoreName());
        //门店地址
        head.setStoreAddress(storeEntity.getStoreAddress());
        //        head.setMemberId(orderEntity.getUserName().toString());
        head.setOrderId(orderEntity.getOrderSn());
        head.setTradeTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE").format(orderEntity.getPayTime()));

        // 商品信息
        Integer goodsTotal = 0; // 商品总个数
        BigDecimal total = Constant.ZERO; // 商品总计
        BigDecimal taxTotal = Constant.ZERO; //税费总计
        List<Goods> goodsList = new ArrayList<>();
        BigDecimal discountedPrice = Constant.ZERO; // 优惠金额
        for (OrderGoodsEntity orderGoods : orderGoodsEntityList) {
            goodsTotal += orderGoods.getNumber();
            total = total.add(orderGoods.getRetailPrice().multiply(new BigDecimal(orderGoods.getNumber())))
                    .setScale(2, BigDecimal.ROUND_HALF_UP);
            discountedPrice = discountedPrice.add(orderGoods.getDiscountedPrice());

            // 税前价
            BigDecimal beforeTaxPrice = orderGoods.getRetailPrice().divide(new BigDecimal(1).add(orderGoods.getGoodsRate()), 2, RoundingMode.HALF_UP);


            GoodsEntity goodsEntity = goodsService.queryObject(orderGoods.getGoodsId());
            BigDecimal goodsTax = CalculateTax.calculateFinalTax(goodsEntity, orderGoods.getRetailPrice(), goodsService).setScale(3, RoundingMode.HALF_UP);
            goodsTax = goodsTax.multiply(new BigDecimal(orderGoods.getNumber())).setScale(2, RoundingMode.HALF_UP);
            taxTotal = taxTotal.add(goodsTax).setScale(2, RoundingMode.HALF_UP);

            Goods goods = new Goods(orderGoods.getGoodsName(),
                    orderGoods.getRetailPrice().toString(), // 含税价
//                    beforeTaxPrice.toString(),// 税前价
                    goodsTax.toString(),
                    orderGoods.getNumber().toString(),
                    new BigDecimal(orderGoods.getNumber()).multiply(orderGoods.getRetailPrice()).setScale(2, RoundingMode.HALF_UP).toString(),
                    orderGoods.getDiscountedPrice().toString(),
                    orderGoods.getRetailPrice().subtract(orderGoods.getDiscountedPrice()).setScale(2, RoundingMode.HALF_UP).toString()
                    );
            goodsList.add(goods);
        }

        // 订单积分详情
        Mall2MemberConsumptionRecordsEntity memberConsumptionRecordsEntity = memberConsumptionRecordsDao.queryObjectByOrderSn(orderEntity.getOrderSn());
        // 收银信息
        CashInfo cashInfo = new CashInfo();
        cashInfo.setGoodsTotal(goodsTotal.toString());
        cashInfo.setTotal(total.setScale(2, BigDecimal.ROUND_HALF_UP).toString());
        cashInfo.setTaxTotal(taxTotal.setScale(2, BigDecimal.ROUND_HALF_UP).toString());
        cashInfo.setReceipts(orderEntity.getActualPrice().setScale(2, BigDecimal.ROUND_HALF_UP).toString());
        cashInfo.setOddChange(discountedPrice.toString());
        cashInfo.setCoupon(orderEntity.getCouponPrice().setScale(2, BigDecimal.ROUND_HALF_UP).toString());
        cashInfo.setFreight(
                new BigDecimal(orderEntity.getFreightPrice()).setScale(2, BigDecimal.ROUND_HALF_UP).toString());
        cashInfo.setDeductionScore(memberConsumptionRecordsEntity.getDeductionScore());
        cashInfo.setScoreDeductionPrice(memberConsumptionRecordsEntity.getScoreDeductionPrice().toString());
        if ("alipay".equals(orderEntity.getPayFlag())) {
            cashInfo.setPaymentMode("支付宝支付");
        } else {
            cashInfo.setPaymentMode("微信支付");
        }
        // 海关清单
        CusListing cusListing = new CusListing();
        cusListing.setOrderId(orderEntity.getOrderSn());
        if (!orderEntity.getOrderBizType().equalsIgnoreCase(Dict.orderBizType.item_11.getItem())) {
            cusListing.setWaybillId(orderProcessRecordEntity.getLogisticsNo());
            cusListing.setInvtNo(orderProcessRecordEntity.getInvtNo());

            cusListing.setConsignee(orderEntity.getConsignee());
            // 脱敏设置
            if (StringUtils.isNotEmpty(cusListing.getConsignee()) && cusListing.getConsignee().length() > 1) {
                cusListing.setConsignee(new StringBuilder(cusListing.getConsignee()).replace(1, 2, "*").toString());
            }
            cusListing.setConsigneeTel(orderEntity.getMobile());
            if (StringUtils.isNotEmpty(cusListing.getConsigneeTel())) {
                cusListing.setConsigneeTel(new StringBuilder(cusListing.getConsigneeTel()).replace(3, 7, "****").toString());
//                cusListing.setConsigneeTel(cusListing.getConsigneeTel());
            }
        }
        cusListing.setOriginAddress(PrintTicketPropertiesBuilder.instance().getAddress());
        cusListing.setDeliveryAddress(storeEntity.getStoreAddress());
        // 尝试在取货码表中查询数据，如果有的话就改变状态
        String orderSn = orderEntity.getOrderSn();
        PickUpCodeEntity pickUpCodeEntity = pickUpCodeService.queryObject(orderSn);
        if (pickUpCodeEntity != null) {
            pickUpCodeEntity.setPickUpCodeStatus(Dict.PickUpCodeStatusEnum.item_1.getStatus());
            pickUpCodeService.update(pickUpCodeEntity);
        }
        TicketMailInfo mailInfo = new TicketMailInfo();
        String exprNo = orderProcessRecordEntity.getLogisticsNo();
//        if (StringUtils.isNullOrEmpty(exprNo)) {
//            throw new RRException("快递面单为空，请联系客服");
//        }
        //图片地址
        mailInfo.setStoreImgUrl(storeEntity.getStoreImgUrl()==null?"/statics/img/cw_qrcode.png":storeEntity.getStoreImgUrl().trim());
        if (!StringUtils.isNullOrEmpty(exprNo)) {
            byte[] barCode128 = BarcodeUtil.generateBarCode128(exprNo, 6.0D, null, true, false);
            String exprNoBase64Img = new String(Base64.getEncoder().encode(barCode128));
            mailInfo.setExprNoBase64Img(exprNoBase64Img);

            mailInfo.setExprNo(exprNo);
            String logoUrl = "/statics/img/sf_img.jpg";

            Map<String, String> logoMap = new HashMap<>();
            logoMap.put("yto", "/statics/img/yto_logo.jpg");
            logoMap.put("best", "/statics/img/bestex_logo3.png");
            logoMap.put("sf", "/statics/img/sf_img.jpg");
            if (StringUtils.isNotEmpty(orderEntity.getShippingCode()) && logoMap.containsKey(orderEntity.getShippingCode())) {
                logoUrl = logoMap.get(orderEntity.getShippingCode());
            }
            mailInfo.setExprLogoUrl(logoUrl);
        }
        mailInfo.setShopTel(storeEntity.getTelephoneNumber());
        AddressEntity addressEntity = addressDao.queryStoreAddress(storeEntity.getId(),Dict.addressStatus.item_1.getItem());
        // 发货人
        if (Objects.isNull(addressEntity)) {
            throw new ServiceException("请先配置发货地址！");
        }
        mailInfo.setSenderTel(addressEntity.getTelNumber());
        mailInfo.setSenderName(addressEntity.getSenderName());
        mailInfo.setSenderProvince(addressEntity.getProvinceName());
        mailInfo.setSenderCity(addressEntity.getCityName());
        mailInfo.setSenderDistrict(addressEntity.getCountyName());
        mailInfo.setSenderAddress(addressEntity.getDetailInfo());

        // 收货人
        mailInfo.setConsigneeMob(new StringBuilder(orderEntity.getMobile()).replace(3, 7, "****").toString());
//        mailInfo.setConsigneeMob(orderEntity.getMobile());
        mailInfo.setConsigneeName(new StringBuilder(orderEntity.getConsignee()).replace(1, 2, "*").toString());
        mailInfo.setConsigneeProvince(orderEntity.getProvince());
        mailInfo.setConsigneeCity(orderEntity.getCity());
        mailInfo.setConsigneeDistrict(orderEntity.getDistrict());
        mailInfo.setConsigneeAddress(orderEntity.getAddress());

        return TicketPrintUtil.print(head, goodsList, cashInfo, cusListing, mailInfo);
    }


    /**
     * 退款
     */
    @Override
    @Transactional
    public void refund(OrderEntity order) {
        boolean needUpdateStock = true;
        if (order.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_201.getItem())) {
            order.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_401.getItem()));
        }
        if (Dict.payFlag.item_cash.getItem().equals(order.getPayFlag())) {
            order.setPayStatus(Integer.parseInt(Dict.payStatus.item_4.getItem()));
        }
        orderDao.update(order);//修改为退款中
        // TODO: 2019/6/13 定时任务查询退款成功后释放库存、优惠券
        /*// 判断是否有优惠券
        UserCouponEntity couponVo = userCouponDao.queryByOrderId(order.getId());
        if (null != couponVo) {
            userCouponDao.cancelOrder(couponVo);
        }

        if (!needUpdateStock) {
            return;
        }
        // 更新库存
        updateStock(order, "管理后台订单退款");*/
//        updateStock(order, "管理后台订单退款");

        queryStorePromRealUpdateIsScan(order);
    }

    /**
     * 退款
     */
    @Transactional
    public void refund(OrderEntity order, WechatRefundApiResult result) {
        boolean needUpdateStock = true;
        if (order.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_201.getItem())) {
            order.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_401.getItem()));
        }
        if (Dict.payFlag.item_cash.getItem().equals(order.getPayFlag())) {
            order.setPayStatus(Integer.parseInt(Dict.payStatus.item_4.getItem()));
        } else {
            order.setPayStatus(Integer.parseInt(Dict.payStatus.item_5.getItem()));
            OrderRefundEntity mallOrderRefund = orderRefundDao.queryObjectByOrderId(order.getId());
            OrderRefundEntity orderRefund = new OrderRefundEntity();
            orderRefund.setRefundId(result.getRefund_id());
            try {
                orderRefund.setOutRefundNo(result.getOut_trade_no());
            } catch (Exception e) {
                e.printStackTrace();
            }
            orderRefund.setRefundMoney(BigDecimal.valueOf(Long.valueOf(result.getRefund_fee())).divide(Constant.ONE_HUNDRED));
            orderRefund.setRefundStatus(Integer.parseInt(Dict.RefundStatus.item_5.getItem()));//退款处理中
            orderRefund.setModTime(new Date());

            if (mallOrderRefund != null) {
                orderRefund.setId(mallOrderRefund.getId());
                orderRefund.setRefundType(mallOrderRefund.getRefundType());
                orderRefundDao.update(orderRefund);
            } else {
                orderRefund.setOrderId(Integer.parseInt(order.getId() + ""));
                orderRefund.setUserId(Integer.parseInt(order.getUserId() + ""));
                orderRefund.setCreateTime(new Date());
                List<OrderEntity> list = orderDao.queryObjectByMerchOrderSn(order.getMerchOrderSn());
                if (list.size() > 1) {//多条订单
                    orderRefund.setRefundType(Integer.parseInt(Dict.RefundType.item_2.getItem()));//部分退款
                } else {
                    orderRefund.setRefundType(Integer.parseInt(Dict.RefundType.item_1.getItem()));//用户全额退款
                }
                orderRefundDao.save(orderRefund);//退款记录
            }
        }
        orderDao.update(order);//
        // TODO: 2019/6/13 定时任务查询退款成功后释放库存、优惠券
        /*// 判断是否有优惠券
        UserCouponEntity couponVo = userCouponDao.queryByOrderId(order.getId());
        if (null != couponVo) {
            userCouponDao.cancelOrder(couponVo);
        }

        if (!needUpdateStock) {
            return;
        }
        // 更新库存
        updateStock(order, "管理后台订单退款");*/
//        updateStock(order, "管理后台订单退款");

        queryStorePromRealUpdateIsScan(order);
    }


    @Transactional
    public void refund(OrderEntity order, AliPayMicropayApiResult result) {
        if (order.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_201.getItem())) {
            order.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_401.getItem()));
        }
        if (Dict.payFlag.item_cash.getItem().equals(order.getPayFlag())) {
            order.setPayStatus(Integer.parseInt(Dict.payStatus.item_4.getItem()));
        } else {
            order.setPayStatus(Integer.parseInt(Dict.payStatus.item_4.getItem()));
            OrderRefundEntity mallOrderRefund = orderRefundDao.queryObjectByOrderId(order.getId());
            OrderRefundEntity orderRefund = new OrderRefundEntity();
            orderRefund.setRefundId(result.getTradeNo());
            orderRefund.setOutRefundNo(result.getOutTradeNo());
            orderRefund
                    .setRefundMoney(new BigDecimal(result.getRefundFee()).divide(Constant.ONE_HUNDRED));
            orderRefund.setRefundStatus(Integer.parseInt(Dict.RefundStatus.item_2.getItem()));//退款处理中
            orderRefund.setModTime(new Date());

            if (mallOrderRefund != null) {
                orderRefund.setId(mallOrderRefund.getId());
                orderRefund.setRefundType(mallOrderRefund.getRefundType());
                orderRefundDao.update(orderRefund);
            } else {
                orderRefund.setOrderId(Integer.parseInt(order.getId() + ""));
                orderRefund.setUserId(Integer.parseInt(order.getUserId() + ""));
                orderRefund.setCreateTime(new Date());
                List<OrderEntity> list = orderDao.queryObjectByMerchOrderSn(order.getMerchOrderSn());
                if (list.size() > 1) {//多条订单
                    orderRefund.setRefundType(Integer.parseInt(Dict.RefundType.item_2.getItem()));//部分退款
                } else {
                    orderRefund.setRefundType(Integer.parseInt(Dict.RefundType.item_1.getItem()));//用户全额退款
                }
                orderRefundDao.save(orderRefund);//退款记录
            }
        }
        orderDao.update(order);//修改为退款中
        updateStock(order, "收银端退款");

    }

    /**
     * 平安退款逻辑处理
     *
     * @param order
     * @param result
     */
    @Transactional
    public void pinganRefund(OrderEntity order, net.sf.json.JSONObject result, String refundId) {
        boolean needUpdateStock = true;
        if (order.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_201.getItem())) {
            order.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_401.getItem()));
        }
        order.setPayStatus(Integer.parseInt(Dict.payStatus.item_3.getItem()));
        OrderRefundEntity orderRefund = new OrderRefundEntity();
        orderRefund.setRefundId(refundId);
        orderRefund.setOutRefundNo(result.getString("ord_no"));
        orderRefund.setRefundStatus(Integer.parseInt(Dict.RefundStatus.item_5.getItem()));//退款处理中
        orderRefund.setModTime(new Date());
        orderRefund.setRefundMoney(BigDecimal.valueOf(result.getInt("trade_amount")).divide(Constant.ONE_HUNDRED));

        OrderRefundEntity mallOrderRefund = orderRefundDao.queryObjectByOrderId(order.getId());
        if (mallOrderRefund != null) {
            orderRefund.setRefundType(mallOrderRefund.getRefundType());
            orderRefund.setId(mallOrderRefund.getId());
            orderRefundDao.update(orderRefund);
        } else {//退款记录不存在
            orderRefund.setOrderId(Integer.parseInt(order.getId() + ""));
            orderRefund.setUserId(Integer.parseInt(order.getUserId() + ""));
            orderRefund.setCreateTime(new Date());
            orderRefundDao.save(orderRefund);//退款记录
        }
        orderDao.update(order);//修改为退款中
        // TODO: 2019/6/13 定时任务查询退款成功后释放库存、优惠券
        /*// 判断是否有优惠券
        UserCouponEntity couponVo = userCouponDao.queryByOrderId(order.getId());
        if (null != couponVo) {
            userCouponDao.cancelOrder(couponVo);
        }

        if (!needUpdateStock) {
            return;
        }
        // 更新库存
        updateStock(order, "管理后台平安退款订单");*/

        queryStorePromRealUpdateIsScan(order);
    }

    /**
     * 微信国际退款逻辑处理
     *
     * @param order
     * @param result
     */
    @Transactional
    public void globalRefund(OrderEntity order, WechatGlobalRefundApiResult result) {
        boolean needUpdateStock = true;
        if (order.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_201.getItem())) {
            order.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_401.getItem()));
        }
        order.setPayStatus(Integer.parseInt(Dict.payStatus.item_3.getItem()));
        OrderRefundEntity orderRefund = new OrderRefundEntity();
        orderRefund.setRefundId(result.getRefund_id());
        orderRefund.setOutRefundNo(result.getOut_refund_no());
        orderRefund.setRefundStatus(Integer.parseInt(Dict.RefundStatus.item_5.getItem()));//退款处理中
        orderRefund.setModTime(new Date());
        orderRefund.setRefundMoney(BigDecimal.valueOf(Long.valueOf(result.getRefund_fee())).divide(Constant.ONE_HUNDRED));
        orderRefund.setRefundFeeType(result.getRefund_fee_type());
        if (org.apache.commons.lang3.StringUtils.isNotEmpty(result.getTotal_fee())) {
            orderRefund.setTotalFee(Integer.parseInt(BigDecimal.valueOf(Long.valueOf(result.getTotal_fee())).divide(Constant.ONE_HUNDRED).toString()));
        }
        orderRefund.setFeeType(result.getFee_type());
        if (org.apache.commons.lang3.StringUtils.isNotEmpty(result.getCash_fee())) {
            orderRefund.setCashFee(Integer.parseInt(BigDecimal.valueOf(Long.valueOf(result.getCash_fee())).divide(Constant.ONE_HUNDRED).toString()));
        }
        orderRefund.setCashFeeType(result.getCash_fee_type());
        if (org.apache.commons.lang3.StringUtils.isNotEmpty(result.getCash_refund_fee())) {
            orderRefund.setCashRefundFee(Integer.parseInt(BigDecimal.valueOf(Long.valueOf(result.getCash_refund_fee())).divide(Constant.ONE_HUNDRED).toString()));
        }
        orderRefund.setCashRefundFeeType(result.getCash_refund_fee_type());

        OrderRefundEntity mallOrderRefund = orderRefundDao.queryObjectByOrderId(order.getId());
        if (mallOrderRefund != null) {
            orderRefund.setRefundType(mallOrderRefund.getRefundType());
            orderRefund.setId(mallOrderRefund.getId());
            orderRefundDao.update(orderRefund);
        } else {//退款记录不存在
            orderRefund.setOrderId(Integer.parseInt(order.getId() + ""));
            orderRefund.setUserId(Integer.parseInt(order.getUserId() + ""));
            orderRefund.setCreateTime(new Date());
            orderRefundDao.save(orderRefund);//退款记录
        }
        orderDao.update(order);//修改为退款中
        // TODO: 2019/6/13 定时任务查询退款成功后释放库存、优惠券
        /*// 判断是否有优惠券
        UserCouponEntity couponVo = userCouponDao.queryByOrderId(order.getId());
        if (null != couponVo) {
            userCouponDao.cancelOrder(couponVo);
        }

        if (!needUpdateStock) {
            return;
        }
        // 更新库存
        updateStock(order, "管理后台微信国际退款订单");*/

        queryStorePromRealUpdateIsScan(order);
    }


    private synchronized void restoreInventory(OrderEntity order, String changeReason) {
        Map<String, Object> map = new HashMap();
        SysUserEntity user = ShiroUtils.getUserEntity();
        map.put("orderId", order.getId());
        List<OrderGoodsEntity> orderGoodsVoList = orderGoodsDao.queryList(map);

        for (OrderGoodsEntity orderGoodsEntity : orderGoodsVoList) {
            ProductStoreRelaEntity storeRelaEntity = productStoreRelaDao
                    .queryByGoodsIdAndStoreId(order.getStoreId().longValue(), orderGoodsEntity.getGoodsId().longValue());
            if (null == storeRelaEntity || null == storeRelaEntity.getSellVolume()) {
                storeRelaEntity.setSellVolume(0);
            }
            BigDecimal sellVolume = new BigDecimal(storeRelaEntity.getSellVolume() - orderGoodsEntity.getNumber());//销售量
            if (sellVolume.compareTo(Constant.ZERO) < 0) {
                sellVolume = Constant.ZERO;
            }
//            GoodsEntity goodsEntity = goodsDao.queryObject(orderGoodsEntity.getGoodsId());
//            if (goodsEntity != null) {
//                stockNum = goodsEntity.getGoodsNumber();
//                //还原商户商品库存
//                resetGoodsStock(stockNum, storeRelaEntity, orderGoodsEntity, sellVolume, changeReason, user);
//            }
            Integer stockNum = 0;
            if (null != storeRelaEntity.getStockNum()) {
                stockNum = storeRelaEntity.getStockNum();
                resetStoreGoodsStock(order.getOrderSn(),stockNum, storeRelaEntity, orderGoodsEntity, sellVolume, changeReason, user);//还原门店库存
            }
        }
    }

    private synchronized void updateStock(OrderEntity order, String changeReason) {
        Map<String, Object> map = new HashMap();
        SysUserEntity user = ShiroUtils.getUserEntity();
        map.put("orderId", order.getId());
        List<OrderGoodsEntity> orderGoodsVoList = orderGoodsDao.queryList(map);
        for (OrderGoodsEntity orderGoodsEntity : orderGoodsVoList) {
            ProductStoreRelaEntity storeRelaEntity = productStoreRelaDao
                    .queryByGoodsIdAndStoreId(order.getStoreId().longValue(), orderGoodsEntity.getGoodsId().longValue());
//                    .queryByStoreIdProductId(Long.valueOf(order.getStoreId()),Long.valueOf(orderGoodsEntity.getProductId()));
            if (null == storeRelaEntity || null == storeRelaEntity.getSellVolume()) {
                storeRelaEntity.setSellVolume(0);
            }
            BigDecimal sellVolume = new BigDecimal(storeRelaEntity.getSellVolume() - orderGoodsEntity.getNumber());//销售量
            if (sellVolume.compareTo(Constant.ZERO) < 0) {
                sellVolume = Constant.ZERO;
            }

            Integer stockNum = 0;
            GoodsEntity goodsEntity = goodsDao.queryObject(orderGoodsEntity.getGoodsId());
            if (goodsEntity != null) {
                stockNum = goodsEntity.getGoodsNumber();
                //还原商户商品库存
                resetGoodsStock(stockNum, storeRelaEntity, orderGoodsEntity, sellVolume, changeReason, user);
            }
            if (null != storeRelaEntity.getStockNum()) {
                stockNum = storeRelaEntity.getStockNum();
                //普通商品不受共享库存影响，直接取门店配置库存
                //该商品所属第三方商户不是共享库存
                if (goodsEntity.getIsStockShare().equalsIgnoreCase(Dict.isStockShare.item_0.getItem())) {
                    resetStoreGoodsStock(order.getOrderSn(),stockNum, storeRelaEntity, orderGoodsEntity, sellVolume, changeReason, user);//还原门店库存
                } else {
                    //该商品所属第三方商户是共享库存，但商品业务类型不是00保税备货
                    if (!goodsEntity.getGoodsBizType().equalsIgnoreCase(Dict.orderBizType.item_00.getItem())) {
                        resetStoreGoodsStock(order.getOrderSn(),stockNum, storeRelaEntity, orderGoodsEntity, sellVolume, changeReason, user);//还原门店库存
                    }
                }
            }
            //该商品所属第三方商户为共享库存，且是保税备货商品，取消订单时改变
            updateGoodsByIsShareStock(goodsEntity);
        }
    }

    /**
     * 更新商品库存数量变化后是否已共享为0“未共享”
     *
     * @param goodsInfo
     */
    private void updateGoodsByIsShareStock(GoodsEntity goodsInfo) {
        //该商品所属第三方商户为共享库存，且是保税备货商品
        if (goodsInfo.getIsStockShare().equalsIgnoreCase(Dict.isStockShare.item_1.getItem())
                && goodsInfo.getGoodsBizType().equalsIgnoreCase(Dict.orderBizType.item_00.getItem())) {
            GoodsEntity goodsVo = new GoodsEntity();
            goodsVo.setId(goodsInfo.getId());
            //商品库存数量变化后是否已共享,0：否，1：是(下单、退款、取消订单触发)
            goodsVo.setIsGoodsShareStock(Dict.isGoodsShareStock.item_0.getItem());
            goodsDao.update(goodsVo);
        }
    }

    /**
     * 还原商品总库存
     *
     * @param stockNum
     * @param storeRelaEntity
     * @param orderGoodsEntity
     * @param sellVolume
     * @param changeReason
     * @param user
     */
    private void resetGoodsStock(Integer stockNum, ProductStoreRelaEntity storeRelaEntity,
                                 OrderGoodsEntity orderGoodsEntity, BigDecimal sellVolume, String changeReason, SysUserEntity user) {
        GoodsEntity goodsEntity = goodsDao.queryObject(storeRelaEntity.getGoodsId());
        if (goodsEntity != null) {
            goodsEntity.setGoodsNumber(stockNum + orderGoodsEntity.getNumber());
//                        goodsEntity.setSellVolume(Integer.parseInt(goodsSellVolume.toString()));
            if ("oms退单成功，恢复库存".equals(changeReason)) {
                goodsEntity.setToBeRestored(goodsEntity.getToBeRestored() - orderGoodsEntity.getNumber());
            }
            goodsDao.update(goodsEntity);

            String username = "system";
            if (user != null) {
                username = user.getUsername();
            }

            MngChangeEntity mngChangeEntity = new MngChangeEntity();
            mngChangeEntity.setGoodsId(Integer.parseInt(String.valueOf(goodsEntity.getId())));
            mngChangeEntity.setThirdPartyMerchCode(goodsEntity.getThirdPartyMerchCode());
            mngChangeEntity.setChangeReason(changeReason);
            mngChangeEntity.setChangeType(Dict.changeType.item_0.getItem());
            mngChangeEntity.setChangeNum(orderGoodsEntity.getNumber());//变化数
            mngChangeEntity.setOriginalNum(stockNum);//原库存数
            mngChangeEntity.setValidNum(stockNum + orderGoodsEntity.getNumber());//可用数
            mngChangeEntity.setCreateTime(new Date());
            mngChangeEntity.setModTime(new Date());
            mngChangeEntity.setCreaterSn(username);
            mngChangeEntity.setModerSn(username);
            mngChangeEntity.setIsValid(0);
            mngChangeEntity.setMerchSn(goodsEntity.getMerchSn());
            mngChangeDao.save(mngChangeEntity);
        }
    }

    /**
     * 还原商品总库存
     * @param stockNum
     * @param storeRelaEntity
     * @param orderGoodsEntity
     * @param user
     */
    private void resetGoodsStockHkMall(OrderEntity order,Integer stockNum, ProductStoreRelaEntity storeRelaEntity,
                                 OrderGoodsEntity orderGoodsEntity,SysUserEntity user) {
        GoodsEntity goodsEntity = goodsDao.queryObject(storeRelaEntity.getGoodsId());
        if (goodsEntity != null) {
            //商品数量 + 待退款数量
            goodsEntity.setGoodsNumber(stockNum + orderGoodsEntity.getNumber());
            //还原商品总库存
            goodsDao.update(goodsEntity);
            String username = "system";
            if (user != null) {
                username = user.getUsername();
            }

            MngChangeEntity mngChangeEntity = new MngChangeEntity();
            mngChangeEntity.setOrderSn(order.getOrderSn());
            mngChangeEntity.setGoodsId(Integer.parseInt(String.valueOf(goodsEntity.getId())));
            mngChangeEntity.setThirdPartyMerchCode(goodsEntity.getThirdPartyMerchCode());
            mngChangeEntity.setChangeReason("收银端退款");
            mngChangeEntity.setChangeType(Dict.changeType.item_0.getItem());
            mngChangeEntity.setChangeNum(orderGoodsEntity.getNumber());//变化数
            mngChangeEntity.setOriginalNum(stockNum);//原库存数
            mngChangeEntity.setValidNum(stockNum + orderGoodsEntity.getNumber());//可用数
            mngChangeEntity.setCreateTime(new Date());
            mngChangeEntity.setModTime(new Date());
            mngChangeEntity.setCreaterSn(username);
            mngChangeEntity.setModerSn(username);
            mngChangeEntity.setIsValid(0);
            mngChangeEntity.setMerchSn(goodsEntity.getMerchSn());
            mngChangeDao.save(mngChangeEntity);
        }
    }

    /**
     * 还原门店商品库存
     *
     * @param stockNum
     * @param storeRelaEntity
     * @param orderGoodsEntity
     * @param sellVolume
     * @param changeReason
     * @param user
     */
    private void resetStoreGoodsStock(String orderSn,Integer stockNum, ProductStoreRelaEntity storeRelaEntity,
                                      OrderGoodsEntity orderGoodsEntity, BigDecimal sellVolume, String changeReason, SysUserEntity user) {
        storeRelaEntity.setSellVolume(Integer.parseInt(sellVolume.toString())); // 减退库存
        storeRelaEntity.setStockNum(stockNum + orderGoodsEntity.getNumber());//库存数量
        if ("oms退单成功，恢复库存".equals(changeReason)) {
            storeRelaEntity.setToBeRestored(storeRelaEntity.getToBeRestored() - orderGoodsEntity.getNumber());
        }
        productStoreRelaDao.update(storeRelaEntity);


        String username = "system";
        if (user != null) {
            username = user.getUsername();
        }
        StoreMngChangeEntity storeMngChangeEntity = new StoreMngChangeEntity();
        storeMngChangeEntity.setChangeType(Dict.changeType.item_0.getItem());
        storeMngChangeEntity.setOrderSn(orderSn);
        storeMngChangeEntity.setChangeReason(changeReason);
        storeMngChangeEntity.setGoodsId(Integer.parseInt(String.valueOf(storeRelaEntity.getGoodsId())));
        storeMngChangeEntity.setStoreId(Integer.parseInt(String.valueOf(storeRelaEntity.getStoreId())));
        storeMngChangeEntity.setMerchSn(storeRelaEntity.getMerchSn());
        storeMngChangeEntity.setStoreChangeNum(orderGoodsEntity.getNumber());
        storeMngChangeEntity.setStoreOriginalNum(stockNum);
        storeMngChangeEntity.setStoreValidNum(stockNum + orderGoodsEntity.getNumber());
        storeMngChangeEntity.setCreateTime(new Date());
        storeMngChangeEntity.setModTime(new Date());
        storeMngChangeEntity.setCreaterSn(username);
        storeMngChangeEntity.setModerSn(username);
        storeMngChangeEntity.setIsValid(0);
        storeMngChangeDao.save(storeMngChangeEntity);
    }

    /**
     * 海控还原门店商品库存
     * @param stockNum
     * @param storeRelaEntity
     * @param orderGoodsEntity
     * @param sellVolume
     * @param user
     */
    private void resetStoreGoodsStockMall(OrderEntity order,Integer stockNum, ProductStoreRelaEntity storeRelaEntity,
                                      OrderGoodsEntity orderGoodsEntity, BigDecimal sellVolume,SysUserEntity user) {
        storeRelaEntity.setSellVolume(Integer.parseInt(sellVolume.toString())); // 减退库存
        //库存数量 + 商品数量
        storeRelaEntity.setStockNum(stockNum + orderGoodsEntity.getNumber());//库存数量
        //待退款数量 - 商品数量
        //storeRelaEntity.setToBeRestored(storeRelaEntity.getToBeRestored() - orderGoodsEntity.getNumber());
        productStoreRelaDao.update(storeRelaEntity);

        String username = "system";
        if (user != null) {
            username = user.getUsername();
        }
        StoreMngChangeEntity storeMngChangeEntity = new StoreMngChangeEntity();
        storeMngChangeEntity.setOrderSn(order.getOrderSn());
        storeMngChangeEntity.setChangeType(Dict.changeType.item_0.getItem());
        storeMngChangeEntity.setChangeReason("前端退款");
        storeMngChangeEntity.setGoodsId(storeRelaEntity.getGoodsId().intValue());
        storeMngChangeEntity.setStoreId(storeRelaEntity.getStoreId().intValue());
        storeMngChangeEntity.setMerchSn(storeRelaEntity.getMerchSn());
        storeMngChangeEntity.setStoreChangeNum(orderGoodsEntity.getNumber());
        storeMngChangeEntity.setStoreOriginalNum(stockNum);
        storeMngChangeEntity.setStoreValidNum(stockNum + orderGoodsEntity.getNumber());
        storeMngChangeEntity.setCreateTime(new Date());
        storeMngChangeEntity.setModTime(new Date());
        storeMngChangeEntity.setCreaterSn(username);
        storeMngChangeEntity.setModerSn(username);
        storeMngChangeEntity.setIsValid(0);
        storeMngChangeDao.save(storeMngChangeEntity);
    }

    /**
     * 查询该退款订单编号是否是推广渠道订单，是则修改渠道定时扫描状态
     *
     * @param orderInfo
     */
    private void queryStorePromRealUpdateIsScan(OrderEntity orderInfo) {
        Map map = new HashMap();
        map.put("orderId", orderInfo.getId());
        List<MkStorePromOrderRealEntity> list = mkStorePromOrderRealDao.queryPromRealListByMap(map);
        if (list.size() > 0) {
            for (MkStorePromOrderRealEntity mkStorePromOrderRealEntity : list) {
                mkStorePromOrderRealEntity.setIsPromStatScan(Dict.isDistSellScan.item_0.getItem());
                mkStorePromOrderRealDao.update(mkStorePromOrderRealEntity);
            }
        }
    }

    /**
     * 处理用户退款申请
     *
     * @param orderInfo
     */
    @Transactional
    public void applyRefundDeal(OrderEntity orderInfo, OrderRefundEntity refundEntity) {
        refundEntity.setApprovalTime(new Date());
        //        refundEntity.setApprover(ShiroUtils.getUserId());
        //  退积分
        try {
            Integer integral = 1;
            if (orderInfo.getActualPrice().intValue() > 0) {
                integral = orderInfo.getActualPrice().intValue();
            }
            if (refundEntity.getRefundStatus() == 2) {
                orderInfo.setOrderStatus(401);
//                UserEntity entity = userDao.queryObject(orderInfo.getUserId());
            } else {
                orderInfo.setOrderStatus(201);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        orderRefundDao.update(refundEntity);
        orderDao.update(orderInfo);
    }

    @Override
    public OrderRefundEntity queryRefundObject(Long refundId) {
        return orderRefundDao.queryObject(refundId);
    }

    @Override
    public List<OrderRefundEntity> queryRefundList(Map<String, Object> map) {
        return orderRefundDao.queryList(map);
    }

    @Override
    public int queryRefundTotal(Map<String, Object> map) {
        return orderRefundDao.queryTotal(map);
    }

    @Override
    public int getUserOrderInfo(Map<String, Object> map) {
        int result = 0;
        String type = (String) map.get("type");
        if ("yfkOrderUserSum".equals(type)) {
            result = orderDao.getYfkOrderUserSum(map);
        } else if ("oderUserSum".equals(type)) {
            result = orderDao.getOderUserSum(map);
        } else if ("todayUserOrder".equals(type)) {
            result = orderDao.getTodayUserOrder(map);
        } else if ("todayUserSales".equals(type)) {
            result = orderDao.getTodayUserSales(map);
        } else if ("incomeSum".equals(type)) {
            result = orderDao.getIncomeSum(map);
        } else if ("payedOrderCount".equals(type)) {
            result = orderDao.getPayedOrderCount(map);
        }
        return result;
    }

    @Override
    public Map getLogistics(Long id) {
        OrderEntity orderEntity = queryObject(id);
        if (orderEntity == null) {
            throw new RRException("此订单不存在！");
        }
        if (orderEntity.getShippingStatus() == 0) {
            if (orderEntity.getOrderBizType().equalsIgnoreCase(Dict.orderBizType.item_00.getItem()) ||
                    orderEntity.getOrderBizType().equalsIgnoreCase(Dict.orderBizType.item_02.getItem())) {
                throw new RRException("此订单还未发货！");
            } else {
                if (StringUtils.isNullOrEmpty(orderEntity.getShippingNo())) {
                    throw new RRException("此订单还未发货！");
                }
            }
        }

        Map logisticsInfo = Maps.newHashMap();
        List<WuliuEntity> wuliuEntityList = new ArrayList<>();
        OrderProcessRecordEntity orderProcessRecordEntity =
                orderProcessRecordDao.queryObjectByOrderSn(orderEntity.getOrderSn());
        if (orderProcessRecordEntity != null) {
            if (orderEntity.getOrderBizType().equals(Dict.orderBizType.item_10.getItem()) ||
                    orderEntity.getOrderBizType().equals(Dict.orderBizType.item_02.getItem())) {
                WuliuEntity wuliuEntity = new WuliuEntity();
                wuliuEntity.setAcceptTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
                        .format(orderProcessRecordEntity.getCustomsSuccTime()));
                wuliuEntity.setAcceptStation(PrintTicketPropertiesBuilder.instance().getAddress() + "送达" +
                        storeDao.queryObject(orderEntity.getStoreId()).getStoreAddress() +
                        ";交易完成，用户已提走");
                wuliuEntityList.add(wuliuEntity);
            }
            if (StringUtils.isNotEmpty(orderEntity.getShippingCode()) &&
                    StringUtils.isNotEmpty(orderEntity.getShippingNo()) &&
                    orderProcessRecordEntity.getShipmentStartTime() != null) {
                if (orderEntity.getShippingCode().equalsIgnoreCase("SF")) {
                    StoreEntity storeEntity = storeDao.queryObject(orderEntity.getStoreId());
                    if (storeEntity == null) {
                        throw new RRException("查询顺丰订单异常，订单的门店信息不存在");
                    }
                    ThirdMerchExpressEntity thirdMerchExpressEntity = thirdMerchExpressDao.getThirdMerchExpressByThirdCode(storeEntity.getThirdPartyMerchCode());
                    if (thirdMerchExpressEntity == null) {
                        throw new RRException("查询顺丰订单异常，缺失商户快递账号信息");
                    }
                    SfRouteServiceResponseEntity entity = SFUtil.routeService(orderEntity.getShippingNo(), thirdMerchExpressEntity.getExpressAccount(),
                            thirdMerchExpressEntity.getExpressPwd(), SFPropertiesBuilder.instance().getUrl());
//                    SfRouteServiceResponseEntity entity = SFUtil.routeService("254355029325", thirdMerchExpressEntity.getExpressAccount(),
//                    thirdMerchExpressEntity.getExpressPwd(), SFPropertiesBuilder.instance().getUrl());//444072971585
                    if (entity.getHead().equalsIgnoreCase("OK")) {
                        if (entity.getBody() == null) {
                            WuliuEntity wuliuEntity = new WuliuEntity();
                            wuliuEntity.setAcceptStation("暂无物流轨迹");
                            wuliuEntityList.add(wuliuEntity);
                        } else {
                            if (entity.getBody().getRouteResponse() == null) {
                                WuliuEntity wuliuEntity = new WuliuEntity();
                                wuliuEntity.setAcceptStation("暂无物流轨迹");
                                wuliuEntityList.add(wuliuEntity);
                            } else {
                                RouteResponseEntity routeResponseEntity = entity.getBody().getRouteResponse().get(0);
                                if (routeResponseEntity != null) {
                                    List<RouteEntity> entityList = routeResponseEntity.getRouteResponse();
                                    for (RouteEntity route : entityList) {
                                        WuliuEntity wuliuEntity = new WuliuEntity();
                                        wuliuEntity.setAcceptTime(route.getAccept_time());
                                        wuliuEntity.setAcceptStation(route.getAccept_address() + route.getRemark());
                                        wuliuEntityList.add(wuliuEntity);
                                    }
                                }
                            }
                        }
                    } else {
                        throw new RRException("查询顺丰订单异常，" + entity.getErrors());
                    }

                } else {
                    JSONObject traces =
                            KdniaoUtil.getOrderTracesByJson(orderEntity.getShippingCode(), orderEntity.getShippingNo());
                    List<Map> mapList = (List<Map>) traces.get("Traces");
                    if (mapList != null && mapList.size() > 0) {
                        for (Map map : mapList) {
                            WuliuEntity wuliuEntity = new WuliuEntity();
                            wuliuEntity.setAcceptTime(map.get("AcceptTime").toString());
                            wuliuEntity.setAcceptStation(map.get("AcceptStation").toString());
                            wuliuEntityList.add(wuliuEntity);
                        }
                    }
                    String state = traces.get("State") + "";
                    if (Dict.logisticsStatus.item_0.getItem().equals(state) && traces.getBoolean("Success")) {
                        String reason = traces.get("Reason") + "";
                        WuliuEntity wuliuEntity = new WuliuEntity();
                        wuliuEntity.setAcceptStation(reason);
                        wuliuEntityList.add(wuliuEntity);
                    }
                }
            }
            if (Dict.isSend.item_1.getItem().equalsIgnoreCase(orderProcessRecordEntity.getIsCustomsSend()) &&
                    orderProcessRecordEntity.getShipmentStartTime() != null) {
                WuliuEntity wuliuEntity = new WuliuEntity();
                wuliuEntity.setAcceptStation("订单已出库");
                wuliuEntity.setAcceptTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
                        .format(orderProcessRecordEntity.getShipmentStartTime()));
                wuliuEntityList.add(wuliuEntity);
            }
            if (Dict.isSend.item_1.getItem().equals(orderProcessRecordEntity.getIsCustomsSend())) {
                WuliuEntity wuliuEntity = new WuliuEntity();
                wuliuEntity.setAcceptStation("订单清关完成，等待仓库发货");
                wuliuEntity.setAcceptTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
                        .format(orderProcessRecordEntity.getCustomsSuccTime()));
                wuliuEntityList.add(wuliuEntity);
            }

            if (Dict.isSend.item_0.getItem().equalsIgnoreCase(orderProcessRecordEntity.getIsCustomsSend())) {
                WuliuEntity wuliuEntity = new WuliuEntity();
                wuliuEntity.setAcceptStation("订单清关失败");
                wuliuEntityList.add(wuliuEntity);
            }
            if (Dict.isSend.item_1.getItem().equalsIgnoreCase(orderProcessRecordEntity.getIsEleOrderSend()) &&
                    orderProcessRecordEntity.getWaybillSuccTime() != null) {
                WuliuEntity wuliuEntity = new WuliuEntity();
                wuliuEntity.setAcceptStation("海关三单发送成功");
                wuliuEntity.setAcceptTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
                        .format(orderProcessRecordEntity.getWaybillSuccTime()));
                wuliuEntityList.add(wuliuEntity);
            }
            if (Dict.isSend.item_1.getItem().equals(orderProcessRecordEntity.getIsPaymentSend())) {
                WuliuEntity wuliuEntity = new WuliuEntity();
                wuliuEntity.setAcceptStation("订单支付成功");
                wuliuEntity.setAcceptTime(
                        new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(orderProcessRecordEntity.getPaySuccTime()));
                wuliuEntityList.add(wuliuEntity);
            }
            if (Dict.isSend.item_1.getItem().equalsIgnoreCase(orderProcessRecordEntity.getIsAddOrderSend())) {
                WuliuEntity wuliuEntity = new WuliuEntity();
                wuliuEntity.setAcceptStation("订单下单成功");
                wuliuEntity.setAcceptTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
                        .format(orderProcessRecordEntity.getAddOrderSuccTime()));
                wuliuEntityList.add(wuliuEntity);
            }
        }
        logisticsInfo.put("tracesList", wuliuEntityList);
        logisticsInfo.put("logisticCode", orderEntity.getShippingNo());
        logisticsInfo.put("shipperCode", orderEntity.getShippingCode());
        return logisticsInfo;
    }

    @Override
    public OrderEntity queryInfos(Long id) {
        OrderEntity orderEntity = orderDao.queryObject(id);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("orderId", id);
        List<OrderGoodsEntity> orderGoodsEntityList = orderGoodsDao.queryList(map);
        orderEntity.setOrderGoodsEntityList(orderGoodsEntityList);
        return orderEntity;
    }

    /**
     * 普货商品生成线下订单
     *
     * @param offlineCartList
     * @param user
     * @return
     */
    @Transactional
    @Override
    public Map orderSubmit(List<OfflineCartEntity> offlineCartList, SysUserEntity user) {
        Map resultObj = Maps.newHashMap();
        try {
            if (user == null) {
                resultObj.put("errno", 400);
                resultObj.put("errmsg", "用户登录超时，请重新登录");
                return resultObj;
            }
            if (!user.getRoleType().equalsIgnoreCase("2")) {
                resultObj.put("errno", 400);
                resultObj.put("errmsg", "该操作只允许店员账户操作");
                return resultObj;
            }
            if (org.apache.commons.lang3.StringUtils.isEmpty(user.getMerchSn())) {
                resultObj.put("errno", 400);
                resultObj.put("errmsg", "操作用户的商户编号为空，请先维护用户商户编号信息再来操作");
                return resultObj;
            }
            Long userId = user.getUserId();
            Integer storeId = user.getStoreId();
            //获取要购买的商品
            Map param = Maps.newHashMap();
            param.put("userId", userId);
            param.put("storeId", storeId);
            if (null == offlineCartList && offlineCartList.size() == 0) {
                resultObj.put("errno", 400);
                resultObj.put("errmsg", "购买商品数据为空");
                return resultObj;
            }
            List<OfflineCartEntity> offlineCartEntityList = offlineCartDao.queryOfflineCartByBizType(param);
            if (offlineCartEntityList.size() == 0 && offlineCartList.size() > 0) {
                resultObj.put("errno", 0);
                resultObj.put("errmsg", "该单已下单成功，请重新扫描商品进行购买");
                return resultObj;
            }
            // 检查库存和更新库存
            for (OfflineCartEntity cartEntity : offlineCartEntityList) {
                GoodsEntity goodsEntity = goodsDao.queryObject(cartEntity.getGoodsId());
                if (goodsEntity == null) {
                    resultObj.put("errno", 400);
                    resultObj.put("errmsg", "订单提交失败：商品不存在");
                    return resultObj;
                }
                //取得规格的信息,判断规格库存
                ProductStoreRelaEntity productInfo = productStoreRelaDao
                        .queryByGoodsIdAndStoreId(Long.valueOf(storeId), Long.valueOf(cartEntity.getGoodsId()));
                synchronized (productInfo) {
                    if (null == productInfo || null == productInfo.getStockNum() ||
                            productInfo.getStockNum() < cartEntity.getNumber()) {
                        resultObj.put("errno", 400);
                        resultObj.put("errmsg", "库存不足，仅剩余" + productInfo.getStockNum());
                        return resultObj;
                    } else {
                        productInfo.setStockNum(productInfo.getStockNum() - cartEntity.getNumber());
                        productInfo.setStoreId(Long.valueOf(storeId));
                        productInfo.addSellVolume();
                        productStoreRelaDao.updateStockNumByStoreIdAndSku(productInfo);//修改普通商品库存

                        if (goodsEntity != null) {
                            goodsEntity.setGoodsNumber(goodsEntity.getGoodsNumber() - cartEntity.getNumber());
                            goodsDao.update(goodsEntity);
                        }
                    }
                }
            }
            String merchOrderSn = "EMATO" + CommonUtil.generateOrderNumber();
            OrderEntity order = setOrderVo(user, offlineCartEntityList, user.getMerchSn());
            order.setStoreId(storeId);
            order.setMerchOrderSn(merchOrderSn);

            //开启事务，插入订单信息和订单商品
            if (order != null) {
                orderDao.save(order);
                if (null == order.getId()) {
                    resultObj.put("errno", 400);
                    resultObj.put("errmsg", "订单提交失败");
                    return resultObj;
                }
                for (OfflineCartEntity cartEntity : offlineCartEntityList) {
                    OrderGoodsEntity orderGoodsEntity = setOrderGoodsVo(order, cartEntity);
                    //新增订单详情
                    orderGoodsDao.save(orderGoodsEntity);
                }
                //清空预订单商品临时表
                offlineCartDao.deleteByUserId(userId);
                Map orderInfoMap = Maps.newHashMap();
                orderInfoMap.put("orderInfo", order);
                resultObj.put("errno", 0);
                resultObj.put("errmsg", "订单提交成功");
                resultObj.put("data", orderInfoMap);
            }
        } catch (Exception e) {
            e.printStackTrace();
            resultObj.put("errno", 400);
            resultObj.put("errmsg", "订单异常");
            return resultObj;
        }
        return resultObj;
    }

    /**
     * 设置订单数据
     *
     * @param loginUser
     * @return
     */
    public OrderEntity setOrderVo(SysUserEntity loginUser, List<OfflineCartEntity> offlineCartEntityList,
                                  String merchSn) {
        OrderEntity orderInfo = new OrderEntity();
        BigDecimal freightPrice = new BigDecimal(0.00);
        BigDecimal goodsTotalPrice = new BigDecimal(0.00);
        for (OfflineCartEntity offlineCartEntity : offlineCartEntityList) {
            goodsTotalPrice = goodsTotalPrice
                    .add(offlineCartEntity.getRetailPrice().multiply(new BigDecimal(offlineCartEntity.getNumber())));
        }
        //订单价格计算：订单的总价+运费
        BigDecimal orderTotalPrice = goodsTotalPrice.add(freightPrice);
        //查询未使用的优惠券
        /*String couponName = "";
        BigDecimal fullCutCouponDec = Constant.ZERO;
        UserCouponVo couponVo = null;*/
        BigDecimal couponPrice = new BigDecimal(0.00);
        //减去其它支付的金额后，要实际支付的金额   订单的总价+运费-优惠券金额
        BigDecimal actualPrice = orderTotalPrice.subtract(couponPrice);

        //商户（拼音首字母）+业务类型+编号
        //        String merchSn = OmsMerchPropertiesBuilder.instance().getMerchSn();
        //        String merchShortName = OmsMerchPropertiesBuilder.instance().getMerchShortName();
        MerchEntity merchEntity = merchDao.findByMerchSn(merchSn);
        String merchShortName = "";
        if (merchEntity != null) {
            merchShortName = merchEntity.getMerchShortName();
        }
        String orderSn = merchShortName + Dict.orderBizType.item_11.getItem() + CommonUtil.generateOrderNumber();
        orderInfo.setOrderSn(orderSn);
        orderInfo.setMerchSn(merchSn);
        orderInfo.setUserId(Integer.parseInt(loginUser.getUserId() + ""));
        orderInfo.setFreightPrice(freightPrice.intValue());
        orderInfo.setOrderBizType(Dict.orderBizType.item_11.getItem());

        /*orderInfo.setCoupon_id(userCouponId);
        orderInfo.setCoupon_name(couponName);*/
        //        orderInfo.setFullCutPrice(fullCutCouponDec);//使用的优惠券
        orderInfo.setCouponPrice(couponPrice);
        orderInfo.setPostscript("");//留言
        orderInfo.setAddTime(new Date());
        orderInfo.setGoodsPrice(goodsTotalPrice);
        orderInfo.setOrderPrice(orderTotalPrice);
        orderInfo.setActualPrice(actualPrice);
        orderInfo.setOrderType("1");
        orderInfo.setOrderStatus(0);// 待付款
        orderInfo.setShippingStatus(0);
        orderInfo.setPayStatus(0);
        orderInfo.setShippingId(0L);
        orderInfo.setShippingFee(Constant.ZERO);
        orderInfo.setIntegral(0);
        orderInfo.setIntegralMoney(Constant.ZERO);
        orderInfo.setCreateTime(new Date());
        orderInfo.setModTime(new Date());
        orderInfo.setIsOnfflineOrder(Dict.isOnfflineOrder.item_1.getItem());//线下购买
        /*//标记该订单已使用优惠券
        if(couponVo != null){
            couponVo.setUsed_time(new Date());
            couponVo.setIsUsed(Dict.isUsed.item_1.getItem());
            apiUserCouponMapper.update(couponVo);
        }*/
        return orderInfo;
    }

    /**
     * 设置订单数据
     *
     * @param
     * @return
     */
    public OrderEntity setOrder(Integer userId, List<LinkedHashMap> goodsList,
                                String merchSn) {
        OrderEntity orderInfo = new OrderEntity();
        BigDecimal freightPrice = new BigDecimal(0.00);
        BigDecimal goodsTotalPrice = new BigDecimal(0.00);
        for (LinkedHashMap goods : goodsList) {
            goodsTotalPrice = goodsTotalPrice
                    .add(new BigDecimal(goods.get("retailPrice").toString()).multiply(new BigDecimal(goods.get("sellVolume").toString())));
        }
        //订单价格计算：订单的总价+运费
        BigDecimal orderTotalPrice = goodsTotalPrice.add(freightPrice);
        //查询未使用的优惠券
        /*String couponName = "";
        BigDecimal fullCutCouponDec = Constant.ZERO;
        UserCouponVo couponVo = null;*/
        BigDecimal couponPrice = new BigDecimal(0.00);
        //减去其它支付的金额后，要实际支付的金额   订单的总价+运费-优惠券金额
        BigDecimal actualPrice = orderTotalPrice.subtract(couponPrice);

        //商户（拼音首字母）+业务类型+编号
        //        String merchSn = OmsMerchPropertiesBuilder.instance().getMerchSn();
        //        String merchShortName = OmsMerchPropertiesBuilder.instance().getMerchShortName();
        MerchEntity merchEntity = merchDao.findByMerchSn(merchSn);
        String merchShortName = "";
        if (merchEntity != null) {
            merchShortName = merchEntity.getMerchShortName();
        }
        String orderSn = merchShortName + Dict.orderBizType.item_10.getItem() + CommonUtil.generateOrderNumber();
        orderInfo.setOrderSn(orderSn);
        orderInfo.setMerchSn(merchSn);
        orderInfo.setUserId(userId);
        orderInfo.setFreightPrice(freightPrice.intValue());
        orderInfo.setOrderBizType(Dict.orderBizType.item_10.getItem());

        /*orderInfo.setCoupon_id(userCouponId);
        orderInfo.setCoupon_name(couponName);*/
        //        orderInfo.setFullCutPrice(fullCutCouponDec);//使用的优惠券
        orderInfo.setCouponPrice(couponPrice);
        orderInfo.setPostscript("");//留言
        orderInfo.setAddTime(new Date());
        orderInfo.setGoodsPrice(goodsTotalPrice);
        orderInfo.setOrderPrice(orderTotalPrice);
        orderInfo.setActualPrice(actualPrice);
        orderInfo.setOrderType("1");
        orderInfo.setOrderStatus(0);// 待付款
        orderInfo.setShippingStatus(0);
        orderInfo.setPayStatus(0);
        orderInfo.setShippingId(0L);
        orderInfo.setShippingFee(Constant.ZERO);
        orderInfo.setIntegral(0);
        orderInfo.setIntegralMoney(Constant.ZERO);
        orderInfo.setCreateTime(new Date());
        orderInfo.setModTime(new Date());
        orderInfo.setIsOnfflineOrder(Dict.isOnfflineOrder.item_1.getItem());//线下购买
//        orderInfo.setIsScan("0");//默认未扫描
        /*//标记该订单已使用优惠券
        if(couponVo != null){
            couponVo.setUsed_time(new Date());
            couponVo.setIsUsed(Dict.isUsed.item_1.getItem());
            apiUserCouponMapper.update(couponVo);
        }*/
        return orderInfo;
    }


    public OrderGoodsEntity setOrderGoodsVo(OrderEntity orderInfo, OfflineCartEntity goodsItem) {
        GoodsEntity goodsVo = goodsDao.queryObject(goodsItem.getGoodsId());
        OrderGoodsEntity orderGoodsVo = new OrderGoodsEntity();
        orderGoodsVo.setOrderId(Integer.parseInt(orderInfo.getId() + ""));
        orderGoodsVo.setGoodsId(goodsItem.getGoodsId());
        orderGoodsVo.setGoodsSn(goodsItem.getGoodsSn());
        orderGoodsVo.setProductId(goodsItem.getProductId());
        orderGoodsVo.setGoodsName(goodsItem.getGoodsName());
        orderGoodsVo.setListPicUrl(goodsItem.getListPicUrl());
        orderGoodsVo.setMarketPrice(goodsItem.getMarketPrice());
        orderGoodsVo.setRetailPrice(goodsItem.getRetailPrice());
        orderGoodsVo.setNumber(goodsItem.getNumber());
        orderGoodsVo.setOrderBizType(Dict.orderBizType.item_11.getItem());
        orderGoodsVo.setCreateTime(new Date());
        orderGoodsVo.setModTime(new Date());
        orderGoodsVo.setGoodsRate(goodsVo.getGoodsRate());
        orderGoodsVo.setSku(goodsVo.getSku());
        return orderGoodsVo;
    }

//    public OrderGoodsEntity setOrderGoods(OrderEntity orderInfo, LinkedHashMap goods) {
//        GoodsEntity goodsVo = goodsDao.queryObject(goods.get("goodsId"));
//        ProductEntity productEntity = productDao.queryObjectByGoodsIdAndStoreId(goodsVo.getId() + "", null);
//        OrderGoodsEntity orderGoodsVo = new OrderGoodsEntity();
//        orderGoodsVo.setOrderId(Integer.parseInt(orderInfo.getId() + ""));
//        orderGoodsVo.setGoodsId(goodsVo.getId().intValue());
//        orderGoodsVo.setGoodsSn(goodsVo.getGoodsSn());
//        orderGoodsVo.setProductId(productEntity.getId().intValue());
//        orderGoodsVo.setGoodsName(goodsVo.getName());
//        orderGoodsVo.setListPicUrl(goodsVo.getListPicUrl());
//
//
//        orderGoodsVo.setMarketPrice((BigDecimal) goods.get("storeMarketPrice"));
//        orderGoodsVo.setRetailPrice((BigDecimal) goods.get("storeRetailPrice"));
//        orderGoodsVo.setNumber((Integer) goods.get("sellVolume"));
//        orderGoodsVo.setOrderBizType(Dict.orderBizType.item_10.getItem());
//        orderGoodsVo.setCreateTime(new Date());
//        orderGoodsVo.setModTime(new Date());
//        orderGoodsVo.setGoodsRate(goodsVo.getGoodsRate());
//        orderGoodsVo.setSku(goodsVo.getSku());
//
//
//        BigDecimal number = new BigDecimal(Long.valueOf(goodsItem.getNumber()));
//        BigDecimal goodsTotal = goodsItem.getRetail_price().multiply(number);//单商品总价
//        BigDecimal rate = goodsTotal.divide(orderInfo.getGoods_price(),2, BigDecimal.ROUND_HALF_UP);//当前商品总价/订单总价（不含运费、不含优惠券）
//        BigDecimal freightPrice = BigDecimal.valueOf(orderInfo.getFreight_price());
//        BigDecimal settlePrice = Constant.ZERO;
//        if(orderInfo.getFreight_price() != 0 && !"0".equalsIgnoreCase(orderInfo.getCoupon_price()+"")){
//            //运费-优惠券
//            BigDecimal rateTotal = freightPrice.subtract(orderInfo.getCoupon_price());
//            //商品结算平摊价格（含优惠券、运费金额） = 单商品总价 + 当前商品总价/订单总价（不含运费、不含优惠券） * 运费与优惠券合计税率
//            settlePrice = goodsTotal.add(rate.multiply(rateTotal));
//        }else{
//            if(orderInfo.getFreight_price()!=0){
//                //运费税率 = 单商品总价/订单总价（不含运费）* 运费金额
//                BigDecimal freightRate = rate.multiply(freightPrice);
//                //商品结算平摊价格（含运费金额） = 单商品总价+运费税率
//                settlePrice = goodsTotal.add(freightRate);
//            }
//            if(!"0".equalsIgnoreCase(orderInfo.getCoupon_price()+"")){
//                //优惠券税率 = 单商品总价/订单总价（不含优惠券）* 优惠券金额
//                BigDecimal couponRate = rate.multiply(orderInfo.getCoupon_price());
//                //商品结算平摊价格（含优惠券金额） = 单商品总价-优惠券税率
//                settlePrice = goodsTotal.subtract(couponRate);
//            }
//        }
//        if(settlePrice.compareTo(BigDecimal.valueOf(0)) == 0){
//            orderGoodsVo.setSettlePrice(goodsTotal);//商品结算平摊价格
//        }else{
//            orderGoodsVo.setSettlePrice(settlePrice);//商品结算平摊价格
//        }
//
//        return orderGoodsVo;
//    }


    @Override
    public OrderEntity queryObjectBySysUser(Long id) {
        OrderEntity orderEntity = orderDao.queryObjectBySysUser(id);

        Map<String, Object> map = new HashMap<String, Object>();
        map.put("orderId", id);
        List<OrderGoodsEntity> orderGoodsEntityList = orderGoodsDao.queryList(map);
        orderEntity.setOrderGoodsEntityList(orderGoodsEntityList);
        return orderEntity;
    }

    @Override
    public int confirmPay(Long id, String payFlag, String orderSnWx) {
        SysUserEntity user = ShiroUtils.getUserEntity();
        if (user == null) {
            throw new RRException("用户登录超时，请重新登录");
        }
        if (!user.getRoleType().equalsIgnoreCase("2")) {
            throw new RRException("该操作只允许店员账户操作");
        }
        OrderEntity orderEntity = queryObject(id);
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_201.getItem())) {
            throw new RRException("此订单已付款！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_301.getItem())) {
            throw new RRException("此订单已完成！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_101.getItem())) {
            throw new RRException("此订单已取消！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_102.getItem())) {
            throw new RRException("此订单已删除！");
        }
        orderEntity.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_201.getItem()));
        orderEntity.setPayStatus(Integer.parseInt(Dict.payStatus.item_2.getItem()));
        orderEntity.setPayFlag(payFlag);
        orderEntity.setPayTime(new Date());
        if (Dict.payFlag.item_alipay.getItem().equalsIgnoreCase(payFlag)) {
            orderEntity.setAliTradeNo(orderSnWx);
        } else {
            if (orderSnWx != null) {
                orderEntity.setOrderSnWx(orderSnWx);
            }
        }
//        Date now = new Date();
//        Integer storeId = orderEntity.getStoreId();
//        Map queryParams = new HashMap();
//        queryParams.put("orderId", orderEntity.getId());
//        List<OrderGoodsEntity> orderGoodsList = orderGoodsDao.queryList(queryParams);
//        // 遍历订单下的详情商品，修改商品的最后销售时间
//        if (orderGoodsList!=null && orderGoodsList.size()>0){
//            orderGoodsList.forEach(orderGoods ->{
//                Integer goodsId = orderGoods.getGoodsId();
//                GoodsEntity goodsEntity = goodsDao.queryObject(goodsId);
//                if (Objects.nonNull(goodsEntity)){
//                    goodsEntity.setLastSaleTime(now);
//                    goodsDao.update(goodsEntity);
//                }
//                if (Objects.nonNull(storeId)){
//                    ProductStoreRelaEntity productStoreRelaEntity = productStoreRelaDao.queryByGoodsIdAndStoreId(Long.valueOf(storeId), Long.valueOf(goodsId));
//                    if (Objects.nonNull(productStoreRelaEntity)){
//                        productStoreRelaEntity.setLastSaleTime(now);
//                        productStoreRelaDao.update(productStoreRelaEntity);
//                    }
//                }
//            });
//        }
        orderDao.update(orderEntity);
        return 0;
    }

    @Override
    public List<OrderEntity> queryExportList(Map<String, Object> map) {
        List<OrderEntity> list = orderDao.queryExportList(map);
        for (OrderEntity order : list) {
            OrderProcessRecordEntity orderProcessRecord = orderProcessRecordDao.queryObjectByOrderSn(order.getOrderSn());
            order.setOrderProcessRecord(orderProcessRecord);
            // 查询活动价
            BigDecimal topicPrice = orderDao.queryTopicPriceByOrderSnAndSku(order.getOrderSn(), order.getSku());
            order.setTopicPrice(topicPrice);
        }
        return list;
    }

    @Override
    public List<OrderEntity> queryOffilineOrderList(Map<String, Object> map) {
        return orderDao.queryOffilineOrderList(map);
    }

    /**
     * 还原查验单库存方法
     *
     * @param orderSns  查验单订单编号
     * @return          是否还原成功, true: 成功，false: 失败
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean restore(String orderSns) {

        if (org.springframework.util.StringUtils.isEmpty(orderSns)) {
            LOGGER.error("还原查验单库存，订单编号为空！");
            return false;
        }
        List<String> orderIdStrList = new ArrayList<>();
        if (orderSns.contains(",")) {
            String[] split = orderSns.split(",");
            orderIdStrList.addAll(Arrays.asList(split));
        } else {
            orderIdStrList.add(orderSns);
        }
        List<Integer> orderIdList = orderIdStrList.parallelStream().map(Integer::valueOf).collect(Collectors.toList());
        // 查询订单详细信息
        List<OrderGoodsRestoreVo> orderGoodsRestoreVos = orderGoodsService.queryListByOrderIds(orderIdList);
        List<String> orderSnList = orderGoodsRestoreVos.stream().map(OrderGoodsRestoreVo::getOrderSn).collect(Collectors.toList());
        // 查询记录表, 不能还原多次
        List<String> snList = newRetailOrderRestoreStockRecordService.queryListByOrderSnList(orderSnList);
        // 不为空则说明有订单已经被还原过, 返回失败
        if (!CollectionUtils.isEmpty(snList)) {
            LOGGER.error(String.format("订单【%s】已经还原过库存，不可继续还原！", snList));
            throw new RRException(String.format("订单【%s】已经还原过库存，不可继续还原！", snList));
        }

        // 需要更新门店商品库存(mall_product_store_rela)和园区库存(mall_goods)
        // 园区库存, 无门店概念
        List<GoodsEntity> goodsEntities = new ArrayList<>();
        // 门店商品库存
        List<ProductStoreRelaEntity> productStoreRelaEntities = new ArrayList<>();
        // 组装数据
        orderGoodsRestoreVos.forEach(orderGoodsRestoreVo -> {
            goodsEntities.add(wrapGoods(orderGoodsRestoreVo));
            productStoreRelaEntities.add(wrapProductStoreRela(orderGoodsRestoreVo));
        });

        // 还原园区库存
        goodsService.restoreBatch(goodsEntities);
        // 还原门店库存
        productStoreRelaService.restoreBatch(productStoreRelaEntities);
        LOGGER.info("还原【{}】查验订单库存成功！", orderSnList);
        // 查验完成的单已经转成保税备货，800放行后不会通知到kmall，所以需要将状态修改为已发货
        orderDao.updateOrderStatusByOrderSnList(orderSnList);
        LOGGER.info("更新【{}】查验订单状态为已发货成功！", orderSnList);
        // 添加还原记录
        List<NewRetailOrderRestoreStockRecordEntity> stockRecordEntityList = orderGoodsRestoreVos.stream().map(this::wrapRestoreRecord).collect(Collectors.toList());
        newRetailOrderRestoreStockRecordService.saveBatch(stockRecordEntityList);
        LOGGER.info("新增【{}】查验订单还原记录成功！", orderSnList);
        return true;
    }

    /**
     * 组装查验单库存还原记录实体
     * @param orderGoodsRestoreVo   实体
     * @return  查验单库存还原记录
     */
    private NewRetailOrderRestoreStockRecordEntity wrapRestoreRecord(OrderGoodsRestoreVo orderGoodsRestoreVo){
        NewRetailOrderRestoreStockRecordEntity entity = new NewRetailOrderRestoreStockRecordEntity();
        SysUserEntity user = ShiroUtils.getUserEntity();

        entity.setOrderId(orderGoodsRestoreVo.getOrderId());
        entity.setOrderSn(orderGoodsRestoreVo.getOrderSn());
        entity.setRestoreNum(orderGoodsRestoreVo.getNumber());
        entity.setStoreId(orderGoodsRestoreVo.getStoreId());
        entity.setShopName(orderGoodsRestoreVo.getShopName());
        entity.setSku(orderGoodsRestoreVo.getSku());
        entity.setCreateSn(String.valueOf(user.getUserId()));
        entity.setCreateTime(new Date());
        entity.setUpdateSn(String.valueOf(user.getUserId()));
        entity.setUpdateTime(new Date());
        entity.setStatus(Dict.stockRestoreEnum.SUCCESS.getCode());

        return entity;
    }

    /**
     * 组装成ProductStoreRelaEntity, 还原操作
     * @param orderGoodsRestoreVo   订单详细数据
     * @return  门店库存
     */
    private ProductStoreRelaEntity wrapProductStoreRela(OrderGoodsRestoreVo orderGoodsRestoreVo) {
        ProductStoreRelaEntity productStoreRelaEntity = new ProductStoreRelaEntity();
        productStoreRelaEntity.setStoreId(orderGoodsRestoreVo.getStoreId().longValue());
        productStoreRelaEntity.setSku(orderGoodsRestoreVo.getSku());
        productStoreRelaEntity.setStockNum(orderGoodsRestoreVo.getNumber());
        return productStoreRelaEntity;
    }

    /**
     * 组装成GoodsEntity, 还原操作
     * @param orderGoodsRestoreVo   订单详细数据
     * @return  库存
     */
    private GoodsEntity wrapGoods(OrderGoodsRestoreVo orderGoodsRestoreVo) {
        GoodsEntity goodsEntity = new GoodsEntity();
        goodsEntity.setGoodsNumber(orderGoodsRestoreVo.getNumber());
        goodsEntity.setSku(orderGoodsRestoreVo.getSku());
        return goodsEntity;
    }

    @Override
    public List<OrderEntity> queryPickUpCodeList(Map<String, Object> map) {
        return orderDao.queryPickUpCodeList(map);
    }

    @Override
    public int uploadExcel(List<OrderExpressDto> orderExpressDtoList) {
        SysUserEntity user = ShiroUtils.getUserEntity();
        boolean isFail = false;
        List<String> failShippingNameList = new ArrayList<>();
        List<String> failOrderSnList = new ArrayList<>();
        List<String> failShippingCodeList = new ArrayList<>();
        List<String> failCodeSnList = new ArrayList<>();
        List<String> failNameSnList = new ArrayList<>();
        List<String> failStatusOrderSnList = new ArrayList<>();
        if (orderExpressDtoList != null && orderExpressDtoList.size() > 0) {
            for (int i = 0; i < orderExpressDtoList.size(); i++) {
                OrderExpressDto orderExpressDto = orderExpressDtoList.get(i);
                OrderEntity orderEntity = new OrderEntity();
                Map<String, Object> valideDate = MapBeanUtil.fromObject(orderExpressDto);
                ImmutableBiMap.Builder builder = new ImmutableBiMap.Builder();
                builder.put("orderSn", "订单编号");
                builder.put("shippingNo", "快递单号");
                builder.put("shippingName", "快递公司");
                builder.put("shippingCode", "快递简写");
                R r = ValidatorUtil.isEmpty(builder.build(), valideDate);
                if (Integer.valueOf(r.get("code").toString()) != 0) {
                    throw new RRException(r.get("msg").toString());
                } else {
                    r = ValidatorUtil.isEmpty(builder.build(), valideDate);
                    if (Integer.valueOf(r.get("code").toString()) != 0) {
                        throw new RRException(r.get("msg").toString());
                    }
                }
                OrderEntity order = orderDao.queryObjectByOrderSn(orderExpressDto.getOrderSn());
                if (order == null) {
                    isFail = true;
                    failOrderSnList.add(orderExpressDto.getOrderSn());
                } else {
                    if (!(order.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_201.getItem())
                            && order.getPayStatus() == Integer.parseInt(Dict.payStatus.item_2.getItem()))) {
                        isFail = true;
                        failStatusOrderSnList.add(orderExpressDto.getOrderSn());
                    }
                }
                ShippingEntity shippingEntity = shippingDao.queryObjectByCode(orderExpressDto.getShippingCode());
                if (shippingEntity == null) {
                    isFail = true;
                    failShippingCodeList.add(orderExpressDto.getShippingCode());
                    failCodeSnList.add(orderExpressDto.getOrderSn());
                } else {
                    if (!orderExpressDto.getShippingName().equalsIgnoreCase(shippingEntity.getName())) {
                        isFail = true;
                        failShippingNameList.add(orderExpressDto.getShippingName());
                        failNameSnList.add(orderExpressDto.getOrderSn());
                    }
                }
                if (!isFail) {//false则有错误的数据
                    if (order != null) {// 修改商品
//                        orderEntity.setOrderSn(orderExpressDto.getOrderSn());
                        orderEntity.setShippingNo(orderExpressDto.getShippingNo());
                        orderEntity.setShippingCode(orderExpressDto.getShippingCode());
                        orderEntity.setShippingName(orderExpressDto.getShippingName());
                        orderEntity.setShippingStatus(Integer.parseInt(Dict.shippingStatus.item_1.getItem()));
                        orderEntity.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_300.getItem()));
                        orderEntity.setModerSn(user.getUsername());
                        orderEntity.setCreateTime(new Date());
                        orderEntity.setModTime(new Date());
                        orderEntity.setId(order.getId());
                        orderDao.update(orderEntity);
                    }
                }
            }
            if (failOrderSnList != null && failOrderSnList.size() > 0) {
                throw new RRException("导入数据异常，订单编号不存在，不存在的订单编号【" + failOrderSnList + "】，请删除掉再继续操作");
            }
            if (failStatusOrderSnList != null && failStatusOrderSnList.size() > 0) {
                throw new RRException("导入数据异常，修改订单快递功能只支持已付款未发货的订单，以下订单编号无效【" + failStatusOrderSnList + "】，请删除掉再继续操作");
            }
            if (failShippingCodeList != null && failShippingCodeList.size() > 0) {
                throw new RRException("导入数据异常，快递简写不在可支持的范围中，简写错误的订单编号【" + failCodeSnList + "】，错误的快递简写【" + failShippingCodeList + "】，" +
                        "正确数据可下载订单页面的快递公司简写Excel中查看");
            }
            if (failShippingNameList != null && failShippingNameList.size() > 0) {
                throw new RRException("导入数据异常，快递简写对应的快递公司不一致，快递公司错误的订单编号【" + failNameSnList + "】，请修改Excel数据中订单编号对应的快递公司错误信息，" +
                        "正确数据可下载订单页面的快递公司简写Excel中查看");
            }
//            if(failFreightGoodsSnList != null && failFreightGoodsSnList.size() > 0){
//                exportExceptionDataEntity.setExportExceptionData("运费信息请在商城配置》运费模板中维护，运费与商户信息对应，请检查该商品商户信息下的运费是否维护，不存在的商品编码【"+failFreightGoodsSnList+"】,运费【"+failFreightList+"】");
//                exportExceptionDataDao.save(exportExceptionDataEntity);
//                throw new RRException("导入数据异常，异常信息请在商品管理》》商品导入异常数据中查看检查");
//            }
        } else {
            throw new RRException("导入数据为空，或者检查商品编码数据是否为空");
        }
        return 1;
    }

    @Override
    public List<OrderEntity> promOrderList(Map<String, Object> map) {
        Integer[] statusList = {201};
        List<OrderEntity> list = orderDao.promOrderList(map);
        for (OrderEntity orderEntity : list) {
            Map<String, Object> queryMap = new HashMap<>();
            queryMap.put("goodsId", orderEntity.getGoodsId());
            queryMap.put("statusList", statusList);
            queryMap.put("orderId", orderEntity.getId());
            Double promActualPrice = orderDao.getActualPriceByOutProm(queryMap);
            if (promActualPrice == null) {
                promActualPrice = 0d;
            }
            orderEntity.setPromActualPrice(BigDecimal.valueOf(promActualPrice));
        }
        return list;
    }

    @Override
    public int queryPromOrderTotal(Map<String, Object> map) {
        return orderDao.queryPromOrderTotal(map);
    }

    @Override
    public List<OrderEntity> promOrderListExport(Map<String, Object> map) {
        Integer[] statusList = {201};
        List<OrderEntity> list = orderDao.promOrderListExport(map);
        for (OrderEntity orderEntity : list) {
            Map<String, Object> queryMap = new HashMap<>();
            queryMap.put("goodsId", orderEntity.getGoodsId());
            queryMap.put("orderId", orderEntity.getId());
            queryMap.put("statusList", statusList);
            Double promActualPrice = orderDao.getActualPriceByOutProm(queryMap);
            if (promActualPrice == null) {
                promActualPrice = 0d;
            }
            orderEntity.setPromActualPrice(BigDecimal.valueOf(promActualPrice));
        }
        return list;
    }

    @Override
    public List<OrderEntity> storeTopicOrderList(Map<String, Object> map) {
        List<OrderEntity> list = orderDao.storeTopicOrderList(map);
        return list;
    }

    @Override
    public int queryStoreTopicOrderTotal(Map<String, Object> map) {
        return orderDao.queryStoreTopicOrderTotal(map);
    }

    @Override
    public List<WxOrderEntity> wxOrderResendQueryAllList(Map<String, Object> map) {
//        String requestData = JacksonUtil.toJson(map);
        String url = OmsMerchPropertiesBuilder.instance().getWxOrderResendUrl();
        // 同步访问,返回结果字符串
        String response = OkHttpUtils.post(map, url, "SSL");
        ResponseData responseData = JacksonUtils.fromStringJson(response, ResponseData.class);
        if (responseData.getCode().equalsIgnoreCase("0")) {
            List<WxOrderEntity> list = responseData.getData().getRows();
            return list;
        }
        return null;
    }

    @Override
    public List<OrderRecognitionDto> queryOrderListByRecognition(Map<String, Object> map) {
        String value = sysConfigDao.queryByKey("FACE_COLLECT_FREQUENCY_TIME");
        if (value == null) {
            throw new RRException("请联系管理员配系统参数置FACE_COLLECT_FREQUENCY_TIME信息！");
        }
        List<OrderRecognitionDto> list = orderDao.queryOrderListByRecognition(map);
        for (OrderRecognitionDto orderRecognitionDto : list) {
            Integer frequencySecondTime = Integer.parseInt(value);
            String lastFaceTime = orderRecognitionDto.getLastFaceTime();
            if (StringUtils.isNotEmpty(lastFaceTime)) {
                Date lastFaceDate = DateUtils.convertStringToDate(lastFaceTime, DateUtils.DATE_TIME_PATTERN);
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(lastFaceDate);
                calendar.add(Calendar.SECOND, frequencySecondTime);
                Date addSecondTime = calendar.getTime();
                Date nowDate = new Date();
                if (addSecondTime.getTime() > nowDate.getTime()) {
                    orderRecognitionDto.setAddSecondTime(DateUtils.format(addSecondTime, DateUtils.DATE_TIME_PATTERN));
                    orderRecognitionDto.setIsDateLast("false");
                } else {
                    //可调用身份验证范围内
                    orderRecognitionDto.setIsDateLast("true");
                }
            } else {//可调用身份验证范围内
                orderRecognitionDto.setIsDateLast("true");
            }
        }
        return list;
    }

    @Override
    public int queryOrderListByRecognitionTotal(Map<String, Object> map) {
        return orderDao.queryOrderListByRecognitionTotal(map);
    }

    /**
     * 提交订单并付款
     *
     * @param param 提交的订单数据、包括用户信息、支付码、会话id、机器码（收银台）、取货方式、收货地址信息、会员码
     * @param user
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public synchronized Map offlineRetailSubmit(Map param, SysUserEntity user) {
        long start = System.currentTimeMillis();
        // 解析订单数据 List
        List<LinkedHashMap> goodsList = (List<LinkedHashMap>) param.get("goodsList");
        // 解析用户信息 LinkedHashMap
        Map userInfo = (Map) param.get("userInfo");
        // 解析支付码 String
        String parCode = (String) param.get("payCode");
        // 解析sessionId（WebSocket） String
        String sessionId = (String) param.get("sessionId");
        // machineCode
        String machineCode = (String) param.get("machineCode");
        //选择的方式  1柜取 0邮寄
        int status = Integer.parseInt(param.get("status").toString());
        Map<String, String> mapAddr = new HashMap<>();
        if (status == 0) {
            //省
            String cmbProvince = (String) param.get("cmbProvince");
            //市
            String cmbCity = (String) param.get("cmbCity");
            //区
            String cmbArea = (String) param.get("cmbArea");
            //详细地址
            String addrUser = (String) param.get("addrUser");

            mapAddr.put("cmbProvince", cmbProvince);
            mapAddr.put("cmbCity", cmbCity);
            mapAddr.put("cmbArea", cmbArea);
            mapAddr.put("addrUser", addrUser);
        }

        try {
            machineCode = URLDecoder.decode(machineCode, "UTF-8");
        } catch (Exception e) {
//            e.printStackTrace();
            LOGGER.error("decode machine code failed! error message : ", e);
        }
        Integer storeId = user.getStoreId();
        // 根据商品条码、sku、门店id查询相对应的商品信息，并组装成对象
        List<QueryGoodsVO> queryGoodsVOList = new ArrayList<>();
        Map<String, GoodsEntity> goodsEntityMap;
        List<GoodsEntity> goodsEntityList;
        try {
            goodsList.forEach(map -> {
                QueryGoodsVO queryGoodsVo = new QueryGoodsVO();
                queryGoodsVo.setProdBarcode((String) map.get("prodBarcode"));
                queryGoodsVo.setSku((String) map.get("goodsSn"));
                queryGoodsVo.setStoreId(storeId.longValue());
                queryGoodsVo.setSellVolume((Integer) map.get("sellVolume"));
                queryGoodsVo.setRetailPrice(new BigDecimal(String.valueOf(map.get("retailPrice"))));
                queryGoodsVo.setGoodsTaxes(new BigDecimal(String.valueOf(map.get("goodstaxes"))));
                queryGoodsVo.setDisCountedPrice(new BigDecimal(String.valueOf(map.get("discountedPrice"))));
                queryGoodsVo.setTotalPrice(new BigDecimal(String.valueOf(map.get("actualPaymentAmount"))));
                queryGoodsVo.setActivity((String) map.get("activity"));
                queryGoodsVo.setDeductionScore((Integer) map.get("deductionScore"));
                Object deductionPriceObj = map.get("deductionPrice");
                BigDecimal deductionPrice = BigDecimal.ZERO;
                if (Objects.nonNull(deductionPriceObj)) {
                    deductionPrice = new BigDecimal(deductionPriceObj.toString());
                }
                queryGoodsVo.setDeductionPrice(deductionPrice);
                queryGoodsVOList.add(queryGoodsVo);
            });
            // 将在循环中查询数据库改为一次性查询
            goodsEntityList = goodsService.queryGoodsStockByQueryGoodsVoList(queryGoodsVOList);
            goodsEntityMap = goodsEntityList.stream().collect(Collectors.toMap(GoodsEntity::getSku, Function.identity(), (k1, k2) -> k2));
        } catch (Exception e){
            LOGGER.error("组装查询商品数据或查询商品数据时出现异常！", e);
            throw new ServiceException(e);
        }

        Map resultObj = Maps.newHashMap();
        // 海控需求，下单流程修改，收银端接收会员码，付款码，用户信息，订单数据
        // 1. 校验库存：保税仓库存 + 展销店库存 - 出区数 >= 购买数
        /* -----------------↓--------------生产请打开注释-------------------↓------------ */
        /*WareQueryStockParamDTO wareQueryStockParamDTO = new WareQueryStockParamDTO();
        List<Criteria> criteriaList = new ArrayList<>();
        goodsList.forEach(goods -> {
            Criteria criteria = new Criteria();
            String sku = (String) goods.get("goodsSn");
            criteria.setItemCode(sku);
            GoodsEntity goodsEntity = goodsEntityMap.get(sku);
            criteria.setItemId(goodsEntity.getWarehousSysGoodId());
            criteria.setWarehouseCode(goodsEntity.getWarehouseSn());
            criteria.setOwnerCode(goodsEntity.getConsignorSn());
            criteria.setInventoryType(Constants.InventoryType.ZP.getType());
            criteriaList.add(criteria);
        });
        wareQueryStockParamDTO.setCriteriaList(criteriaList);
        String queryWarehouseStockResponse = null;
        try {
            queryWarehouseStockResponse = haiKongWarehouseTemplate.queryWarehouseStock(wareQueryStockParamDTO);
        } catch (Exception e) {
            LOGGER.error("下单调用海控仓库系统查询库存出现异常！", e);
            throw new ServiceException(String.format("下单调用海控仓库系统查询库存出现异常！"));
        }
        if (org.springframework.util.StringUtils.isEmpty(queryWarehouseStockResponse)) {
            LOGGER.error("调用库存系统接口出现错误！返回结果为空！");
            throw new ServiceException("调用库存系统接口出现错误！");
        }
        WareQueryStockResponseDTO wareQueryStockResponseDTO = JacksonUtil.fromStringJson(queryWarehouseStockResponse, WareQueryStockResponseDTO.class);
        if (Objects.isNull(wareQueryStockResponseDTO)) {
            throw new ServiceException("解析一步达库存系统响应数据出现错误！");
        }
        List<WareQueryStockResponseDTO.WareQueryStockResponseItemDTO> items = wareQueryStockResponseDTO.getItems();
        // 解析xml，组装成map key=>sku value=>库存
        Map<String, Integer> stockMap = new HashMap<>(16);
        items.forEach(item -> {
            String itemCode = item.getItemCode();
            Integer quantity = item.getQuantity();
            if (stockMap.containsKey(itemCode)) {
                // 避免出现sku相同情况
                stockMap.put(itemCode, stockMap.get(itemCode) + quantity);
            } else {
                stockMap.put(itemCode, quantity);
            }
        });*/
        /* -----------------↑--------------生产请打开注释------------------↑------------- */

        /* -----------------↓--------------测试数据，生产请注释-------------------↓------------ */
        Map<String, Integer> stockMap = new HashMap<>(16);
        goodsList.forEach(goods -> {
            String sku = (String) goods.get("goodsSn");
            if (stockMap.containsKey(sku)) {
                // 避免出现sku相同情况
                stockMap.put(sku, stockMap.get(sku) + 3);
            } else {
                stockMap.put(sku, 3);
            }
        });
        /* -----------------↑--------------测试数据，生产请注释------------------↑------------- */

        try {
            if (user == null) {
                resultObj.put("errno", 400);
                resultObj.put("errmsg", "用户登录超时，请重新登录");
                return resultObj;
            }
            if (!user.getRoleType().equalsIgnoreCase("2")) {
                resultObj.put("errno", 400);
                resultObj.put("errmsg", "该操作只允许店员账户操作");
                return resultObj;
            }
            if (org.apache.commons.lang3.StringUtils.isEmpty(user.getMerchSn())) {
                resultObj.put("errno", 400);
                resultObj.put("errmsg", "操作用户的商户编号为空，请先维护用户商户编号信息再来操作");
                return resultObj;
            }
            Long userId = user.getUserId();

            List<GoodsEntity> goodsEntities = new ArrayList<>();

            BigDecimal totalTax = new BigDecimal(0);

            // 复制集合数据
            ListUtils listUtils = BeanUtils.instantiate(ListUtils.class);
            listUtils.copyList(goodsEntityList, queryGoodsVOList);

            //生成商户订单号
            SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
            String orderSn = "ZMHK" + format.format(new Date()) + CommonUtil.generateOrderNumber();
            // 检查库存和更新库存
            for (QueryGoodsVO goodsDto : queryGoodsVOList) {
                // 要购买的数量
                Integer sellVolume = goodsDto.getSellVolume();
                String prodBarcode = goodsDto.getProdBarcode();
                String sku = goodsDto.getSku();
                // 园区库存
                Integer goodsNumber = goodsDto.getGoodsNumber();
                // 门店库存
                Integer stockNum = goodsDto.getStockNum();
                // 仓库库存可用库存数
                Integer warehouseStock = stockMap.get(sku);

                // 判断库存
                if (stockMap.containsKey(sku)) {
                    // 当前出区数
                    Integer exitRegionNumber = goodsDto.getExitRegionNumber();
                    // 保税仓库存 + 门店库存 - 出区数 > 购买数
                    if (!((warehouseStock + stockNum) - exitRegionNumber > sellVolume)) {
                        // 库存不足
                        LOGGER.error("sku：【{}】库存不足，门店可用库存：【{}】，仓库可用库存：【{}】，购买数量：【{}】", sku, stockNum, warehouseStock, sellVolume);
                        throw new ServiceException(String.format("sku：【%s】库存不足，门店可用库存：【%s】，仓库可用库存：【%s】，购买数量：【%s】", sku, stockNum, warehouseStock, sellVolume));
                    }
                    // TODO 库存变化记录新增字段：订单号、门店编号
                    // 门店库存变化记录
                    StoreMngChangeEntity storeMngChangeEntity = new StoreMngChangeEntity();
                    storeMngChangeEntity.setChangeType(Dict.changeType.item_1.getItem());
                    storeMngChangeEntity.setOrderSn(orderSn);
                    storeMngChangeEntity.setChangeReason("商品销售扣减");
                    storeMngChangeEntity.setGoodsId(goodsDto.getId().intValue());
                    storeMngChangeEntity.setStoreId(Integer.parseInt(String.valueOf(goodsDto.getStoreId())));
                    storeMngChangeEntity.setMerchSn(goodsDto.getMerchSn());
                    storeMngChangeEntity.setStoreChangeNum(sellVolume);
                    storeMngChangeEntity.setStoreOriginalNum(stockNum);
                    storeMngChangeEntity.setStoreValidNum(stockNum - sellVolume);
                    storeMngChangeEntity.setCreateTime(new Date());
                    storeMngChangeEntity.setModTime(new Date());
                    storeMngChangeEntity.setCreaterSn(user.getUsername());
                    storeMngChangeEntity.setModerSn(user.getUsername());
                    storeMngChangeEntity.setIsValid(0);
                    storeMngChangeDao.save(storeMngChangeEntity);

                    int validNum = stockNum - sellVolume;
                    // 园区库存变化记录，不计销售扣减
                    /*MngChangeEntity mngChangeEntity = new MngChangeEntity();
                    mngChangeEntity.setThirdPartyMerchCode(goodsDto.getThirdPartyMerchCode());
                    mngChangeEntity.setChangeReason("商品销售扣减");
                    mngChangeEntity.setCreateTime(new Date());
                    mngChangeEntity.setModTime(new Date());
                    mngChangeEntity.setCreaterSn(user.getUsername());
                    mngChangeEntity.setModerSn(user.getUsername());
                    mngChangeEntity.setIsValid(0);
                    mngChangeEntity.setMerchSn(goodsDto.getMerchSn());
                    mngChangeEntity.setOriginalNum(goodsNumber);//原库存数
                    mngChangeEntity.setValidNum(goodsNumber - sellVolume);//可用数
                    mngChangeEntity.setChangeNum(sellVolume);//变化数
                    mngChangeEntity.setChangeType(Dict.changeType.item_1.getItem());
                    mngChangeEntity.setGoodsId(goodsDto.getId().intValue());

                    mngChangeDao.save(mngChangeEntity);*/

                    // 如果园区库存数量小于等于0, 则不更新园区库存, 园区库存只做参考
                    int diff = Math.max(goodsNumber - sellVolume, 0);
                    GoodsEntity goodsEntity = new GoodsEntity();
                    BeanUtils.copyProperties(goodsDto, goodsEntity);
                    goodsEntity.setGoodsNumber(diff);
                    goodsEntity.setLastSaleTime(new Date());
                    goodsService.updateStockNumberByProductCodeAndSku(goodsEntity);
                    // 门店库存
                    ProductStoreRelaEntity productStoreRelaEntity = new ProductStoreRelaEntity();
                    BeanUtils.copyProperties(goodsDto, productStoreRelaEntity);
                    productStoreRelaEntity.setStockNum(validNum);
                    productStoreRelaEntity.setStoreId(storeId.longValue());
                    productStoreRelaEntity.setSellVolume(sellVolume);
                    productStoreRelaEntity.setLastSaleTime(new Date());
                    productStoreRelaService.updateStockNumByStoreIdAndSku(productStoreRelaEntity);//修改普通商品库存

                    BigDecimal retailPrice = goodsDto.getRetailPrice(); // 单价
                    BigDecimal storeRetailPrice = goodsDto.getRetailPrice(); // 单价
                    // 优惠价
                    BigDecimal disCountedPrice = goodsDto.getDisCountedPrice();
                    // 实际支付价
                    BigDecimal actualPaymentAmount = goodsDto.getTotalPrice();

                    goodsEntity = new GoodsEntity();
                    BeanUtils.copyProperties(goodsDto, goodsEntity);
                    goodsEntity.setRetailPrice(retailPrice);
                    goodsEntity.setStoreRetailPrice(storeRetailPrice);
                    goodsEntity.setDiscountedPrice(disCountedPrice);
                    goodsEntity.setActualPaymentAmount(goodsDto.getTotalPrice());
                    goodsEntity.setSellVolume(goodsDto.getSellVolume());
                    goodsEntity.setActivity(goodsDto.getActivity());
                    goodsEntity.setStoreId(storeId);
                    goodsEntity.setListPicUrl(goodsDto.getListPicUrl());
                    GoodsEntity goodsEntity1 = goodsEntityMap.get(sku);
                    if (Objects.nonNull(goodsEntity1)) {
                        goodsEntity.setWarehouseSn(goodsEntity1.getWarehouseSn());
                        goodsEntity.setConsignorSn(goodsEntity1.getConsignorSn());
                        goodsEntity.setWarehousSysGoodId(goodsEntity1.getWarehousSysGoodId());
                        goodsEntity.setInventoryType(goodsEntity1.getInventoryType());
                        goodsEntity.setDefectiveProductsGrade(goodsEntity1.getDefectiveProductsGrade());
                        goodsEntity.setCategoryId(goodsEntity1.getCategoryId());
                    }
                    goodsEntity.setDeductionScore(goodsDto.getDeductionScore());
                    goodsEntity.setDeductionPrice(goodsDto.getDeductionPrice());
                    goodsEntities.add(goodsEntity);
                } else {
                    // sku不存在
                    LOGGER.error("库存系统中不包含此sku：【{}】，校验库存出错！下单失败！", sku);
                    throw new ServiceException(String.format("库存系统中不包含此sku：【%s】，下单失败！", sku));
                }

                // 计算该购物车所需要的所有税费
                BigDecimal tax = goodsDto.getGoodsTaxes();
                totalTax = totalTax.add(tax).setScale(2, BigDecimal.ROUND_HALF_DOWN); // 计算总的税额
            }

            String openId = (String) param.get("openId");
            String memberCode = (String) param.get("memberCode");
            UserEntity userEntity = userDao.queryByMobile((String) userInfo.get("customPhone"));
            if (userEntity == null) {
                // 保存用户信息
                userEntity = new UserEntity();
                userEntity.setUsername((String) userInfo.get("customName"));
                userEntity.setPassword("");
                userEntity.setIdNo((String) userInfo.get("customIDCard"));
                userEntity.setMobile((String) userInfo.get("customPhone"));
                userEntity.setGender(1);
                userEntity.setRegisterTime(new Date());
                userEntity.setLastLoginTime(new Date());
                userEntity.setIdNo((String) userInfo.get("customIDCard"));
                userEntity.setOpenId(openId);
                userEntity.setMemberCode(memberCode);
                userDao.save(userEntity);

                MerchUserEntity merchUserEntity = new MerchUserEntity();
                merchUserEntity.setMerchSn(user.getMerchSn());
                merchUserEntity.setStoreId(storeId);
                merchUserEntity.setUserId(userEntity.getId());
                merchUserEntity.setCreateTime(new Date());
                merchUserEntity.setIsLoadGoods("0");
                merchUserDao.save(merchUserEntity);
            } else {
                userEntity.setUsername((String) userInfo.get("customName"));
                userEntity.setIdNo((String) userInfo.get("customIDCard"));
                userEntity.setMobile((String) userInfo.get("customPhone"));
                if (!org.springframework.util.StringUtils.isEmpty(openId)) {
                    userEntity.setOpenId(openId);
                }
                if (!org.springframework.util.StringUtils.isEmpty(memberCode)) {
                    userEntity.setMemberCode(memberCode);
                }
                userDao.update(userEntity);
            }

            // 判断该用户是否是生日
            /*Boolean isBirth = false;
            String birthday = "";
            if (userEntity.getIdNo().length() == 15) {
                birthday = userEntity.getIdNo().substring(8, 10) + "-" + userEntity.getIdNo().substring(10, 12);
            } else if (userEntity.getIdNo().length() == 18) {
                birthday = userEntity.getIdNo().substring(10, 12) + "-" + userEntity.getIdNo().substring(12, 14);
            }

            SimpleDateFormat format = new SimpleDateFormat("MM-dd");
            String today = format.format(new Date());
            if (birthday.equalsIgnoreCase(today)) {
                isBirth = true;
            }*/
            // 生成订单
            String merchOrderSn = "EMATO" + CommonUtil.generateOrderNumber();
            BigDecimal actualPrice = new BigDecimal((String) param.get("actualPrice"));
            // OrderVo order = setOrderVo(goodsEntities, userEntity, storeId.longValue(), user.getMerchSn(), disCountAmount, totalTax, status, mapAddr);
            OrderVo order = setOrderVo(goodsEntities, userEntity, storeId.longValue(), user.getMerchSn(), totalTax, status, mapAddr, actualPrice);
            order.setOrder_sn(orderSn);
            order.setStore_id(storeId.longValue());
            String couponSn = (String) userInfo.get("couponSn");
            order.setMerchOrderSn(merchOrderSn);
            order.setCoupon_name(couponSn); // 借用这个字段来记录是否使用优惠券
            order.setIdCard(userEntity.getIdNo());
            //插入订单信息和订单商品
            orderDao.saveOrderVo(order);

            // 订单流转表
            OrderProcessRecordEntity processRecordEntity = new OrderProcessRecordEntity();
            processRecordEntity.setOrderSn(order.getOrder_sn());
            processRecordEntity.setUserId(Integer.valueOf(userEntity.getId() + ""));
            processRecordEntity.setAddOrderStartTime(order.getCreateTime());

            processRecordEntity.setIsAddOrderSend(Dict.isSend.item_1.getItem());
            processRecordEntity.setOrderBizType(Dict.orderBizType.item_10.getItem());

            if (null == order.getId()) {
                resultObj.put("errno", 400);
                resultObj.put("errmsg", "订单提交失败");
                return resultObj;
            }

            List<OrderGoodsVo> orderGoodsVoList = goodsEntities.stream().map(goodsEntity -> setOrderGoodsVo(order, goodsEntity)).collect(Collectors.toList());
            // 批量保存订单详情
            orderGoodsService.saveBatchOrderDetail(orderGoodsVoList);

            //清空预订单商品临时表
            Map orderInfoMap = Maps.newHashMap();
            orderInfoMap.put("orderInfo", order);
            resultObj.put("errno", 0);
            resultObj.put("errmsg", "订单提交成功");
            resultObj.put("data", orderInfoMap);

            //判断支付类型，并支付订单
            R r = null;
            //保存支付记录
            OrderWXPayRecordEntity orderWXPayRecordCurrent = orderWXPayRecordService.saveRecordVo(order);

            StoreEntity store = storeService.queryObject(order.getStore_id().intValue());

            processRecordEntity.setPaymentStartTime(new Date());

            String env = environment.getProperty("haikong.env");
            // 判断是微信的支付码还是支付宝的支付码
            env = "prod";
            if (!org.springframework.util.StringUtils.isEmpty(env) && Constants.PROD.equals(env)) {
                if (parCode.startsWith("28")) {
                    // 支付宝支付
                    throw new ServiceException("目前暂不支持支付宝付款！请使用微信进行支付！");
                    /*try {
                        AliPay(user, parCode, order, processRecordEntity, orderWXPayRecordCurrent, store);
                    } catch (Exception e) {
                        LOGGER.error("支付宝支付出现异常！订单号：【{}】", order.getOrder_sn(), e);
                        throw e;
                    }*/
                } else {
                    // 微信支付
                    try {
                        wxPay(user, parCode, resultObj, order, processRecordEntity, orderWXPayRecordCurrent, store);
                    } catch (Exception e) {
                        e.printStackTrace();
                        throw e;
                    }
                }
            } else {
                OrderEntity orderEntity = queryObject(order.getId());
                orderEntity.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_201.getItem()));
                orderEntity.setPayStatus(Integer.parseInt(Dict.payStatus.item_2.getItem()));
                orderEntity.setPayTime(new Date());
                orderDao.update(orderEntity);
            }

            processRecordEntity.setPaymentStartTime(new Date());

            resultObj.put("shopName", store.getStoreName()); // 根据门店编号查询
            resultObj.put("userName", user.getUsername());

            // 保存订单流转表
            // 设置下单完成时间
            processRecordEntity.setAddOrderSuccTime(order.getPay_time());
            // 设置其他开始时间
            Date date = new Date();
            processRecordEntity.setPaymentStartTime(date);
            processRecordEntity.setEleOrderStartTime(date);
            processRecordEntity.setWaybillStartTime(date);

            orderProcessRecordDao.save(processRecordEntity);


            // 生成销售记录
            SaleRecordEntity saleRecordEntity = new SaleRecordEntity();

            // 根据收银机机器码，查询收银机
            CashierEntity cashierEntity = cashierDao.queryByMachineCode(machineCode, storeId + "");
            if (cashierEntity != null) {
                saleRecordEntity.setCashierSn(cashierEntity.getCashierSn());
                saleRecordEntity.setOrderSn(order.getOrder_sn());
                saleRecordEntity.setSallerId(userId + "");
                saleRecordEntity.setSalesTime(new Date());
                saleRecordEntity.setCreateTime(new Date());
                saleRecordDao.save(saleRecordEntity);
            }

            // 查询当前时间积分规则以及明细，根据积分生成规则进行增加会员积分
            Integer userEntityId = userEntity.getId();
            // 总的积分：基础积分
            AtomicReference<Integer> memberScore = new AtomicReference<>(0);
            // 无会员码，不参与积分赠送
            Map<String, OrderGiftScoreRulesVo> giftGoodsScoreDetailMap = new HashMap<>();
            if (!org.springframework.util.StringUtils.isEmpty(memberCode)) {
                List<PointsRulesAndDetailVO> pointsRulesAndDetailVOList = mall2PointsRulesService.queryListByTime(new Date());
                // 商品map，key===>sku value===>金额
                Map<String, BigDecimal> goodsMap = goodsEntities.stream().collect(Collectors.toMap(GoodsEntity::getSku, GoodsEntity::getActualPaymentAmount, (k1, k2) -> k2));
                // 商品数据map，key===>sku value===>商品实体
                Map<String, GoodsEntity> goodsDataMap = goodsEntities.stream().collect(Collectors.toMap(GoodsEntity::getSku, goodsEntity -> goodsEntity, (k1, k2) -> k2));
                // 订单全部的sku
                Set<String> goodsSkuList = goodsMap.keySet();
                // 订单全部商品的分类列表，只有二级分类才能设置生成规则
                Set<Integer> categorySet = goodsEntities.stream().map(GoodsEntity::getCategoryId).collect(Collectors.toSet());
                pointsRulesAndDetailVOList.forEach(pointsRulesAndDetailVO -> {
                    Integer pointsType = pointsRulesAndDetailVO.getPointsType();
                    // 可以是sku、门店id、分类id
                    String pointsDetailNameId = pointsRulesAndDetailVO.getPointsDetailNameId();
                    // 积分比例
                    BigDecimal ratio = pointsRulesAndDetailVO.getRatio();
                    if (pointsType.equals(Constants.MemberScoreRulesEnum.TWO.getCode())) {
                        // 商品，优先级最高，查询
                        if (goodsSkuList.contains(pointsDetailNameId)) {
                            // 商品积分生成规则包含这个sku
                            // 订单中该sku的总金额
                            BigDecimal money = goodsMap.get(pointsDetailNameId);
                            OrderGiftScoreRulesVo orderGiftScoreRulesVo = new OrderGiftScoreRulesVo();
                            orderGiftScoreRulesVo.setGenerateType(Constants.MemberScoreRulesEnum.TWO.getCode());
                            if (ratio.compareTo(BigDecimal.ZERO) > 0) {
                                // 算出所积的分
                                int giftScore = money.multiply(ratio).add(new BigDecimal(memberScore.get())).intValue();
                                memberScore.set(giftScore);
                                orderGiftScoreRulesVo.setGiftScore(giftScore);
                                orderGiftScoreRulesVo.setGenerateRatio(ratio);
                            } else {
                                // 积分比例设置为0，该商品不记积分。
                                LOGGER.info("商品SKU：【{}】，积分生成规则设置积分比例为：{}，故不产生积分！", pointsDetailNameId, ratio);
                                orderGiftScoreRulesVo.setGiftScore(0);
                                orderGiftScoreRulesVo.setGenerateRatio(BigDecimal.ZERO);
                            }
                            giftGoodsScoreDetailMap.put(pointsDetailNameId, orderGiftScoreRulesVo);
                            goodsDataMap.remove(pointsDetailNameId);
                        }

                    }
                    if (pointsType.equals(Constants.MemberScoreRulesEnum.ONE.getCode())) {
                        Collection<GoodsEntity> goodsEntityCollection = goodsDataMap.values();
                        goodsEntityCollection.forEach(goodsEntity -> {
                            // 商品类别
                            Integer categoryId = goodsEntity.getCategoryId();
                            String sku = goodsEntity.getSku();
                            OrderGiftScoreRulesVo orderGiftScoreRulesVo = new OrderGiftScoreRulesVo();
                            orderGiftScoreRulesVo.setGenerateType(Constants.MemberScoreRulesEnum.ONE.getCode());
                            if (categorySet.contains(categoryId)) {
                                if (categoryId.equals(Integer.parseInt(pointsDetailNameId))) {
                                    // 订单中该sku的总金额
                                    BigDecimal money = goodsMap.get(sku);
                                    if (ratio.compareTo(BigDecimal.ZERO) > 0) {
                                        // 算出所积的分
                                        int giftScore = money.multiply(ratio).add(new BigDecimal(memberScore.get())).intValue();
                                        memberScore.set(giftScore);
                                        orderGiftScoreRulesVo.setGiftScore(giftScore);
                                        orderGiftScoreRulesVo.setGenerateRatio(ratio);
                                    } else {
                                        // 积分比例设置为0，该商品不记积分。
                                        LOGGER.info("分类：【{}】，积分生成规则设置积分比例为：{}，故不产生积分！", pointsDetailNameId, ratio);
                                        orderGiftScoreRulesVo.setGiftScore(0);
                                        orderGiftScoreRulesVo.setGenerateRatio(BigDecimal.ZERO);
                                    }
                                    giftGoodsScoreDetailMap.put(sku, orderGiftScoreRulesVo);
                                    goodsDataMap.remove(sku);
                                }
                            }
                        });
                    }
                    if (pointsType.equals(Constants.MemberScoreRulesEnum.ZERO.getCode())) {
                        // 门店
                        Collection<GoodsEntity> goodsEntityCollection = goodsDataMap.values();
                        goodsEntityCollection.forEach(goodsEntity -> {
                            Integer storeId1 = goodsEntity.getStoreId();
                            String sku = goodsEntity.getSku();
                            OrderGiftScoreRulesVo orderGiftScoreRulesVo = new OrderGiftScoreRulesVo();
                            orderGiftScoreRulesVo.setGenerateType(Constants.MemberScoreRulesEnum.ZERO.getCode());
                            if (storeId.equals(storeId1)) {
                                // 订单中该sku的总金额
                                BigDecimal money = goodsMap.get(sku);
                                if (ratio.compareTo(BigDecimal.ZERO) != 0) {
                                    // 算出所积的分
                                    int giftScore = money.multiply(ratio).add(new BigDecimal(memberScore.get())).intValue();
                                    memberScore.set(giftScore);
                                    orderGiftScoreRulesVo.setGiftScore(giftScore);
                                    orderGiftScoreRulesVo.setGenerateRatio(ratio);
                                } else {
                                    // 积分比例设置为0，该商品不记积分。
                                    LOGGER.info("门店：【{}】，积分生成规则设置积分比例为：{}，故不产生积分！", pointsDetailNameId, ratio);
                                    orderGiftScoreRulesVo.setGiftScore(0);
                                    orderGiftScoreRulesVo.setGenerateRatio(BigDecimal.ZERO);
                                }
                            }
                            giftGoodsScoreDetailMap.put(sku, orderGiftScoreRulesVo);
                        });
                    }
                });
                goodsSkuList.forEach(s -> {
                    if (!giftGoodsScoreDetailMap.containsKey(s)) {
                        OrderGiftScoreRulesVo orderGiftScoreRulesVo = new OrderGiftScoreRulesVo();
                        orderGiftScoreRulesVo.setGiftScore(0);
                        orderGiftScoreRulesVo.setGenerateRatio(BigDecimal.ZERO);
                        orderGiftScoreRulesVo.setGenerateType(3);
                        giftGoodsScoreDetailMap.put(s, orderGiftScoreRulesVo);
                    }
                });

                // 增加该会员的积分
                Mall2MemberPointsEntity memberPointsEntity = memberPointsDao.queryByUserId(userEntityId);
                if (memberPointsEntity == null) {
                    memberPointsEntity = new Mall2MemberPointsEntity();
                    memberPointsEntity.setUserId(userEntityId + "");
                    memberPointsEntity.setPoints(memberScore.get());
                    memberPointsEntity.setCreaterSn(userId + "");
                    memberPointsEntity.setCreateTime(new Date());
                    memberPointsDao.save(memberPointsEntity);
                } else {
                    memberPointsEntity.setPoints(memberScore.get() + memberPointsEntity.getPoints());
                    memberPointsEntity.setModerSn(userId + "");
                    memberPointsEntity.setModTime(new Date());
                    Integer point = 0;
                    if (Objects.isNull(memberPointsEntity.getPoints())) {
                        point = memberScore.get();
                    } else {
                        point = memberPointsEntity.getPoints() + memberScore.get();
                    }
                    memberPointsEntity.setPoints(point);
                    memberPointsDao.update(memberPointsEntity);
                }
            }

            // 增加该会员的消费记录
            Mall2MemberConsumptionRecordsEntity consumptionRecords = new Mall2MemberConsumptionRecordsEntity();
            consumptionRecords.setUserId(userEntity.getId() + "");
            consumptionRecords.setOrderSn(order.getOrder_sn());
            consumptionRecords.setConsumptionTime(new Date());
            consumptionRecords.setShopSn(String.valueOf(storeId));
            // 积分消费记录
            Integer beforeScoreInteger = (Integer) param.get("beforeScore");
            Integer afterScoreStrInteger = (Integer) param.get("afterScore");
            int deductionScore = org.springframework.util.StringUtils.isEmpty((String) param.get("deductionScore")) ? 0 : Integer.parseInt((String) param.get("deductionScore"));
            String memberPhone = String.valueOf(param.get("memberPhone"));
            BigDecimal scoreDeductionPrice = new BigDecimal(org.springframework.util.StringUtils.isEmpty(param.get("scoreDeductionPrice").toString()) ? "0" : param.get("scoreDeductionPrice").toString());
            consumptionRecords.setBeforeScore(beforeScoreInteger);
            consumptionRecords.setAfterScore(afterScoreStrInteger);
            consumptionRecords.setOrderTotalPrice(order.getActual_price());
            consumptionRecords.setScoreDeductionPrice(scoreDeductionPrice);
            consumptionRecords.setMemberCode(memberCode);
            consumptionRecords.setMemberPhone(memberPhone);
            consumptionRecords.setOrderGiftScore(memberScore.get());
            consumptionRecords.setDeductionScore(deductionScore);
            consumptionRecords.setCreaterSn(userId + "");
            consumptionRecords.setCreateTime(new Date());
            memberConsumptionRecordsDao.save(consumptionRecords);

            if (!org.springframework.util.StringUtils.isEmpty(memberCode)) {
                // 同步会员订单消费记录
                syncMemberConsumeRecord(memberPhone, order, deductionScore);
                syncMemberScoreChangeRecord(openId, order, deductionScore, "下单扣减", queryGoodsVOList, giftGoodsScoreDetailMap, HaiKongMemberScoreChangeEventEnum.SUBTRACT.getEvent());
                // 积分变动接口，下单扣减
                Integer score = memberScore.get();
                syncMemberScoreChangeRecord(openId, order, score, "下单赠送", queryGoodsVOList, giftGoodsScoreDetailMap, HaiKongMemberScoreChangeEventEnum.ADD.getEvent());
            }

            // 生成取票码
            PickUpCodeEntity pickUpCodeEntity = new PickUpCodeEntity();
            pickUpCodeEntity.setOrderSn(order.getOrder_sn());
            pickUpCodeEntity.setPickUpCodeSn(cashierEntity.getCashierSn());//小票码前段
            pickUpCodeService.save(pickUpCodeEntity);

            resultObj.put("code", pickUpCodeEntity.getPickUpCodeSn()); // 系统中累加

            resultObj.put("time", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            resultObj.put("orderNo", order.getOrder_sn()); //

            resultObj.put("phone", (String) userInfo.get("customPhone"));
            // 通知WebSocket
            WebSocketServer.sendMessage(sessionId, order.getOrder_sn(), order.getStore_id()
                    + "");

            JedisUtil.del(Constants.WAREHOUSE_STOCK_MAP_KEY + "_" + storeId);


            if (org.springframework.util.StringUtils.isEmpty(env) && Constants.TEST.equals(env)) {
                order.setPayApp("wxpay");
                order.setRequest("1111111111111111111");
                order.setResponse("2222222222222222222");
            }

            // 推单
            sendOrderInfoToVmcShop(order, orderGoodsVoList);

            LOGGER.info("----------------------------------------------------------------------------");
            LOGGER.info("下单耗时：{}ms", (System.currentTimeMillis()) - start);
            LOGGER.info("----------------------------------------------------------------------------");
            return resultObj;
        } catch (Exception e) {
            e.printStackTrace();
            resultObj.put("errno", 400);
            resultObj.put("errmsg", "订单异常------" + e.getMessage());
            throw new RuntimeException(e);
        }
    }

    /**
     * 免税mall创建订单
     * @param order             订单信息：包含订单信息，支付信息，跨境信息
     * @param orderGoodsVoList  订单详情数据
     */
    private void sendOrderInfoToVmcShop(OrderVo order, List<OrderGoodsVo> orderGoodsVoList) {
        SendOrderToVmcShopDTO sendOrderToVmcShopDTO = new SendOrderToVmcShopDTO();

        OrderInfoDTO orderInfoDTO = wrapOrderInfo(order);
        PayInfoDTO payInfoDTO = wrapPayInfo(order);
        SeaportInfoDTO seaportInfoDTO = wrapSeaportInfo(order);
        List<OrderProductInfoDTO> orderProductInfoDTOList = orderGoodsVoList.stream().map(this::wrapOrderProductInfo).collect(Collectors.toList());
        seaportInfoDTO.setOrderProductInfoList(orderProductInfoDTOList);
        List<OrderInfoItemDTO> orderInfoItemDTOList = orderGoodsVoList.stream().map(this::wrapOrderInfoItem).collect(Collectors.toList());

        sendOrderToVmcShopDTO.setOrderInfo(orderInfoDTO);
        sendOrderToVmcShopDTO.setOrderInfoItems(orderInfoItemDTOList);
        sendOrderToVmcShopDTO.setSeaportInfo(seaportInfoDTO);
        sendOrderToVmcShopDTO.setPayInfo(payInfoDTO);

        HaiKongSendOrderInfoRecordEntity haiKongSendOrderInfoRecordEntity = wrapSendOrderInfoRecord(sendOrderToVmcShopDTO);
        List<HaiKongSendOrderInfoDetailRecordEntity> detailRecordEntities = wrapSendOrderInfoDetailRecord(orderInfoItemDTOList);

        // 不要用自带的工具类，处理XML字符串时有bug
        cn.hutool.json.JSON json = JSONUtil.parse(sendOrderToVmcShopDTO);
        String body = JSONUtil.toJsonPrettyStr(json);

        String orderSn = order.getOrder_sn();
        try {

            String response = vmcShopTemplate.sendOrder(body);

            Response<String> r = JacksonUtil.fromListJson(response, new TypeReference<Response<String>>() {});

            if (Objects.nonNull(r) && !"failure".equals(r.getResult())) {
                pickUpCodeService.updatePickUpCodeStatusByOrderSn(orderSn, Dict.PickUpCodeStatusEnum.item_0.getStatus());
                haiKongSendOrderInfoRecordEntity.setResendStatus(HaiKongMemberOrderResendStatusEnum.NON_RESEND.getStatus());
                LOGGER.info("推送订单到免税mall成功！响应结果：{}", response);
            } else {
                pickUpCodeService.updatePickUpCodeStatusByOrderSn(orderSn, Dict.PickUpCodeStatusEnum.item_6.getStatus());
                haiKongSendOrderInfoRecordEntity.setResendStatus(HaiKongMemberOrderResendStatusEnum.WAIT_RESEND.getStatus());
                LOGGER.error("推送订单到免税mall失败！响应结果：{}", response);
            }
        } catch (Exception e) {
            pickUpCodeService.updatePickUpCodeStatusByOrderSn(orderSn, Dict.PickUpCodeStatusEnum.item_6.getStatus());
            haiKongSendOrderInfoRecordEntity.setResendStatus(HaiKongMemberOrderResendStatusEnum.WAIT_RESEND.getStatus());
            LOGGER.error("推送订单到免税mall失败！出现异常！", e);
        }

        haiKongSendOrderInfoRecordService.save(haiKongSendOrderInfoRecordEntity);
        haiKongSendOrderInfoDetailRecordService.saveBatch(detailRecordEntities);
    }

    private List<HaiKongSendOrderInfoDetailRecordEntity> wrapSendOrderInfoDetailRecord(List<OrderInfoItemDTO> orderInfoItemDTOList) {
        return orderInfoItemDTOList.stream().map(orderInfoItemDTO -> {
            HaiKongSendOrderInfoDetailRecordEntity entity = new HaiKongSendOrderInfoDetailRecordEntity();
            BeanUtils.copyProperties(orderInfoItemDTO, entity);
            entity.setIsTax(orderInfoItemDTO.getTax().toString());
            return entity;
        }).collect(Collectors.toList());
    }

    private HaiKongSendOrderInfoRecordEntity wrapSendOrderInfoRecord(SendOrderToVmcShopDTO sendOrderToVmcShopDTO) {
        HaiKongSendOrderInfoRecordEntity entity = new HaiKongSendOrderInfoRecordEntity();
        OrderInfoDTO orderInfo = sendOrderToVmcShopDTO.getOrderInfo();
        PayInfoDTO payInfo = sendOrderToVmcShopDTO.getPayInfo();
        SeaportInfoDTO seaportInfo = sendOrderToVmcShopDTO.getSeaportInfo();

        BeanUtils.copyProperties(orderInfo, entity);
        BeanUtils.copyProperties(payInfo, entity);

        entity.setSeaportCode(seaportInfo.getSeaportCode());
        entity.setSeaportPlatform(seaportInfo.getPlatform());
        entity.setIdentityCard(seaportInfo.getIdentityCard());
        entity.setIdentityMobile(seaportInfo.getIdentityMobile());
        entity.setIdentityName(seaportInfo.getIdentityName());
        entity.setOrderProductInfo(JacksonUtil.toJson(seaportInfo.getOrderProductInfoList()));

        return entity;
    }

    /**
     * 组装推送订单数据：跨境数据
     * @param order 订单数据
     * @return 跨境数据
     */
    private SeaportInfoDTO wrapSeaportInfo(OrderVo order) {
        SeaportInfoDTO seaportInfoDTO = new SeaportInfoDTO();
        String value = sysConfigDao.queryByKey(Constants.CUSTOMS_PORT_CODE);
        if (org.springframework.util.StringUtils.isEmpty(value)) {
            throw new ServiceException("未配置海关口岸代码！配置方式：【系统管理】->【系统参数】");
        }
        seaportInfoDTO.setSeaportCode(value);
        seaportInfoDTO.setPlatform("1");
        seaportInfoDTO.setIdentityCard(order.getIdCard());
        seaportInfoDTO.setIdentityName(order.getPay_name());
        seaportInfoDTO.setIdentityMobile(order.getMobile());
        return seaportInfoDTO;
    }

    /**
     * 组装推送订单数据：支付数据
     * @param order 订单数据
     * @return  支付数据
     */
    private PayInfoDTO wrapPayInfo(OrderVo order) {
        PayInfoDTO payInfoDTO = new PayInfoDTO();
        payInfoDTO.setMoney(order.getActual_price());
        payInfoDTO.setPayMode("offline");
        payInfoDTO.setRequest(order.getRequest());
        payInfoDTO.setResponse(order.getResponse());
        payInfoDTO.setOutTradeNo(order.getAliTradeNo());
        return payInfoDTO;
    }

    /**
     * 组装推送订单数据：订单详情数据
     * @param orderGoodsVo  订单详情
     * @return  订单详情数据
     */
    private OrderInfoItemDTO wrapOrderInfoItem(OrderGoodsVo orderGoodsVo) {
        OrderInfoItemDTO orderInfoItemDTO = new OrderInfoItemDTO();
        orderInfoItemDTO.setOrderId(orderGoodsVo.getOrderSn());
        orderInfoItemDTO.setImageUrl(orderGoodsVo.getList_pic_url());
        orderInfoItemDTO.setBn(orderGoodsVo.getSku());
        orderInfoItemDTO.setBarcode(orderGoodsVo.getBarcode());
        orderInfoItemDTO.setName(orderGoodsVo.getGoods_name());
        orderInfoItemDTO.setCost(orderGoodsVo.getMarket_price());
        orderInfoItemDTO.setPrice(orderGoodsVo.getRetail_price());
        orderInfoItemDTO.setItemcode(orderGoodsVo.getSku());
        orderInfoItemDTO.setAmount(orderGoodsVo.getActualPaymentAmount());
        orderInfoItemDTO.setNums(orderGoodsVo.getNumber());
        orderInfoItemDTO.setTax(true);
        orderInfoItemDTO.setTaxPrice(orderGoodsVo.getTaxPrice());
        return orderInfoItemDTO;
    }

    /**
     * 组装推送订单数据：订单数据
     * @param order 订单数据
     * @return  订单数据
     */
    private OrderInfoDTO wrapOrderInfo(OrderVo order) {
        OrderInfoDTO orderInfoDTO = new OrderInfoDTO();
        orderInfoDTO.setOuterOrderNo(order.getOrder_sn());
        orderInfoDTO.setPayApp(order.getPayApp());
        orderInfoDTO.setDlytypeCode("SF");
        orderInfoDTO.setConsigneeName(order.getPay_name());
        orderInfoDTO.setConsigneeAreaProvince(order.getProvince());
        orderInfoDTO.setConsigneeAreaCity(order.getCity());
        orderInfoDTO.setConsigneeAreaCounty(order.getDistrict());
        orderInfoDTO.setConsigneeAddress(order.getAddress());
        orderInfoDTO.setConsigneeZip("519000");
        orderInfoDTO.setConsigneeTel("0756-8800000");
        orderInfoDTO.setConsigneeEmail("hk@greedc.com");
        orderInfoDTO.setConsigneeMobile(order.getMobile());
        orderInfoDTO.setQuantity(order.getNumber());
        orderInfoDTO.setOrderTotal(order.getActual_price());
        orderInfoDTO.setPlatform("store");

        return orderInfoDTO;
    }

    private OrderProductInfoDTO wrapOrderProductInfo(OrderGoodsVo orderGoodsVo) {
        OrderProductInfoDTO orderProductInfoDTO = new OrderProductInfoDTO();
        orderProductInfoDTO.setProductId(orderGoodsVo.getBarcode());
        orderProductInfoDTO.setGoodsId(orderGoodsVo.getGoods_sn());
        return orderProductInfoDTO;
    }

    /**
     * 支付宝支付
     */
    private void AliPay(SysUserEntity user, String parCode, OrderVo order, OrderProcessRecordEntity processRecordEntity, OrderWXPayRecordEntity orderWXPayRecordCurrent, StoreEntity store) throws Exception {

        AliPayRequestParams params = new AliPayRequestParams();

        String orderBizTypeZn = "普通货物";
        if ("00".equals(order.getOrderBizType())) {
            orderBizTypeZn = "保税备货";
        } else if ("02".equals(order.getOrderBizType())) {
            orderBizTypeZn = "保税展示补货";
        } else if ("10".equals(order.getOrderBizType())) {
            orderBizTypeZn = "保税展示跨境";
        }

        params.setAuthCode(parCode);
        params.setBody(order.getApprovalRemark());
        params.setOutTradeNo(order.getOrder_sn());
        params.setSubject(store.getMerchName() + "-" + store.getStoreName() + "-" + orderBizTypeZn);
        params.setStoreId(store.getId() + "");
        params.setTotalAmount(order.getActual_price().setScale(2, BigDecimal.ROUND_HALF_UP) + "");
        String paramsJson = JacksonUtils.toJson(params);
        order.setRequest(paramsJson);
        LOGGER.info("调用阿里支付接口的请求参数：" + paramsJson);
        AliPayMicropayApiResult aliPayMicropayApiResult = AliPayUtil.aliTradePay(params);
        orderWXPayRecordService.updateRecordByAli(orderWXPayRecordCurrent.getId(), aliPayMicropayApiResult);
        String responseJson = JacksonUtils.toJson(aliPayMicropayApiResult);
        LOGGER.info("调用阿里支付接口的同步返回结果：" + responseJson);
        order.setResponse(responseJson);
        order.setPayApp("alipay");
        order.setAliTradeNo(aliPayMicropayApiResult.getTradeNo());
        // 修改订单状态
        //当支付成功时,修改订单,并把其他支付记录撤销
        if (AliPayUtil.AliPayTradeState.SUCC.getCode().equals(aliPayMicropayApiResult.getCode())) {
//            //查询当前订单所有的支付记录
//            List<OrderWXPayRecordEntity> orderWXPayRecordEntitys =
//                    orderWXPayRecordService.getRecordsByOutTradeNo(order.getOrder_sn());
            this.confirmPay(order.getId(), Dict.payFlag.item_alipay.getItem(), aliPayMicropayApiResult.getTradeNo());
            // 设置支付单完成时间
            processRecordEntity.setPaymentSuccTime(aliPayMicropayApiResult.getGmtPayment());
            processRecordEntity.setPayTransactionId(aliPayMicropayApiResult.getTradeNo());

            sendAliPayInfo(order, store);

            // 系统繁忙
        } else if (AliPayUtil.AliPayTradeState.SERVER_FAIL.getCode().equals(aliPayMicropayApiResult.getCode())) {
            LOGGER.info(aliPayMicropayApiResult.getSubMsg());
            throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + ",请稍后再试");

            // 支付失败
        } else if (AliPayUtil.AliPayTradeState.BUSINESS_FAIL.getCode().equals(aliPayMicropayApiResult.getCode())) {
            // 系统异常
            if (AliPayUtil.BusinessFailState.SYSTEM_ERROR.getCode().equalsIgnoreCase(aliPayMicropayApiResult.getSubCode())) {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + ",请稍后再试");
                // 订单总额超过限额
            } else if (AliPayUtil.BusinessFailState.TOTAL_FEE_EXCEED.getCode().equalsIgnoreCase(aliPayMicropayApiResult.getSubCode())) {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + ",请告知顾客");
                // 授权码无效
            } else if (AliPayUtil.BusinessFailState.PAYMENT_AUTH_CODE_INVALID.getCode().equalsIgnoreCase(aliPayMicropayApiResult.getSubCode())) {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + ",请顾客刷新条码后，重新支付");
                // 交易信息被篡改
            } else if (AliPayUtil.BusinessFailState.CONTEXT_INCONSISTENT.getCode().equalsIgnoreCase(aliPayMicropayApiResult.getSubCode())) {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + ",请重试");
                // 余额支付功能关闭
            } else if (AliPayUtil.BusinessFailState.ERROR_BALANCE_PAYMENT_DISABLE.getCode().equalsIgnoreCase(aliPayMicropayApiResult.getSubCode())) {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + "，请用户打开余额支付");
                // 交易买家不匹配
            } else if (AliPayUtil.BusinessFailState.TRADE_BUYER_NOT_MATCH.getCode().equalsIgnoreCase(aliPayMicropayApiResult.getSubCode())) {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + "，请重试");
                // 买家状态非法
            } else if (AliPayUtil.BusinessFailState.BUYER_ENABLE_STATUS_FORBID.getCode().equalsIgnoreCase(aliPayMicropayApiResult.getSubCode())) {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + "，请买家联系支付宝小二，确认为什么非法");
                // 唤起移动收银台失败
            } else if (AliPayUtil.BusinessFailState.PULL_MOBILE_CASHIER_FAIL.getCode().equalsIgnoreCase(aliPayMicropayApiResult.getSubCode())) {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + "，请用户刷新条码后，重新支付");
                // 用户的无限支付开关关闭
            } else if (AliPayUtil.BusinessFailState.MOBILE_PAYMENT_SWITCH_OFF.getCode().equalsIgnoreCase(aliPayMicropayApiResult.getSubCode())) {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + "，请用户在PC上打开无线支付开关后，在发起支付");
                // 支付失败
            } else if (AliPayUtil.BusinessFailState.PAYMENT_FAIL.getCode().equalsIgnoreCase(aliPayMicropayApiResult.getSubCode())) {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + "，请重试");
                // 商户账号被冻结
            } else if (AliPayUtil.BusinessFailState.SELLER_BEEN_BLOCKED.getCode().equalsIgnoreCase(aliPayMicropayApiResult.getSubCode())) {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + "，请联系支付宝小二解冻");
                // 买家未通过人行认证
            } else if (AliPayUtil.BusinessFailState.ERROR_BUYER_CERTIFY_LEVEL_LIMIT.getCode().equalsIgnoreCase(aliPayMicropayApiResult.getSubCode())) {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + "，请买家联系支付宝小二");
                // 用户当面付付款开关管壁
            } else if (AliPayUtil.BusinessFailState.USER_FACE_PAYMENT_SWITCH_OFF.getCode().equalsIgnoreCase(aliPayMicropayApiResult.getSubCode())) {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + "，请买家打开当面付付款开关");
            } else {
                LOGGER.info(aliPayMicropayApiResult.getSubMsg());
                throw new RuntimeException(aliPayMicropayApiResult.getSubMsg());
            }
            // 其他支付异常状态
        } else {
            LOGGER.info(aliPayMicropayApiResult.getSubMsg());
            throw new RuntimeException(aliPayMicropayApiResult.getSubMsg() + "...........请联系管理员");
        }


    }

    private void sendAliPayInfo(OrderVo order, StoreEntity store) {
        // 组装支付单信息
        Map<String, Object> orderSendCusParams = new HashMap<>();
        orderSendCusParams.put("merchSn", order.getMerchSn());
        orderSendCusParams.put("orderSn", order.getOrder_sn());
        orderSendCusParams.put("merchName", order.getMerchName());
        orderSendCusParams.put("thirdPartyMerchCode", store.getThirdPartyMerchCode());
        orderSendCusParams.put("thirdPartyMerchName", store.getThirdPartyMerchName());
        orderSendCusParams.put("tradeNo", order.getAliTradeNo());
        orderSendCusParams.put("amount", order.getActual_price());

        // 将支付单信息发送到当前项目下的 cuspay
        aliCusDeclareBiz.biz(orderSendCusParams);
    }

    /**
     * 微信支付
     */
    private void wxPay(SysUserEntity user, String parCode, Map resultObj, OrderVo order, OrderProcessRecordEntity processRecordEntity, OrderWXPayRecordEntity orderWXPayRecordCurrent, StoreEntity store) throws ParseException {
        R r;

        String ip = "127.0.0.1";
        try {
            InetAddress ia = InetAddress.getLocalHost();
//        String localname=ia.getHostName();
            ip = ia.getHostAddress();
        } catch (Exception e) {
            e.printStackTrace();
        }
        PayOriginInfoDTO payOriginInfoDTO = new PayOriginInfoDTO();
        WechatMicropayApiResult wechatMicropayApiResult = WechatUtil
                .wxMicropay(store.getMerchName() + "-" + store.getStoreName(), order.getOrderBizType(), null,
                        orderWXPayRecordCurrent.getOutTradeNoWX(), order.getActual_price().doubleValue(),
                        ip, parCode, payOriginInfoDTO);
        orderWXPayRecordService.updateRecord(orderWXPayRecordCurrent.getId(), wechatMicropayApiResult);

        order.setRequest(payOriginInfoDTO.getRequest());
        String response = payOriginInfoDTO.getResponse();
        if (!org.springframework.util.StringUtils.isEmpty(response)) {
            response = response.replaceAll("\r|\n", "");
        }
        order.setResponse(response);
        order.setPayApp("wxpay");
        order.setFeeType(wechatMicropayApiResult.getFee_type());
        order.setAliTradeNo(wechatMicropayApiResult.getTransaction_id());
        resultObj.put("shopName", store.getStoreName()); // 根据门店编号查询
        resultObj.put("userName", user.getUsername());
        // 修改订单状态
        //当支付成功时,修改订单,并把其他支付记录撤销
        AtomicBoolean atomicBoolean = new AtomicBoolean(false);
        if (WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatMicropayApiResult.getTrade_state())) {
            //查询当前订单所有的支付记录
            List<OrderWXPayRecordEntity> orderWXPayRecordEntitys =
                    orderWXPayRecordService.getRecordsByOutTradeNo(order.getOrder_sn());
            LOGGER.info("wechatMicropayApiResult.getTransaction_id()" + wechatMicropayApiResult.getTransaction_id());
            order.setPayTransactionId(wechatMicropayApiResult.getTransaction_id());
            Map orderRaram = Maps.newHashMap();
            orderRaram.put("payTransactionId", wechatMicropayApiResult.getTransaction_id());
            orderRaram.put("orderId", order.getId());
            orderDao.updateOrderInfo(orderRaram);
            this.confirmPay(order.getId(), Dict.payFlag.item_weixin.getItem(), orderWXPayRecordCurrent.getOutTradeNoWX());

            // 设置支付单完成时间
            processRecordEntity.setPaymentSuccTimeStr(wechatMicropayApiResult.getTime_end());
            processRecordEntity.setPaymentSuccTime(
                    new SimpleDateFormat("yyyyMMddHHmmss").parse(wechatMicropayApiResult.getTime_end()));
            processRecordEntity.setPayTransactionId(wechatMicropayApiResult.getTransaction_id());

            atomicBoolean.set(true);

            //用户支付中
        } else if (WechatUtil.WXTradeState.USERPAYING.getCode().equals(wechatMicropayApiResult.getTrade_state())) {
            r = R.error(WechatUtil.WXTradeState.USERPAYING.getCodeZn() + ",稍等片刻后请刷新页面重新查看订单状态");
            int times = 0;
            // 查询是否支付了
            while (true) {
                boolean flag = orderQuery(order, processRecordEntity);
                if (flag) {
                    atomicBoolean.set(true);
                    break;
                }
                try {
                    Thread.currentThread().sleep(1000);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (times >= 60) {
                    throw new RuntimeException("超过60s未支付，订单下单失败");
                }
                times++;
            }
            //用户支付失败
        } else if (WechatUtil.WXTradeState.PAYERROR.getCode().equals(wechatMicropayApiResult.getTrade_state())) {
            WechatReverseApiResult wechatReverseApiResult =
                    WechatUtil.wxReverse(orderWXPayRecordCurrent.getOutTradeNoWX());
            //撤销订单成功
            if (WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatReverseApiResult.getReturn_code()) &&
                    WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatReverseApiResult.getResult_code())) {
                //调用订单查询接口
                WechatRefundApiResult wechatRefundApiResult =
                        WechatUtil.wxOrderQuery(orderWXPayRecordCurrent.getOutTradeNoWX());
                if (WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatRefundApiResult.getReturn_code()) &&
                        WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatRefundApiResult.getResult_code())) {
                    // 修改订单支付记录
                    orderWXPayRecordService
                            .updateWXPayRecordTradeState(orderWXPayRecordCurrent.getId(), wechatRefundApiResult);
                }
                r = R.error(orderWXPayRecordCurrent.getErrCodeDes());
            } else {
                r = R.error(wechatReverseApiResult.getErr_code_des());
            }
            throw new RuntimeException("订单支付失败");
        } else {
            throw new RuntimeException("未支付或支付失败，请联系管理员");
        }

        if (atomicBoolean.get()) {
            // 推送支付单
            sendWxPayInfo(order, store);
        }

    }

    private void sendWxPayInfo(OrderVo order, StoreEntity store) {
        // 组装支付单信息
        Map<String, Object> orderSendCusParams = new HashMap<>();
        orderSendCusParams.put("merchSn", order.getMerchSn());
        orderSendCusParams.put("orderSn", order.getOrder_sn());
        orderSendCusParams.put("merchName", order.getMerchName());
        orderSendCusParams.put("thirdPartyMerchCode", store.getThirdPartyMerchCode());
        orderSendCusParams.put("thirdPartyMerchName", store.getThirdPartyMerchName());
        orderSendCusParams.put("outTradeNo", order.getMerchOrderSn());
        orderSendCusParams.put("transactionId", order.getPayTransactionId());
        orderSendCusParams.put("subOrderId", "");   // ccnet原逻辑没有对该字段赋值
        orderSendCusParams.put("subOrderNo", order.getOrder_sn());
        orderSendCusParams.put("feeType", order.getFeeType());
        int orderFee = order.getActual_price().multiply(new BigDecimal(100)).intValue();
        orderSendCusParams.put("orderFee", orderFee);
        orderSendCusParams.put("productFee", orderFee);
        orderSendCusParams.put("transportFee", 0);
        UserEntity userEntity = userService.queryByMobile(order.getMobile());
        orderSendCusParams.put("certId", userEntity.getIdNo());
        orderSendCusParams.put("name", order.getPay_name());

        // 将支付单信息发送到当前项目下的 cuspay
        wxCusDeclareBiz.biz(orderSendCusParams);
    }

    /**
     * 同步会员消费记录
     * @param memberPhone   会员手机号
     * @param order         订单信息
     * @param deductionScore    抵扣积分
     */
    private void syncMemberConsumeRecord(String memberPhone, OrderVo order, Integer deductionScore) {
        HaiKongMemberOrderSyncResendEntity haiKongMemberOrderSyncResendEntity = new HaiKongMemberOrderSyncResendEntity();
        MemberOrderInfoSyncDTO memberOrderInfoSyncDTO = new MemberOrderInfoSyncDTO();
        memberOrderInfoSyncDTO.setPhone(memberPhone);
        memberOrderInfoSyncDTO.setOrderNo(order.getOrder_sn());
        memberOrderInfoSyncDTO.setConsumeDate(new Date());
        memberOrderInfoSyncDTO.setOrderAmount(order.getActual_price());
        memberOrderInfoSyncDTO.setOrderScore(deductionScore);
        BeanUtils.copyProperties(memberOrderInfoSyncDTO, haiKongMemberOrderSyncResendEntity);
        Date date = new Date();
        haiKongMemberOrderSyncResendEntity.setCreateTime(date);
        haiKongMemberOrderSyncResendEntity.setLastResendTime(date);
        try {
            String body = JacksonUtil.toJson(memberOrderInfoSyncDTO);
            LOGGER.info("请求会员系统同步消费订单接口！请求体：{}", body);
            // 发送请求
            String memberOrderSyncResponseJson = haiKongMemberTemplate.memberOrderSync(body);
            LOGGER.info("请求会员系统同步消费订单接口！响应：{}", memberOrderSyncResponseJson);
            Response<String> response = JacksonUtil.fromListJson(memberOrderSyncResponseJson, new TypeReference<Response<String>>() {});
            if (Objects.nonNull(response) && response.getSuccess()) {
                haiKongMemberOrderSyncResendEntity.setMemberSysOrderId(response.getData());
                haiKongMemberOrderSyncResendEntity.setResendStatus(HaiKongMemberOrderResendStatusEnum.NON_RESEND.getStatus());
            } else {
                haiKongMemberOrderSyncResendEntity.setResendStatus(HaiKongMemberOrderResendStatusEnum.WAIT_RESEND.getStatus());
            }
            haiKongMemberOrderSyncResendService.save(haiKongMemberOrderSyncResendEntity);
            LOGGER.info("请求会员系统同步消费订单接口成功！");
        } catch (Exception e) {
            LOGGER.error("请求会员系统同步消费订单接口出现异常！准备新增发送失败记录，等待重发！异常信息：", e);
            // 没有请求成功，写表，重发
            haiKongMemberOrderSyncResendEntity.setResendStatus(HaiKongMemberOrderResendStatusEnum.WAIT_RESEND.getStatus());
            haiKongMemberOrderSyncResendService.save(haiKongMemberOrderSyncResendEntity);
        }
    }

    /**
     * 同步会员积分变动记录
     * @param openId    会员openid
     * @param order     订单信息
     * @param changeEvent 变动事件
     * @param changeReason 变动原因
     * @param goodsList 商品详情
     * @param giftGoodsScoreDetailMap 赠送积分详情
     * @param score     变动积分
     */
    private void syncMemberScoreChangeRecord(String openId,
                                             OrderVo order,
                                             Integer score,
                                             String changeReason,
                                             List<QueryGoodsVO> goodsList,
                                             Map<String, OrderGiftScoreRulesVo> giftGoodsScoreDetailMap,
                                             String changeEvent) {
        HaiKongMemberScoreChangeRecordEntity haiKongMemberScoreChangeRecordEntity = new HaiKongMemberScoreChangeRecordEntity();
        MemberScoreChangeDTO memberScoreChangeDTO = new MemberScoreChangeDTO();
        String changeId = UUID.randomUUID(true).toString();
        memberScoreChangeDTO.setChangeEvent(changeEvent);
        memberScoreChangeDTO.setChangeId(changeId);
        memberScoreChangeDTO.setChangeReason(changeReason);
        memberScoreChangeDTO.setOpenId(openId);
        memberScoreChangeDTO.setOutBizNo(order.getOrder_sn());
        memberScoreChangeDTO.setScore(score);
        BeanUtils.copyProperties(memberScoreChangeDTO, haiKongMemberScoreChangeRecordEntity);
        Date date = new Date();
        haiKongMemberScoreChangeRecordEntity.setCreateTime(date);
        haiKongMemberScoreChangeRecordEntity.setModifyTime(date);
        try {
            String body = JacksonUtil.toJson(memberScoreChangeDTO);
            LOGGER.info("请求会员系统积分变动接口！请求体：{}", body);
            String changeMemberScoreResponseJson = haiKongMemberTemplate.changeMemberScore(body);
            LOGGER.info("请求会员系统积分变动接口！响应数据：{}", changeMemberScoreResponseJson);
            Response<MemberScoreChangeResponseDTO> response = JacksonUtil.fromListJson(changeMemberScoreResponseJson, new TypeReference<Response<MemberScoreChangeResponseDTO>>() {});
            if (Objects.nonNull(response) && response.getSuccess()) {
                MemberScoreChangeResponseDTO responseData = response.getData();
                haiKongMemberScoreChangeRecordEntity.setStatementId(responseData.getStatementId());
                haiKongMemberScoreChangeRecordEntity.setResendStatus(HaiKongMemberOrderResendStatusEnum.NON_RESEND.getStatus());
            } else {
                haiKongMemberScoreChangeRecordEntity.setResendStatus(HaiKongMemberOrderResendStatusEnum.WAIT_RESEND.getStatus());
            }
            haiKongMemberScoreChangeRecordService.save(haiKongMemberScoreChangeRecordEntity);
            LOGGER.info("请求会员系统积分变动接口成功！");
        } catch (Exception e) {
            LOGGER.error("请求会员系统积分变动接口出现异常！准备新增发送失败记录，等待重发！异常信息：", e);
            // 失败重发
            haiKongMemberScoreChangeRecordEntity.setResendStatus(HaiKongMemberOrderResendStatusEnum.WAIT_RESEND.getStatus());
            haiKongMemberScoreChangeRecordService.save(haiKongMemberScoreChangeRecordEntity);
        }
        LOGGER.info("保存会员系统积分变动详情记录中......");
        List<HaiKongMemberScoreChangeDetailRecordEntity> recordEntityList = goodsList.stream().map(goodsEntity -> {
            HaiKongMemberScoreChangeDetailRecordEntity entity = new HaiKongMemberScoreChangeDetailRecordEntity();
            String sku = goodsEntity.getSku();
            OrderGiftScoreRulesVo orderGiftScoreRulesVo = giftGoodsScoreDetailMap.get(sku);
            if (Objects.nonNull(orderGiftScoreRulesVo)) {
                entity.setGenerateRatio(orderGiftScoreRulesVo.getGenerateRatio());
                entity.setGenerateRules(orderGiftScoreRulesVo.getGenerateType());
                entity.setGiftScore(orderGiftScoreRulesVo.getGiftScore());
            }
            entity.setOrderSn(order.getOrder_sn());
            entity.setRetailPrice(goodsEntity.getRetailPrice());
            entity.setActualPrice(goodsEntity.getTotalPrice());
            entity.setProductBarcode(goodsEntity.getProdBarcode());
            entity.setSellVolume(goodsEntity.getSellVolume());
            entity.setSku(sku);
            entity.setDeductionScore(goodsEntity.getDeductionScore());
            return entity;
        }).collect(Collectors.toList());
        haiKongMemberScoreChangeDetailRecordService.saveBatch(recordEntityList);
    }

    private boolean orderQuery(OrderVo order, OrderProcessRecordEntity processRecordEntity) {
        LOGGER.info(">>>>>>>>>>>>>>>>>>>>wxOrderQuery 微信查询接口调用");
        String merchOrderSn = order.getMerchOrderSn();
        String orderId = order.getId() + "";
        String orderSn = order.getOrder_sn();
        WechatRefundApiResult result = WechatUtil.wxOrderQuery(orderSn);
        if (result.getReturn_code().equalsIgnoreCase(WechatUtil.WXTradeState.SUCCESS.getCode())) {
            if (result.getResult_code().equalsIgnoreCase(WechatUtil.WXTradeState.SUCCESS.getCode())) {
                if (result.getTrade_state().equalsIgnoreCase(Dict.tradeState.item_SUCCESS.getItem())) {
                    Date successTime = DateUtils.convertStringToDate(result.getTime_end(),
                            DateUtils.DATE_TIME_PATTERN_YYYY_MM_DD_HH_MM_SS);
                    Map orderRaram = Maps.newHashMap();
                    orderRaram.put("payStatus", Dict.payStatus.item_2.getItem());//已支付
                    orderRaram.put("orderStatus", Dict.orderStatus.item_201.getItem());//已支付
                    orderRaram.put("payTransactionId", result.getTransaction_id());
                    orderRaram.put("payTime", successTime);
                    orderRaram.put("orderId", orderId);
                    orderRaram.put("payFlag", Dict.payFlag.item_weixin.getItem());
                    orderDao.updateOrderInfo(orderRaram);
                    Map processParam = Maps.newHashMap();
                    processParam.put("payTime", successTime);
                    processParam.put("orderSn", orderSn);
                    orderDao.updateOrderProcessRecord(processParam);

//                    orderWXPayRecordService
//                                    .updateWXPayRecordTradeState(orderWXPayRecordTemp.getId(), wechatRefundApiResult);


                    // 设置支付单完成时间
                    processRecordEntity.setPaymentSuccTimeStr(result.getTime_end());
                    processRecordEntity.setPaymentSuccTime(successTime);
                    processRecordEntity.setPayTransactionId(result.getTransaction_id());
                    return true;

                } else if (result.getTrade_state().equalsIgnoreCase(Dict.tradeState.item_NOTPAY.getItem())) {//订单未支付
                    Map orderRaram = Maps.newHashMap();

                    orderRaram.put("payStatus", Dict.payStatus.item_0.getItem());//支付状态未支付
                    orderRaram.put("orderStatus", Dict.orderStatus.item_0.getItem());//订单状态未支付

                    orderRaram.put("orderId", orderId);
                    orderDao.updateOrderInfo(orderRaram);
                } else if (result.getTrade_state().equalsIgnoreCase(Dict.tradeState.item_CLOSED.getItem())) {
                    Map orderRaram = Maps.newHashMap();
                    orderRaram.put("payStatus", Dict.payStatus.item_7.getItem());
                    orderRaram.put("orderStatus", Dict.orderStatus.item_500.getItem());
                    orderRaram.put("orderId", orderId);
                    orderDao.updateOrderInfo(orderRaram);
                    LOGGER.info(">>>>>>>>>>>>>>>>>>>>wxOrderByTransactionIdQueryUpdFail 根据支付单查询微信接口返回信息：state 【" + result.getTrade_state() +
                            "】，des【" + result.getTrade_state_desc() + "】");
                    return false;
                } else if (result.getTrade_state().equalsIgnoreCase(Dict.tradeState.item_PAYERROR.getItem())) {
                    Map orderRaram = Maps.newHashMap();
                    orderRaram.put("payStatus", Dict.payStatus.item_8.getItem());
                    orderRaram.put("orderStatus", Dict.orderStatus.item_501.getItem());
                    orderRaram.put("orderId", orderId);
                    orderDao.updateOrderInfo(orderRaram);
                    LOGGER.info(">>>>>>>>>>>>>>>>>>>>wxOrderByTransactionIdQueryUpdFail 根据支付单查询微信接口返回信息：state 【" + result.getTrade_state() +
                            "】，des【" + result.getTrade_state_desc() + "】");
                    return false;
                } else if (result.getTrade_state().equalsIgnoreCase(Dict.tradeState.item_USERPAYING.getItem())) {
                    Map orderRaram = Maps.newHashMap();
                    orderRaram.put("payStatus", Dict.payStatus.item_1.getItem());
                    orderRaram.put("orderStatus", Dict.orderStatus.item_100.getItem());
                    orderRaram.put("orderId", orderId);
                    orderDao.updateOrderInfo(orderRaram);
                    LOGGER.info(">>>>>>>>>>>>>>>>>>>>wxOrderByTransactionIdQueryUpdFail 根据支付单查询微信接口返回信息：state 【" + result.getTrade_state() +
                            "】，des【" + result.getTrade_state_desc() + "】");
                } else if (result.getTrade_state().equalsIgnoreCase(Dict.tradeState.item_REVOKED.getItem())) {
                    LOGGER.info(">>>>>>>>>>>>>>>>>>>>wxOrderByTransactionIdQueryUpdFail 根据支付单查询微信接口返回信息：state 【" + result.getTrade_state() +
                            "】，des【" + result.getTrade_state_desc() + "】");
                    return false;
                }
            } else {
                LOGGER.info(">>>>>>>>>>>>>>>>>>>>wxOrderQuery 微信查询接口返回失败信息：code 【" + result.getErr_code() +
                        "】，des【" + result.getErr_code_des() + "】");
            }

            return false;
        } else {
            LOGGER.info(">>>>>>>>>>>>>>>>>>>>wxOrderQuery 微信查询接口调用失败： " + result.getReturn_msg());
            return false;
        }
    }

    @Override
    public OrderEntity queryObjectByOrderSn(String orderSn) {
        return orderDao.queryObjectByOrderSn(orderSn);
    }

    ExecutorService service = Executors.newSingleThreadExecutor();
    // 收银端退款的代码
    @Override
    @Transactional
    public synchronized R orderRefund(OrderEntity order) throws Exception {
        OrderEntity orderInfo = order;
        if (null == orderInfo) {
            return R.error("订单不存在");
        }
        if (orderInfo.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_401.getItem()) ||
                orderInfo.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_402.getItem())) {
            return R.error("订单已退款");
        }
        if (orderInfo.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_0.getItem())) {
            return R.error("订单正在准备，请稍等！");
        }
        if (orderInfo.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_100.getItem()) ||
                orderInfo.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_101.getItem())||
                orderInfo.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_102.getItem())
        ) {
            return R.error("订单尚未支付完成，无法进行退款！");
        }

        String payFlag = order.getPayFlag();
        String key  = "kmall_order_refund_" + order.getOrderSn();
        if (JedisUtil.exists(key)) {
            return R.error("订单退款操作过快，请等待！");
        }
        JedisUtil.set(key, System.currentTimeMillis() + "", 3);
        if (orderInfo.getPayStatus() == Integer.parseInt(Dict.payStatus.item_3.getItem())) {
            return R.error("订单正在退款中，请勿重复退款");
        }
//        CountDownLatch cdl = new CountDownLatch(1);
//        service.submit(()-> {
//            try {
                orderDao.updateOrderRefunding(order.getId());
//            } finally {
//                cdl.countDown();
//            }
//        });
//        cdl.await();

        if (Dict.payFlag.item_weixin.getItem().equals(payFlag)) {
            Double totalActualPrice = orderDao.getTotalActualPrice(orderInfo.getMerchOrderSn());
            if (totalActualPrice == null) {
                totalActualPrice = 0d;
            }
            if (orderInfo.getOrderStatus() != Integer.parseInt(Dict.orderStatus.item_0.getItem())) {
                LOGGER.info("[微信退款开始--------orderRefund]"+order.getOrderSn());
                WechatRefundApiResult result = WechatUtil.wxRefund(orderInfo.getOrderSn(), totalActualPrice,
                        orderInfo.getActualPrice().doubleValue());
                order.setPayStatus(Integer.parseInt(Dict.payStatus.item_5.getItem()));
                order.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_401.getItem()));
                //修改为退款成功
                orderDao.update(order);
                // 修改小票码
                PickUpCodeEntity pickUpCodeEntity = pickUpCodeService.queryObject(order.getOrderSn());
                pickUpCodeEntity.setPickUpCodeStatus(Dict.PickUpCodeStatusEnum.item_3.getStatus());
                pickUpCodeService.update(pickUpCodeEntity);
                //新增退款记录
                //OrderRefundEntity orderRefund = orderRefundLog("wx453456511","wx453456566","26999",order.getId(),user.getUserId(),order.getMerchOrderSn());
                OrderRefundEntity orderRefund = orderRefundLog(result.getRefund_id(),result.getOut_trade_no(),result.getRefund_fee(),order.getId(),order.getMerchOrderSn(),payFlag);
                orderRefundDao.save(orderRefund);
                //还原库存，调用免税mall接口退款和积分回退接口
                restoreInventoryMsMall(order);
            }
            // 支付宝的退款代码
        } else if (Dict.payFlag.item_alipay.getItem().equals(payFlag)) {
            LOGGER.info("[支付宝退款开始--------orderRefund]"+order.getOrderSn());
            AliPayMicropayApiResult userRefund = AliPayUtil.aliTradeRefund(order.getOrderSn(), order.getActualPrice().toString(),
                    "用户退款", order.getStoreId() + "");
            // 是否已退款校验
            try {
                String fundChange = userRefund.getFundChange();
                if ("N".equals(fundChange)) {
                    return R.error("资金已退回，请勿重复退款！");
                }
            } catch (Exception e) {
                LOGGER.error("[支付宝退款校验出错]",e.getMessage());
            }
            LOGGER.info(userRefund.getSubMsg());
            order.setPayStatus(Integer.parseInt(Dict.payStatus.item_5.getItem()));
            order.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_401.getItem()));
            //修改为退款成功
            orderDao.update(order);
            // 修改小票码
            PickUpCodeEntity pickUpCodeEntity = pickUpCodeService.queryObject(order.getOrderSn());
            pickUpCodeEntity.setPickUpCodeStatus(Dict.PickUpCodeStatusEnum.item_3.getStatus());
            pickUpCodeService.update(pickUpCodeEntity);
            //新增退款记录
            OrderRefundEntity orderRefund = orderRefundLog(userRefund.getTradeNo(),userRefund.getOutTradeNo(),userRefund.getRefundFee(),order.getId(),order.getMerchOrderSn(),payFlag);
            orderRefundDao.save(orderRefund);
            //还原库存，调用免税mall接口退款和积分回退接口
            restoreInventoryMsMall(order);
        }
        return R.ok("退款成功");
    }


    /**
     * 新增退款记录
     * @param refundId
     * @param OutTradeNo
     * @param refundFee
     * @param orderId
     * @param merchOrderSn
     * @return
     */
    private OrderRefundEntity orderRefundLog(String refundId,String OutTradeNo,String refundFee,Long orderId,String merchOrderSn,String payFlag){

        OrderRefundEntity orderRefund = new OrderRefundEntity();
        orderRefund.setRefundId(refundId);
        orderRefund.setOutRefundNo(OutTradeNo);
        if(Dict.payFlag.item_weixin.getItem().equals(payFlag)){
            orderRefund.setRefundMoney(BigDecimal.valueOf(Long.valueOf(refundFee)).divide(Constant.ONE_HUNDRED));
        }else{
            orderRefund.setRefundMoney(new BigDecimal(refundFee));
        }
        orderRefund.setRefundStatus(Integer.parseInt(Dict.RefundStatus.item_2.getItem()));//退款处理中
        orderRefund.setModTime(new Date());
        orderRefund.setRefundTime(new Date());
        orderRefund.setOrderId(orderId.intValue());
        SysUserEntity user = ShiroUtils.getUserEntity();
        if(user!=null){
            orderRefund.setUserId(user.getUserId().intValue());
            orderRefund.setRefundId(user.getUserId() + "");
        }
        orderRefund.setCreateTime(new Date());
        Integer sum = orderDao.queryObjectByMerchOrderSnHkMall(merchOrderSn);
        if (sum > 1) {//多条订单
            orderRefund.setRefundType(Integer.parseInt(Dict.RefundType.item_2.getItem()));//部分退款
        } else {
            orderRefund.setRefundType(Integer.parseInt(Dict.RefundType.item_1.getItem()));//用户全额退款
        }
        orderRefund.setRestore(1);
        return orderRefund;
    }

    /**
     * 海控订单退款
     * @param order
     */
    private void restoreInventoryMsMall(OrderEntity order) throws Exception{
        Map<String, Object> map = new HashMap();
        SysUserEntity user = ShiroUtils.getUserEntity();
        map.put("orderId", order.getId());
        //mall_order_goodsd，订单明细
        List<OrderGoodsEntity> orderGoodsVoList = orderGoodsDao.queryListHkMall(map);
        for (OrderGoodsEntity orderGoodsEntity : orderGoodsVoList) {
            ProductStoreRelaEntity storeRelaEntity = productStoreRelaDao
                    .queryByGoodsIdAndStoreIdHkMall(order.getStoreId().longValue(), orderGoodsEntity.getGoodsId().longValue());
            if (null == storeRelaEntity || null == storeRelaEntity.getSellVolume()) {
                storeRelaEntity.setSellVolume(0);
            }
            //销售量 - 商品数量
            BigDecimal sellVolume = new BigDecimal(storeRelaEntity.getSellVolume() - orderGoodsEntity.getNumber());//销售量
            if (sellVolume.compareTo(Constant.ZERO) < 0) {
                sellVolume = Constant.ZERO;
            }
            GoodsEntity goodsEntity = goodsDao.queryObject(orderGoodsEntity.getGoodsId());
            if (goodsEntity != null) {
                //还原商户商品总库存
                resetGoodsStockHkMall(order,goodsEntity.getGoodsNumber(), storeRelaEntity, orderGoodsEntity, user);
            }
            //还原门店库存
            if (null != storeRelaEntity.getStockNum()) {
                resetStoreGoodsStockMall(order,storeRelaEntity.getStockNum(), storeRelaEntity, orderGoodsEntity, sellVolume, user);
            }
        }
        //调用免税mall接口
        vmcShopMall(order);
        //调用会员系统积分全量回退接口
        vipIntegralGoBack(order);

    }

    /**
     * 调用会员系统积分全量回退接口
     * @param order
     * @throws Exception
     */
    private void vipIntegralGoBack(OrderEntity order) throws Exception{
        List<IntegralGoBackEntity> changeRecordEntityList = haiKongMemberScoreChangeRecordService.queryIntegralGoBack(order.getOrderSn());
        for(IntegralGoBackEntity integralGoBackEntity:changeRecordEntityList) {
           String integralGoBackEntityMsg = JSON.toJSONString(integralGoBackEntity);
            String responseMsg = haiKongMemberTemplate.rollbackMemberScore(integralGoBackEntityMsg);
            Map<String, Object> res = JSON.parseObject(responseMsg, Map.class);
            LOGGER.info("=======> [vipIntegralGoBack-----调用会员系统积分全量回退接口数据]" + responseMsg);

            //解析数据
            if ("true".equals(res.get("success").toString())) {
                LOGGER.info("=======> [vipIntegralGoBack-----调用会员系统积分全量回退接口数据]" + responseMsg);
            } else {
                LOGGER.error("=======> [vipIntegralGoBack-----调用会员系统积分全量回退接口异常数据]" + responseMsg);
                HaiKongResendMsgEntity haiKongResendMsgEntity = new HaiKongResendMsgEntity();
                haiKongResendMsgEntity.setOpenId(integralGoBackEntity.getOpen_id());
                haiKongResendMsgEntity.setOrderSn(order.getOrderSn());
                haiKongResendMsgEntity.setInterfaceType(HaiKongMemberSystemUrlEnum.ROLLBACK_MEMBER_SCORE.getUrl());
                haiKongResendMsgEntity.setRequestMsg(JSON.toJSONString(integralGoBackEntity));
                haiKongResendMsgEntity.setResponseMsg(responseMsg);
                haiKongResendMsgEntity.setResendNum(0);
                haiKongResendMsgEntity.setIsValid(1);
                haiKongResendMsgDao.saveResendMsg(haiKongResendMsgEntity);
            }

        }
    }

    /**
     *海控免税mall接口
     * @param order
     */
    private void vmcShopMall(OrderEntity order) {
        LOGGER.info("=======> [vmcShopMall-----调用VMCShop接口开始发送退款订单数据]"+JSON.toJSONString(order));
        Map<String,String> map = new HashMap<>();
        map.put("outer_order_no",order.getOrderSn());
        String body = JacksonUtil.toJson(map);
        String response = vmcShopTemplate.refundOrder(body);
        //解析响应数据
        LOGGER.info("=======> [vmcShopMall------发送退款订单数据成功，开始处理后续流程]"+response);
        Map<String,String> res = JSON.parseObject(response,Map.class);

        LOGGER.info(order.getOrderSn()+"[解析响应数据]"+JSON.toJSONString(res));

    }


    @Transactional
    public void toBeRestoreInventory(OrderEntity order) {

        Map<String, Object> map = new HashMap();
        SysUserEntity user = ShiroUtils.getUserEntity();
        map.put("orderId", order.getId());
        List<OrderGoodsEntity> orderGoodsVoList = orderGoodsDao.queryList(map);
        for (OrderGoodsEntity orderGoodsEntity : orderGoodsVoList) {
            // 当前订单商品数量
            Integer restoreNumber = orderGoodsEntity.getNumber();
            ProductStoreRelaEntity storeRelaEntity = productStoreRelaDao
                    .queryByGoodsIdAndStoreId(order.getStoreId().longValue(), orderGoodsEntity.getGoodsId().longValue());
            Integer toBeRestored = storeRelaEntity.getToBeRestored();
            if (toBeRestored == null) {
                toBeRestored = 0;
            }
            // 修改门店商品待退款的数量 = 当前订单商品数量 + 门店待退款数量
            storeRelaEntity.setToBeRestored(toBeRestored + restoreNumber);

            GoodsEntity goodsEntity = goodsDao.queryObject(orderGoodsEntity.getGoodsId());

            toBeRestored = goodsEntity.getToBeRestored();
            if (toBeRestored == null) {
                toBeRestored = 0;
            }
            goodsEntity.setToBeRestored(toBeRestored + restoreNumber);


            productStoreRelaDao.update(storeRelaEntity);
            goodsDao.update(goodsEntity);
        }

    }

    /**
     * 查询oms系统是否有该订单
     *
     * @param orderSn
     * @return
     */
    private boolean arrivedOms(String orderSn) {

        Map<String, String> sParaTemp = new TreeMap<String, String>();
//        sParaTemp.put("data","ZWCW2020122749351849");
        sParaTemp.put("data", orderSn);
        sParaTemp.put("merchId", omsMerchProperties.getMerchSn());
        String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
        sParaTemp.put("timestamp", timestamp);
        //生成要请求给oms秘钥
//        String sign = OmsSign.sign(sParaTemp,cus.getWaybill().get("secret-key"));
        LOGGER.info("md5混淆码参数:" + omsMerchProperties.getMd5Salt());
        String sign = OmsSign.sign(sParaTemp, omsMerchProperties.getMd5Salt());
        sParaTemp.put("sign", sign);
        //构建Request
        String url = omsMerchProperties.getQueryInveResponseUrl();
        Request request = com.kmall.admin.utils.oms.OkHttpUtils.buildRequest(url, JSON.toJSONString(sParaTemp));
        LOGGER.info("oms的请求报文：" + request);
        // 同步访问,返回结果字符串
        String responseString = null;
        try {

            responseString = com.kmall.admin.utils.oms.OkHttpUtils.post(request);

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

        LOGGER.info("oms的响应报文" + responseString);
        //解析响应数据
        Gson gson = new Gson();
        ResponseMessage result = gson.fromJson(responseString, ResponseMessage.class);
        if (result == null) {
            String info = "解析响应数据Result失败";
            LOGGER.error("--- {}", info);
            throw new RuntimeException(info);
        }
        if ("oms无该订单".equals(result.getMsg())) {
            return false;
        }

        return true;

    }


    private String wxRefund(OrderEntity orderInfo, Double totalActualPrice) {
        WechatRefundApiResult result = WechatUtil.wxRefund(orderInfo.getOrderSn().toString(), totalActualPrice,
                orderInfo.getActualPrice().doubleValue());
        if (result.getResult_code().equals(WechatUtil.WXTradeState.SUCCESS.getCode())) {
            refund(orderInfo, result);
        } else {
            OrderRefundEntity mallOrderRefund = orderRefundService.queryObjectByOrderId(orderInfo.getId());
            OrderRefundEntity orderRefund = new OrderRefundEntity();
            orderRefund.setRefundType(Integer.parseInt(Dict.RefundType.item_1.getItem()));
            orderRefund.setRefundMoney(BigDecimal.valueOf(orderInfo.getActualPrice().doubleValue()));
            orderRefund.setRefundStatus(Integer.parseInt(Dict.RefundStatus.item_4.getItem()));
            SysUserEntity user = ShiroUtils.getUserEntity();
            orderRefund.setModerSn(user.getUsername());
            orderRefund.setModTime(new Date());
//            orderRefund.setOutRefundNo(result.getOut_refund_no());
            if (mallOrderRefund != null) {
                orderRefund.setId(mallOrderRefund.getId());
                orderRefundService.update(orderRefund);//退款记录
            }
            OrderExceptionRecordEntity mallOrderExceptionRecord = new OrderExceptionRecordEntity();
            mallOrderExceptionRecord.setOrderSn(orderInfo.getOrderSn());
            mallOrderExceptionRecord.setUserId(Integer.parseInt(orderInfo.getUserId() + ""));
            mallOrderExceptionRecord.setExceptionStatus(Dict.exceptionStatus.item_03.getItem());
            mallOrderExceptionRecord.setExceptionContent("退款失败" + result.getErr_code_des());
            mallOrderExceptionRecord.setCreateTime(new Date());
            orderExceptionRecordService.save(mallOrderExceptionRecord);
            return result.getErr_code_des();
        }
        return "";
    }

    @Override
    public int queryOffilineOrderTotal(Query query) {
        return orderDao.queryOffilineOrderTotal(query);
    }

    @Override
    public List<PurchaseSalesInStockDetail> purchaseSalesInStockDetailList(Query query) {
        return orderDao.purchaseSalesInStockDetailList(query);
    }

    @Override
    public int purchaseSalesInStockDetailTotal(Query query) {
        return orderDao.purchaseSalesInStockDetailTotal(query);
    }

    @Override
    public List<OrderEntity> queryExportOffilineOrderList(Map<String, Object> params) {
        List<OrderEntity> orderEntityList = orderDao.queryExportOffilineOrderList(params);
//        if (orderEntityList!=null && orderEntityList.size()>0){
//            for (OrderEntity orderEntity : orderEntityList) {
//                // 查询活动价
//                BigDecimal topicPrice = orderDao.queryTopicPriceByOrderSnAndSku(orderEntity.getOrderSn(),orderEntity.getSku());
//                orderEntity.setTopicPrice(topicPrice);
//            }
//        }
        return orderEntityList;
    }

    @Override
    public List<OrderEntity> queryMasterExportOffilineOrderList(Map<String, Object> params) {
        return orderDao.queryMasterExportOffilineOrderList(params);
    }

    @Override
    public List<OrderEntity> queryMasterExportList(Map<String, Object> params) {
        return orderDao.queryMasterExportList(params);
    }

    @Override
    public List<SystemFormatDto> queryExportSystemFormatList(Map<String, Object> params) {
        List<SystemFormatDto> systemFormatList = orderDao.queryExportSystemFormatList(params);
        return systemFormatList;
    }

    @Override
    public List<OrderEntity> queryLastDayOrder(String comparedDate) {

        Map<String, Object> map = new HashMap<>();
//
//        DateFormat dateFmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//格式化一下时间
//
//        Date dNow = new Date(); //当前时间
//
//        Date dBefore = new Date();
//
//        Calendar calendar = Calendar.getInstance(); //得到日历
//
//        calendar.setTime(dNow);//把当前时间赋给日历
//
//        calendar.add(Calendar.DAY_OF_MONTH, -1); //设置为前一天
//
//        dBefore = calendar.getTime(); //得到前一天的时间

        String defaultStartDate = comparedDate + " 00:00:00";


        String defaultEndDate = comparedDate + " 23:59:59";


        map.put("startTime", defaultStartDate);
        map.put("endTime", defaultEndDate);
        return orderDao.queryOffilineOrderList(map);
    }

    /**
     * 查询CW保税+新零售销售报表第一个sheet
     *
     * @param billDate
     * @param storeId
     * @return
     */
    @Override
    public ExportExcelDto querySumAmount(String billDate, String storeId) {
        ExportExcelDto exportExcelDto = new ExportExcelDto();
        ExportExcelDto totalAmount = orderDao.totalAmount(billDate, storeId);
        ExportExcelDto refundCurrentAmount = orderDao.refundCurrentAmount(billDate, storeId);
        ExportExcelDto refundPreviousAmount = orderDao.refundPreviousAmount(billDate, storeId);
        ExportExcelDto currentTax = orderDao.currentTax(billDate, storeId);
        ExportExcelDto refundPreviousTax = orderDao.refundPreviousTax(billDate, storeId);

        // 以下是直接从数据库中查出来的
        exportExcelDto.setTotalAmount(totalAmount.getTotalAmount()); // 总销售额
        exportExcelDto.setTotalCount(totalAmount.getTotalCount()); // 总销售数
        exportExcelDto.setRefundCurrentAmount(refundCurrentAmount.getRefundCurrentAmount()); // 当期退款额
        exportExcelDto.setRefundCurrentCount(refundCurrentAmount.getRefundCurrentCount()); // 当期退款数
        exportExcelDto.setRefundPreviousAmount(refundPreviousAmount.getRefundPreviousAmount()); // 退前期销售额
        exportExcelDto.setRefundPreviousCount(refundPreviousAmount.getRefundPreviousCount()); // 退前期销售数
        exportExcelDto.setCurrentTax(currentTax.getCurrentTax()); // 当前税额
        exportExcelDto.setPreviousTax(refundPreviousTax.getPreviousTax()); // 前期税额

        // 以下是通过计算的出来的
        // 销售净额
        exportExcelDto.setNetAmount(new BigDecimal(exportExcelDto.getTotalAmount()).subtract(new BigDecimal(exportExcelDto.getRefundPreviousAmount())).setScale(2, RoundingMode.HALF_UP).toString());
        // 总税额
        exportExcelDto.setTotalTax(new BigDecimal(exportExcelDto.getCurrentTax()).add(new BigDecimal(exportExcelDto.getPreviousTax())).setScale(2, RoundingMode.HALF_UP).toString());
        // 税前总额
        exportExcelDto.setPreTaxTotalAmount(new BigDecimal(exportExcelDto.getNetAmount()).subtract(new BigDecimal(exportExcelDto.getTotalTax())).setScale(2, RoundingMode.HALF_UP).toString());
        // 成功单数
        exportExcelDto.setSuccessNumber(new BigDecimal(exportExcelDto.getTotalCount()).subtract(new BigDecimal(exportExcelDto.getRefundPreviousCount())).setScale(2, RoundingMode.HALF_UP).toString());
        // 退款总额
        exportExcelDto.setRefundAmount(new BigDecimal(exportExcelDto.getRefundCurrentAmount()).add(new BigDecimal(exportExcelDto.getRefundPreviousAmount())).setScale(2, RoundingMode.HALF_UP).toString());
        // 退单单数
        exportExcelDto.setRefundCount(new BigDecimal(exportExcelDto.getRefundCurrentCount()).add(new BigDecimal(exportExcelDto.getRefundPreviousCount())).setScale(2, RoundingMode.HALF_UP).toString());

        return exportExcelDto;
    }

    @Override
    public Map<String, List<OrderEntity>> querySaleOrderList(String billDate, String storeId) {
        Map<String, List<OrderEntity>> result = new HashMap<>();
        // 查询当天所有订单
        List<OrderEntity> orderEntityList = orderDao.queryCurrentPreviousOrderList(billDate, storeId);
        result.put("current", orderEntityList);
        // 查询当天退前期订单
        List<OrderEntity> refundPreviousOrderList = orderDao.queryRefundPreviousOrderList(billDate, storeId);
        result.put("previous", refundPreviousOrderList);

        return result;
    }

    @Override
    public Map<String, List<TaxDetailDto>> queryTaxDetailList(String billDate, String storeId) {
        Map<String, List<TaxDetailDto>> result = new HashMap<>();
        // 查询当天所有订单税单
        List<TaxDetailDto> taxDetailList = orderDao.queryCurrentTaxDetailList(billDate, storeId);

        // 计算税前价，增值税，消费税
        BigDecimal discountRate = new BigDecimal(0.7);
        if (taxDetailList != null && taxDetailList.size() != 0) {
            for (TaxDetailDto taxDetailDto : taxDetailList) {
                // 获取实际支付价格
                String postTaxPrice = taxDetailDto.getPostTaxPrice();
                // 获取总税额
                String taxStr = taxDetailDto.getTax();
                // 税前金额
                BigDecimal tax = new BigDecimal(taxStr);
                BigDecimal pretaxPrice = new BigDecimal(postTaxPrice).subtract(tax).setScale(2, RoundingMode.HALF_UP);
                // 计算综合税率
                BigDecimal taxRate = tax.divide(pretaxPrice, 4, RoundingMode.HALF_UP);
                // 消费税率
                BigDecimal saleTaxRate = new BigDecimal(taxDetailDto.getSaleTaxRate()).divide(new BigDecimal(100), 2, RoundingMode.HALF_UP);
                // 综合税率
                BigDecimal vatRate = new BigDecimal(taxDetailDto.getVatRate()).divide(new BigDecimal(100), 2, RoundingMode.HALF_UP);
//              消费税 = （明细商品总价 / (1-消费税税率)） * 消费税税率
//              增值税 = (明细商品总价 + 消费税) * 增值税税率
//              订单该商品总税费 = （商品消费税 + 商品增值税）* 0.7
                // 如果大于，要算消费税
                BigDecimal saleTax = new BigDecimal(0);
                BigDecimal vat = new BigDecimal(0);
                if (taxRate.compareTo(new BigDecimal("0.23")) > 0) {
                    saleTax = pretaxPrice.divide(new BigDecimal(1).subtract(saleTaxRate), 2, RoundingMode.HALF_UP).multiply(saleTaxRate).
                            setScale(2, RoundingMode.HALF_UP);
                    vat = pretaxPrice.add(saleTax).multiply(vatRate).
                            multiply(discountRate).setScale(2, RoundingMode.HALF_UP);
                    saleTax = saleTax.multiply(discountRate).setScale(2, RoundingMode.HALF_UP);

                } else {
                    // 不需要算消费税,增值税计算
                    vat = pretaxPrice.multiply(vatRate).multiply(discountRate).setScale(2, RoundingMode.HALF_UP);
                }
                taxDetailDto.setSaleTax(saleTax.toString());
                taxDetailDto.setVat(vat.toString());
            }
        }

        result.put("current", taxDetailList);
        // 查询当天退前期订单税单
        List<TaxDetailDto> refundPrevioustaxDetailList = orderDao.queryRefundPreviousTaxDetailList(billDate, storeId);

        // 计算税前价，增值税，消费税
        if (refundPrevioustaxDetailList != null && refundPrevioustaxDetailList.size() != 0) {
            for (TaxDetailDto taxDetailDto : refundPrevioustaxDetailList) {
                // 获取实际支付价格
                String postTaxPrice = taxDetailDto.getPostTaxPrice();
                // 获取总税额
                String taxStr = taxDetailDto.getPreTax();
                // 税前金额
                BigDecimal tax = new BigDecimal(taxStr);
                BigDecimal pretaxPrice = new BigDecimal(postTaxPrice).subtract(tax).setScale(2, RoundingMode.HALF_UP);
                // 计算综合税率
                BigDecimal taxRate = tax.divide(pretaxPrice, 4, RoundingMode.HALF_UP);
                // 消费税率
                BigDecimal saleTaxRate = new BigDecimal(taxDetailDto.getPreSaleTax()).divide(new BigDecimal(100), 2, RoundingMode.HALF_UP);
                // 综合税率
                BigDecimal vatRate = new BigDecimal(taxDetailDto.getPreVat()).divide(new BigDecimal(100), 2, RoundingMode.HALF_UP);
//              消费税 = （明细商品总价 / (1-消费税税率)） * 消费税税率
//              增值税 = (明细商品总价 + 消费税) * 增值税税率
//              订单该商品总税费 = （商品消费税 + 商品增值税）* 0.7
                // 如果大于，要算消费税
                BigDecimal saleTax = new BigDecimal(0);
                BigDecimal vat = new BigDecimal(0);
                if (taxRate.compareTo(new BigDecimal("0.23")) > 0) {
                    saleTax = pretaxPrice.divide(new BigDecimal(1).subtract(saleTaxRate), 2, RoundingMode.HALF_UP).multiply(saleTaxRate).
                            multiply(discountRate).setScale(2, RoundingMode.HALF_UP);
                    vat = pretaxPrice.add(saleTax).multiply(vatRate).
                            multiply(discountRate).setScale(2, RoundingMode.HALF_UP);

                } else {
                    // 不需要算消费税,增值税计算
                    vat = pretaxPrice.multiply(vatRate).multiply(discountRate).setScale(2, RoundingMode.HALF_UP);
                }
                taxDetailDto.setPreSaleTax(saleTax.compareTo(BigDecimal.ZERO) == 0 ? saleTax.toString() : "-" + saleTax.toString());
                taxDetailDto.setPreVat(vat.compareTo(BigDecimal.ZERO) == 0 ? vat.toString() : "-" + vat.toString());
            }
        }

        result.put("previous", refundPrevioustaxDetailList);

        return result;
    }

    @Override
    public List<String> queryInveResponse(String orderSn) throws IOException {
        Map<String, String> sParaTemp = new TreeMap<String, String>();
        sParaTemp.put("data", orderSn);
        sParaTemp.put("merchId", omsMerchProperties.getMerchSn());
        String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
        sParaTemp.put("timestamp", timestamp);
        //生成要请求给oms秘钥
//        String sign = OmsSign.sign(sParaTemp,cus.getWaybill().get("secret-key"));
        LOGGER.info("md5混淆码参数:" + omsMerchProperties.getMd5Salt());
        String sign = OmsSign.sign(sParaTemp, omsMerchProperties.getMd5Salt());
        sParaTemp.put("sign", sign);
        //构建Request
        String url = omsMerchProperties.getQueryInveResponseUrl();
        Request request = com.kmall.admin.utils.oms.OkHttpUtils.buildRequest(url, JSON.toJSONString(sParaTemp));
        LOGGER.info("oms的请求报文：" + request);
        // 同步访问,返回结果字符串
        String responseString = null;
        try {

            responseString = com.kmall.admin.utils.oms.OkHttpUtils.post(request);

        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }

        LOGGER.info("oms的响应报文" + responseString);
        //解析响应数据
        Gson gson = new Gson();
        ResponseMessage result = gson.fromJson(responseString, ResponseMessage.class);
        if (result == null) {
            String info = "解析响应数据Result失败";
            LOGGER.error("--- {}", info);
            throw new RuntimeException(info);
        }
        ResponseMessageData data = result.getData();
        List rows = data.getRows();
        List<String> resultMessage = new LinkedList<>();
        for (Object row : rows) {
            if (row instanceof ArrayList) {
                for (Object o : ((ArrayList<?>) row)) {
                    if (o instanceof LinkedTreeMap) {
                        String cusReturnInfo = (String) ((LinkedTreeMap<?, ?>) o).get("cusReturnInfo");
                        resultMessage.add(cusReturnInfo);
                    }
                }
            }
        }
//        cusReturnInfo -> [Code:2600;Desc:放行]
        return resultMessage;
    }

    /**
     * 查询所有状态为201的订单。且下单时间超过5分钟的订单
     *
     * @return
     */
    @Override
    public List<OrderEntity> queryAll201Order() {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String date = format.format(new Date());
        return orderDao.queryAll201Order(date);

    }

    /**
     * 恢复kmall退单冻结的库存
     *
     * @param orderSn
     */
    @Override
    @Transactional
    public void toBeRestored(String orderSn) {

        // 查询该订单在库存是否已经释放过，避免重复恢复库存
        OrderEntity orderInfo = orderDao.queryObjectByOrderSn(orderSn);
        OrderRefundEntity orderRefundEntity = orderRefundService.queryObjectByOrderId(orderInfo.getId());
        if (orderRefundEntity == null) {
            LOGGER.error("该订单无退款记录，订单号{}", orderSn);
            throw new RuntimeException("该订单无退款记录，订单号:" + orderSn);
        }
        Integer restore = orderRefundEntity.getRestore();
        if (restore == 1) {
            LOGGER.error("该订单库存记录已恢复过，订单号{}", orderSn);
            throw new RuntimeException("该订单库存记录已恢复过，订单号:" + orderSn);
        }
        restoreInventory(orderInfo, "oms退单成功，恢复库存");
        orderRefundEntity.setRestore(1);
        orderRefundService.update(orderRefundEntity);

    }

    @Override
    public Ticket printMsgEwb(long id, String sessionId) {
            OrderEntity orderEntity = queryInfos(id);

            List<OrderGoodsEntity> orderGoodsEntityList = orderEntity.getOrderGoodsEntityList();
            // 获取门店
            StoreEntity storeEntity = storeDao.queryObject(orderEntity.getStoreId());
            // 获取清关信息
            OrderProcessRecordEntity orderProcessRecordEntity =
                    orderProcessRecordDao.queryObjectByOrderSn(orderEntity.getOrderSn());

            // 小票头
            TicketHead head = new TicketHead();
            head.setTitle(storeEntity.getStoreName());
            //门店地址
            head.setStoreAddress(storeEntity.getStoreAddress());
            //        head.setMemberId(orderEntity.getUserName().toString());
            head.setOrderId(orderEntity.getOrderSn());
            head.setTradeTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE").format(orderEntity.getPayTime()));

            // 商品信息
            Integer goodsTotal = 0; // 商品总个数
            BigDecimal total = Constant.ZERO; // 商品总计
            BigDecimal taxTotal = Constant.ZERO; //税费总计
            List<Goods> goodsList = new ArrayList<>();
            BigDecimal discountedPrice = Constant.ZERO; // 优惠金额
            for (OrderGoodsEntity orderGoods : orderGoodsEntityList) {
                goodsTotal += orderGoods.getNumber();
                total = total.add(orderGoods.getRetailPrice().multiply(new BigDecimal(orderGoods.getNumber())))
                        .setScale(2, BigDecimal.ROUND_HALF_UP);
                discountedPrice = discountedPrice.add(orderGoods.getDiscountedPrice());

                GoodsEntity goodsEntity = goodsService.queryObject(orderGoods.getGoodsId());
                BigDecimal goodsTax = CalculateTax.calculateFinalTax(goodsEntity, orderGoods.getRetailPrice(), goodsService).setScale(3, RoundingMode.HALF_UP);
                goodsTax = goodsTax.multiply(new BigDecimal(orderGoods.getNumber())).setScale(2, RoundingMode.HALF_UP);
                taxTotal = taxTotal.add(goodsTax).setScale(2, RoundingMode.HALF_UP);

                Goods goods = new Goods(orderGoods.getGoodsName(),
                        orderGoods.getRetailPrice().toString(), // 含税价
//                    beforeTaxPrice.toString(),// 税前价
                        goodsTax.toString(),
                        orderGoods.getNumber().toString(),
                        new BigDecimal(orderGoods.getNumber()).multiply(orderGoods.getRetailPrice()).setScale(2, RoundingMode.HALF_UP).toString(),
                        orderGoods.getDiscountedPrice().toString());
                goodsList.add(goods);
            }

            // 收银信息
            CashInfo cashInfo = new CashInfo();
            cashInfo.setGoodsTotal(goodsTotal.toString());
            cashInfo.setTotal(total.setScale(2, BigDecimal.ROUND_HALF_UP).toString());
            cashInfo.setTaxTotal(taxTotal.setScale(2, BigDecimal.ROUND_HALF_UP).toString());
            cashInfo.setReceipts(orderEntity.getActualPrice().setScale(2, BigDecimal.ROUND_HALF_UP).toString());
            cashInfo.setOddChange(discountedPrice.toString());
            cashInfo.setCoupon(orderEntity.getCouponPrice().setScale(2, BigDecimal.ROUND_HALF_UP).toString());
            cashInfo.setFreight(
                    new BigDecimal(orderEntity.getFreightPrice()).setScale(2, BigDecimal.ROUND_HALF_UP).toString());
            if ("alipay".equals(orderEntity.getPayFlag())) {
                cashInfo.setPaymentMode("支付宝支付");
            } else {
                cashInfo.setPaymentMode("微信支付");
            }
            // 海关清单
            CusListing cusListing = new CusListing();
            cusListing.setOrderId(orderEntity.getOrderSn());
            if (!orderEntity.getOrderBizType().equalsIgnoreCase(Dict.orderBizType.item_11.getItem())) {
                cusListing.setWaybillId(orderProcessRecordEntity.getLogisticsNo());
                cusListing.setInvtNo(orderProcessRecordEntity.getInvtNo()==null?"":orderProcessRecordEntity.getInvtNo());

                cusListing.setConsignee(orderEntity.getConsignee());
                // 脱敏设置
                if (StringUtils.isNotEmpty(cusListing.getConsignee()) && cusListing.getConsignee().length() > 1) {
                    cusListing.setConsignee(new StringBuilder(cusListing.getConsignee()).replace(1, 2, "*").toString());
                }
                cusListing.setConsigneeTel(orderEntity.getMobile());
                if (StringUtils.isNotEmpty(cusListing.getConsigneeTel())) {
                    cusListing.setConsigneeTel(new StringBuilder(cusListing.getConsigneeTel()).replace(3, 7, "****").toString());
                }
            }
            cusListing.setOriginAddress(PrintTicketPropertiesBuilder.instance().getAddress());
            cusListing.setDeliveryAddress(storeEntity.getStoreAddress());
            // 尝试在取货码表中查询数据，如果有的话就改变状态
//            String orderSn = orderEntity.getOrderSn();
//            PickUpCodeEntity pickUpCodeEntity = pickUpCodeService.queryObject(orderSn);
//            if (pickUpCodeEntity != null) {
//                pickUpCodeEntity.setPickUpCodeStatus("0");
//                pickUpCodeService.update(pickUpCodeEntity);
//
//            }
            TicketMailInfo mailInfo = new TicketMailInfo();
            String exprNo = orderProcessRecordEntity.getLogisticsNo();
            if (StringUtils.isNullOrEmpty(exprNo)) {
                throw new RRException("快递面单为空，请联系客服");
            }
            //图片地址
            mailInfo.setStoreImgUrl(storeEntity.getStoreImgUrl()==null?"/statics/img/cw_qrcode.png":storeEntity.getStoreImgUrl().trim());
            mailInfo.setExprNo(exprNo);
            String logoUrl = "/statics/img/sf_img.jpg";

            Map<String, String> logoMap = new HashMap<>();
            logoMap.put("yto", "/statics/img/yto_logo.jpg");
            logoMap.put("best", "/statics/img/bestex_logo3.png");
            logoMap.put("sf", "/statics/img/sf_img.jpg");
            if (StringUtils.isNotEmpty(orderEntity.getShippingCode()) && logoMap.containsKey(orderEntity.getShippingCode())) {
                logoUrl = logoMap.get(orderEntity.getShippingCode());
            }

            mailInfo.setExprLogoUrl(logoUrl);
            byte[] barCode128 = BarcodeUtil.generateBarCode128(exprNo, 6.0D, null, true, false);
            String exprNoBase64Img = new String(Base64.getEncoder().encode(barCode128));
            mailInfo.setShopTel(storeEntity.getTelephoneNumber());

            AddressEntity addressEntity = addressDao.queryStoreAddress(storeEntity.getId(),Dict.addressStatus.item_1.getItem());
            // 发货人
            mailInfo.setSenderTel(addressEntity.getTelNumber());
            mailInfo.setSenderName("CW澳洲大药房");
            mailInfo.setSenderProvince(addressEntity.getProvinceName());
            mailInfo.setSenderCity(addressEntity.getCityName());
            mailInfo.setSenderDistrict(addressEntity.getCountyName());
            mailInfo.setSenderAddress(addressEntity.getDetailInfo());

            // 收货人
            mailInfo.setConsigneeMob(new StringBuilder(orderEntity.getMobile()).replace(3, 7, "****").toString());
            mailInfo.setConsigneeName(new StringBuilder(orderEntity.getConsignee()).replace(1, 2, "*").toString());
            mailInfo.setConsigneeProvince(orderEntity.getProvince());
            mailInfo.setConsigneeCity(orderEntity.getCity());
            mailInfo.setConsigneeDistrict(orderEntity.getDistrict());
            mailInfo.setConsigneeAddress(orderEntity.getAddress());

            mailInfo.setExprNoBase64Img(exprNoBase64Img);
            return TicketPrintUtil.print(head, goodsList, cashInfo, cusListing, mailInfo);
    }

    /**
     * 计算优惠价格，活动价格
     *
     * @param calculateOrderDiscountPriceVo 请求参数
     * @return 商品集合
     */
    @Override
    public CalculateOrderDiscountPriceResponseVO calculateOrderDiscountPrice(CalculateOrderDiscountPriceVO calculateOrderDiscountPriceVo) {
        if (Objects.isNull(calculateOrderDiscountPriceVo)) {
            LOGGER.error("计算活动优惠价格，请求参数为null！");
            throw new ServiceException("计算活动优惠价格，请求参数为null！");
        }
        CalculateOrderDiscountPriceResponseVO calculateOrderDiscountPriceResponseVO = new CalculateOrderDiscountPriceResponseVO();
        String storeId = calculateOrderDiscountPriceVo.getStoreId();
        String memberCode = calculateOrderDiscountPriceVo.getMemberCode();
        calculateOrderDiscountPriceResponseVO.setMemberCode(memberCode);
        List<GoodsDetailsDto> goodsDetailsDtos = calculateOrderDiscountPriceVo.getGoodsList();
        BigDecimal orderTotalPrice = BigDecimal.ZERO;
        List<QueryGoodsVO> goodsVos = new ArrayList<>();
        for (GoodsDetailsDto good : goodsDetailsDtos) {
            // 清空上一次计算活动价格的相关信息
            BigDecimal deductionPrice = good.getDeductionPrice();
            if (Objects.nonNull(deductionPrice)) {
                good.setDeductionPrice(null);
            }
            Integer deductionScore = good.getDeductionScore();
            if (Objects.nonNull(deductionScore)) {
                good.setDeductionScore(null);
            }
            BigDecimal discountedPrice = good.getDiscountedPrice();
            if (Objects.nonNull(discountedPrice)) {
                good.setDiscountedPrice(null);
            }
            String activity = good.getActivity();
            if (Objects.nonNull(activity)) {
                good.setActivity(null);
            }
            BigDecimal actualPaymentAmount = good.getActualPaymentAmount();
            good.setActualPaymentAmount(good.getRetailPrice());

            QueryGoodsVO queryGoodsVo = new QueryGoodsVO();
            BeanUtils.copyProperties(good, queryGoodsVo);
            queryGoodsVo.setSku(good.getGoodsSn());
            queryGoodsVo.setStoreId(Long.parseLong(storeId));
            queryGoodsVo.setDisCountedPrice(BigDecimal.ZERO);
            queryGoodsVo.setTotalPrice(actualPaymentAmount);
            orderTotalPrice = orderTotalPrice.add(good.getRetailPrice());
            goodsVos.add(queryGoodsVo);
        }
        calculateOrderDiscountPriceResponseVO.setOrderTotalPrice(orderTotalPrice);
        calculateOrderDiscountPriceResponseVO.setGoodsDetailsDtos(goodsDetailsDtos);

        // 查询商品表
        List<GoodsEntity> goodsEntities = goodsService.queryGoodsStockByQueryGoodsVoList(goodsVos);
        Map<String, GoodsEntity> goodsMap = goodsEntities.stream().collect(Collectors.toMap(GoodsEntity::getSku, Function.identity(), (k1, k2) -> k2));

        /*
         * 2.查询当前时间，该门店是否有活动，如果有活动，查询开启了哪些营销方式
         * 参数： 当前时间  门店id
         */
        List<MkActivitiesEntity> mkActivitiesEntityList = mkActivitiesService.queryByNow(storeId, DateUtils.format(new Date(), "yyyy-MM-dd"));
        // 活动优先级判定，特价>打折>满减/满赠>优惠券>积分抵扣;
//        List<Constants.ActivityTopicEnum> activityTopicEnums = Arrays.asList(Constants.ActivityTopicEnum.values());
//        for (MkActivitiesEntity mkActivitiesEntity : mkActivitiesEntityList) {
//            for (Constants.ActivityTopicEnum activityTopicEnum : activityTopicEnums) {
//                if (activityTopicEnum.get) {
//
//                }
//            }
//        }
        /*
         * 活动相关规则：
         * 1. 优先优惠券再去计算积分
         * 2. 满赠的赠品商品在推送订单时零售价为0
         * 3. 任何活动都优先于积分计算
         * 4. 活动之间具有互斥性
         */
        if (CollectionUtils.isEmpty(mkActivitiesEntityList) && org.springframework.util.StringUtils.isEmpty(memberCode)) {
            LOGGER.info("门店【{}】，在当前时间无相关活动信息！", storeId);
            for (GoodsDetailsDto goodsDetailsDto : goodsDetailsDtos) {
                GoodsEntity goodsEntity = new GoodsEntity();
                BeanUtils.copyProperties(goodsDetailsDto, goodsEntity);
                goodsEntity.setGoodsRate(new BigDecimal(goodsDetailsDto.getGoodsRate()));
                // 无活动情况，实际支付价 = 零售价
                BigDecimal tax = CalculateTax.calculateFinalTax(goodsEntity , goodsEntity.getRetailPrice(), goodsService).setScale(3,RoundingMode.HALF_UP);
                // 预估税
                goodsDetailsDto.setGoodstaxes(String.valueOf(tax.multiply(new BigDecimal(goodsDetailsDto.getSellVolume()))));
            }
            calculateOrderDiscountPriceResponseVO.setGoodsDetailsDtos(goodsDetailsDtos);
            return calculateOrderDiscountPriceResponseVO;
        }

        List<Integer> brandIdList = goodsEntities.stream().map(GoodsEntity::getBrandId).collect(Collectors.toList());
        List<Integer> categoryIdList = goodsEntities.stream().map(GoodsEntity::getCategoryId).collect(Collectors.toList());
        // 活动标识
        AtomicBoolean activityFlag = new AtomicBoolean(true);
        // 限时特价活动标识
        AtomicBoolean promotionActivityFlag = new AtomicBoolean(false);
        // 与积分抵扣互斥的sku
        List<String> promotionSkuList = new ArrayList<>();
        // 判断活动类型并排序，再确定购物栏中商品是否满足活动条件
        mkActivitiesEntityList.stream().filter(mkActivitiesEntity -> {
            if (!Constants.ActivityTopicEnum.JFDK.getTopicCode().equals(mkActivitiesEntity.getMkaTopic())) {
                return true;
            }
            if (Objects.isNull(mkActivitiesEntity.getPriority())) {
                LOGGER.error("活动：【{}】，活动ID：【{}】未设置优先级！请先设置优先级！", mkActivitiesEntity.getMkaTopic(), mkActivitiesEntity.getMkaId());
                throw new ServiceException(String.format("活动：【%s】，活动ID：【%s】未设置优先级！请先设置优先级！", mkActivitiesEntity.getMkaTopic(), mkActivitiesEntity.getMkaId()));
            }
            return false;
        }).sorted().forEach(mkActivitiesEntity -> {
            String mkaStoreId = mkActivitiesEntity.getMkaStoreId();
            Long mkaId = mkActivitiesEntity.getMkaId();
            String mkaTopic = mkActivitiesEntity.getMkaTopic();
            if (org.springframework.util.StringUtils.isEmpty(mkaTopic)) {
                LOGGER.error("活动主题为空！请检查活动设置！");
                throw new ServiceException("价活动主题为空！请检查活动设置！");
            }
            Constants.ActivityTopicEnum activityTopicEnum = Constants.ActivityTopicEnum.valueOf(mkaTopic.toUpperCase());
            // 活动之间的优先级：特价>打折>满减/满赠>优惠券>积分抵扣
            if (activityTopicEnum == Constants.ActivityTopicEnum.LSCX) {
                // 判断商品是否符合限时特价活动要求
                List<MkActivitiesPromotionEntity> mkActivitiesPromotionEntities = mkActivitiesPromotionService.queryListByMkaIdAndStoreId(mkaId.intValue(), storeId);
                if (CollectionUtils.isEmpty(mkActivitiesPromotionEntities)) {
                    LOGGER.error("查询临时促销活动信息结果为空！mka_id：{}, store_id：{}", mkaId, storeId);
                }
                // 限时特价，直接替换实际支付价即可，并且拿特价计算税款
                mkActivitiesPromotionEntities.forEach(mkActivitiesPromotionEntity -> {
                    String entityBarcode = mkActivitiesPromotionEntity.getBarcode();
                    String entityGoodsSn = mkActivitiesPromotionEntity.getSku();
                    BigDecimal activityPrice = mkActivitiesPromotionEntity.getActivityPrice();
                    String shopSn = mkActivitiesPromotionEntity.getShopSn();
                    String rejectScore = mkActivitiesPromotionEntity.getRejectScore();
                    // 如果与积分抵扣互斥的，记录sku
                    if (!org.springframework.util.StringUtils.isEmpty(rejectScore) && Constants.PromotionActivityRejectEnum.REJECT.getCode().equals(rejectScore)) {
                        promotionSkuList.add(entityGoodsSn);
                    }
                    goodsDetailsDtos.forEach(goodsDetailsDto -> {
                        String sku = goodsDetailsDto.getSku();
                        String prodBarcode = goodsDetailsDto.getProdBarcode();
                        BigDecimal retailPrice = goodsDetailsDto.getRetailPrice();
                        if (entityBarcode.equals(prodBarcode) && entityGoodsSn.equals(sku) && shopSn.equals(storeId)) {
                            GoodsEntity goodsEntity = goodsMap.get(sku);
                            BigDecimal tax = CalculateTax.calculateFinalTax(goodsEntity, activityPrice, goodsService).setScale(3, RoundingMode.HALF_UP);
                            goodsDetailsDto.setActualPaymentAmount(activityPrice);
                            goodsDetailsDto.setGoodstaxes(String.valueOf(tax.multiply(new BigDecimal(goodsDetailsDto.getSellVolume()))));
                            goodsDetailsDto.setActivity(Constants.ActivityTopicEnum.LSCX.getTopicName());
                            goodsDetailsDto.setDiscountedPrice(retailPrice.subtract(activityPrice));
                            goodsDetailsDto.setDeductionPrice(null);
                            activityFlag.set(false);
                            promotionActivityFlag.set(true);
                        }
                    });
                });
            } else if (activityTopicEnum == Constants.ActivityTopicEnum.MZ) {
                // 判断商品是否符合满赠活动要求
                MkActivitiesFullGiftEntity mkActivitiesFullGiftEntity = mkActivitiesFullGiftService.queryObjectByMkaIdAndStoreId(mkaId.intValue(), storeId);
                if (Objects.isNull(mkActivitiesFullGiftEntity)) {
                    LOGGER.error("查询满赠活动信息结果为空！mka_id：{}, store_id：{}", mkaId, storeId);
                } else {
                    Long brandId = mkActivitiesFullGiftEntity.getBrandId();
                    Long categoryId = mkActivitiesFullGiftEntity.getCategoryId();
                    Constants.ActivityType fullGiftActivityType = Constants.ActivityType.valueOf(mkActivitiesFullGiftEntity.getFullGiftType());
                    switch (fullGiftActivityType) {
                        case BRAND:
                            if (Objects.isNull(brandId)) {
                                LOGGER.error("满赠活动品牌编号为空，计算失败！请检查活动设置！活动ID：{}", mkActivitiesFullGiftEntity.getMkaId());
                                throw new ServiceException(String.format("满赠活动品牌编号为空，计算失败！请检查活动设置！活动ID：%s", mkActivitiesFullGiftEntity.getMkaId()));
                            }
                            if (brandIdList.contains(brandId.intValue())) {
                                // 活动包含该商品品牌，此次订单该品牌商品
                                List<GoodsEntity> goodsEntityList = goodsEntities.stream().filter(goodsEntity -> brandId.intValue() == goodsEntity.getBrandId()).collect(Collectors.toList());
                                AtomicReference<BigDecimal> brandTotalPrice = new AtomicReference<>(BigDecimal.ZERO);
                                goodsEntityList.forEach(goodsEntity -> {
                                    brandTotalPrice.set(brandTotalPrice.get().add(goodsEntity.getRetailPrice()));
                                });
                                if (brandTotalPrice.get().compareTo(mkActivitiesFullGiftEntity.getQualifiedAmount()) >= 0) {
                                    // 满足满赠条件
                                    String giftGoodsSn = mkActivitiesFullGiftEntity.getGiftGoodsSn();
                                    String giftBarcode = mkActivitiesFullGiftEntity.getGiftBarcode();
                                    GoodsEntity goodsEntity = goodsService.queryGoodsStockByBarcodeAndStoreIdAndSku(giftBarcode, Integer.parseInt(mkaStoreId), giftGoodsSn);
                                    GoodsDetailsDto goodsDetailsDto = new GoodsDetailsDto();
                                    BeanUtils.copyProperties(goodsEntity, goodsDetailsDto);
                                    // 除了限时促销（需要向海关备案)，其它活动都拿海关备案价来算税款
                                    BigDecimal tax = CalculateTax.calculateFinalTax(goodsEntity, goodsEntity.getRetailPrice(), goodsService).setScale(3, RoundingMode.HALF_UP);
                                    goodsDetailsDto.setGoodstaxes(String.valueOf(tax.multiply(new BigDecimal(goodsDetailsDto.getSellVolume()))));
                                    goodsDetailsDto.setActualPaymentAmount(BigDecimal.ZERO);
                                    goodsDetailsDto.setActivity(Constants.ActivityTopicEnum.MZ.getTopicName());
                                    goodsDetailsDto.setGiftNumber(mkActivitiesFullGiftEntity.getGiftNumber());
                                    goodsDetailsDto.setDiscountedPrice(goodsEntity.getRetailPrice());
                                    goodsDetailsDto.setDeductionPrice(null);
                                    // 添加进商品详情列表
                                    goodsDetailsDtos.add(goodsDetailsDto);
                                    activityFlag.set(false);
                                }
                            }
                            break;
                        case CATEGORY:
                            if (Objects.isNull(categoryId)) {
                                LOGGER.error("满赠活动分类编号为空，计算失败！请检查活动设置！活动ID：{}", mkActivitiesFullGiftEntity.getMkaId());
                                throw new ServiceException(String.format("满赠活动分类编号为空，计算失败！请检查活动设置！活动ID：%s", mkActivitiesFullGiftEntity.getMkaId()));
                            }
                            if (categoryIdList.contains(categoryId.intValue())) {
                                // 活动包含该商品分类
                                List<GoodsEntity> goodsEntityList = goodsEntities.stream().filter(goodsEntity -> brandId.equals(mkActivitiesFullGiftEntity.getCategoryId())).collect(Collectors.toList());
                                AtomicReference<BigDecimal> categoryTotalPrice = new AtomicReference<>(BigDecimal.ZERO);
                                goodsEntityList.forEach(goodsEntity -> {
                                    categoryTotalPrice.set(categoryTotalPrice.get().add(goodsEntity.getRetailPrice()));
                                });
                                if (categoryTotalPrice.get().compareTo(mkActivitiesFullGiftEntity.getQualifiedAmount()) >= 0) {
                                    // 满足满赠条件
                                    String giftGoodsSn = mkActivitiesFullGiftEntity.getGiftGoodsSn();
                                    String giftBarcode = mkActivitiesFullGiftEntity.getGiftBarcode();
                                    GoodsEntity goodsEntity = goodsService.queryGoodsStockByBarcodeAndStoreIdAndSku(giftBarcode, Integer.parseInt(mkaStoreId), giftGoodsSn);
                                    GoodsDetailsDto goodsDetailsDto = new GoodsDetailsDto();
                                    BeanUtils.copyProperties(goodsEntity, goodsDetailsDto);
                                    // 除了限时促销（需要向海关备案)，其它活动都拿海关备案价来算税款
                                    BigDecimal tax = CalculateTax.calculateFinalTax(goodsEntity, goodsEntity.getRetailPrice(), goodsService).setScale(3, RoundingMode.HALF_UP);
                                    goodsDetailsDto.setGoodstaxes(String.valueOf(tax.multiply(new BigDecimal(goodsDetailsDto.getSellVolume()))));
                                    goodsDetailsDto.setActualPaymentAmount(BigDecimal.ZERO);
                                    goodsDetailsDto.setActivity(Constants.ActivityTopicEnum.MZ.getTopicName());
                                    goodsDetailsDto.setGiftNumber(mkActivitiesFullGiftEntity.getGiftNumber());
                                    goodsDetailsDto.setDiscountedPrice(goodsEntity.getRetailPrice());
                                    goodsDetailsDto.setDeductionPrice(null);
                                    // 添加进商品详情列表
                                    goodsDetailsDtos.add(goodsDetailsDto);
                                    activityFlag.set(false);
                                }
                            }
                            break;
                        default:
                            LOGGER.error("未知满赠类型【{},{}】！请联系管理员！", fullGiftActivityType.getActivityType(), fullGiftActivityType.getActivityTypeCode());
                            throw new ServiceException(String.format("未知满赠类型【%s,%s】！请联系管理员！", fullGiftActivityType.getActivityType(), fullGiftActivityType.getActivityTypeCode()));
                    }
                }
            } else if (activityTopicEnum == Constants.ActivityTopicEnum.YHQ) {
                // 判断商品是否符合优惠券活动要求
                List<MkActivitiesCouponEntity> mkActivitiesCouponEntities = mkActivitiesCouponService.queryListByMkaIdAndStoreId(mkaId, storeId);
                if (CollectionUtils.isEmpty(mkActivitiesCouponEntities)) {
                    LOGGER.error("查询优惠券活动信息结果为空！活动ID：{}, 门店编号：{}", mkaId, storeId);
                } else {
                    MkActivitiesCouponEntity mkActivitiesCouponEntity = mkActivitiesCouponEntities.get(0);
                    Integer couponEntityBrandId = mkActivitiesCouponEntity.getBrandId();
                    Integer couponEntityCategoryId = mkActivitiesCouponEntity.getCategoryId();
                    String shopSn = mkActivitiesCouponEntity.getShopSn();
                    if (org.springframework.util.StringUtils.isEmpty(shopSn)) {
                        LOGGER.error("优惠券活动门店编号为空，计算失败！请检查活动设置！活动ID：{}", mkActivitiesCouponEntity.getMkaId());
                        throw new ServiceException(String.format("优惠券活动门店编号为空，计算失败！请检查活动设置！活动ID：%s", mkActivitiesCouponEntity.getMkaId()));
                    }
                    Integer couponEntityStoreId = Integer.parseInt(shopSn);
                    BigDecimal couponPrice = mkActivitiesCouponEntity.getCouponPrice();
                    Constants.ActivityType couponActivityType = Constants.ActivityType.customValueOf(mkActivitiesCouponEntity.getActivityType());
                    if (Objects.isNull(couponActivityType)) {
                        LOGGER.error("错误的优惠券优惠类型：【{}】，请检查活动设置！活动ID：{}", mkActivitiesCouponEntity.getActivityType(), mkActivitiesCouponEntity.getMkaId());
                        throw new ServiceException(String.format("错误的优惠券优惠类型：【%s】，请检查活动设置！活动ID：%s", mkActivitiesCouponEntity.getActivityType(), mkActivitiesCouponEntity.getMkaId()));
                    }
                    switch (couponActivityType) {
                        case BRAND:
                            if (Objects.isNull(couponEntityBrandId)) {
                                LOGGER.error("优惠券活动品牌编号为空，计算失败！请检查活动设置！活动ID：{}", mkActivitiesCouponEntity.getMkaId());
                                throw new ServiceException(String.format("优惠券活动品牌编号为空，计算失败！请检查活动设置！活动ID：%s", mkActivitiesCouponEntity.getMkaId()));
                            }
                            goodsEntities.forEach(goodsEntity -> {
                                if (couponEntityBrandId.equals(goodsEntity.getBrandId())) {
                                    BigDecimal retailPrice = goodsEntity.getRetailPrice();
                                    String sku = goodsEntity.getSku();
                                    String prodBarcode = goodsEntity.getProdBarcode();
                                    if (couponPrice.compareTo(retailPrice) <= 0) {
                                        LOGGER.error("优惠券优惠金额【{}】大于或等于商品【条码：{}，sku：{}】的零售价【{}】，请检查优惠券金额设置！", couponPrice, prodBarcode, sku, retailPrice);
                                        throw new ServiceException(String.format("优惠券优惠金额【%s】大于或等于商品【条码：%s，sku：%s】的零售价【%s】，请检查优惠券金额设置！", couponPrice, prodBarcode, sku, retailPrice));
                                    }
                                    BigDecimal discountAfterPrice = retailPrice.subtract(couponPrice);
                                    GoodsDetailsDto goodsDetailsDto = new GoodsDetailsDto();
                                    BeanUtils.copyProperties(goodsEntity, goodsDetailsDto);
                                    // 除了限时促销（需要向海关备案)，其它活动都拿海关备案价来算税款
                                    BigDecimal tax = CalculateTax.calculateFinalTax(goodsEntity, goodsEntity.getRetailPrice(), goodsService).setScale(3, RoundingMode.HALF_UP);
                                    goodsDetailsDto.setActualPaymentAmount(discountAfterPrice);
                                    goodsDetailsDto.setGoodstaxes(String.valueOf(tax.multiply(new BigDecimal(goodsDetailsDto.getSellVolume()))));
                                    goodsDetailsDto.setActivity(Constants.ActivityTopicEnum.YHQ.getTopicName());
                                    goodsDetailsDto.setDiscountedPrice(retailPrice.subtract(discountAfterPrice));
                                    goodsDetailsDto.setDeductionPrice(null);
                                    goodsDetailsDtos.add(goodsDetailsDto);
                                    activityFlag.set(false);
                                }
                            });
                            break;
                        case CATEGORY:
                            if (Objects.isNull(couponEntityCategoryId)) {
                                LOGGER.error("优惠券活动分类编号为空，计算失败！请检查活动设置！活动ID：{}", mkActivitiesCouponEntity.getMkaId());
                                throw new ServiceException(String.format("优惠券活动分类编号为空，计算失败！请检查活动设置！活动ID：%s", mkActivitiesCouponEntity.getMkaId()));
                            }
                            goodsEntities.forEach(goodsEntity -> {
                                if (couponEntityCategoryId.equals(goodsEntity.getCategoryId())) {
                                    BigDecimal retailPrice = goodsEntity.getRetailPrice();
                                    String sku = goodsEntity.getSku();
                                    String prodBarcode = goodsEntity.getProdBarcode();
                                    if (couponPrice.compareTo(retailPrice) <= 0) {
                                        LOGGER.error("优惠券优惠金额【{}】大于或等于商品【条码：{}，sku：{}】的零售价【{}】，请检查优惠券金额设置！", couponPrice, prodBarcode, sku, retailPrice);
                                        throw new ServiceException(String.format("优惠券优惠金额【%s】大于或等于商品【条码：%s，sku：%s】的零售价【%s】，请检查优惠券金额设置！", couponPrice, prodBarcode, sku, retailPrice));
                                    }
                                    BigDecimal discountAfterPrice = retailPrice.subtract(couponPrice);
                                    GoodsDetailsDto goodsDetailsDto = new GoodsDetailsDto();
                                    BeanUtils.copyProperties(goodsEntity, goodsDetailsDto);
                                    // 除了限时促销（需要向海关备案)，其它活动都拿海关备案价来算税款
                                    BigDecimal tax = CalculateTax.calculateFinalTax(goodsEntity, goodsEntity.getRetailPrice(), goodsService).setScale(3, RoundingMode.HALF_UP);
                                    goodsDetailsDto.setActualPaymentAmount(discountAfterPrice);
                                    goodsDetailsDto.setGoodstaxes(String.valueOf(tax.multiply(new BigDecimal(goodsDetailsDto.getSellVolume()))));
                                    goodsDetailsDto.setActivity(Constants.ActivityTopicEnum.YHQ.getTopicName());
                                    goodsDetailsDto.setDiscountedPrice(retailPrice.subtract(discountAfterPrice));
                                    goodsDetailsDto.setDeductionPrice(null);
                                    goodsDetailsDtos.add(goodsDetailsDto);
                                    activityFlag.set(false);
                                }
                            });
                            break;
                        case PRODUCT:
                            mkActivitiesCouponEntities.forEach(mkActivitiesCouponEntity1 -> {
                                // 单个商品优惠券，有多条记录
                                String activityProductBarcode = mkActivitiesCouponEntity1.getBarcode();
                                String activitySku = mkActivitiesCouponEntity1.getGoodsSn();
                                goodsEntities.forEach(goodsEntity -> {
                                    String sku = goodsEntity.getSku();
                                    String prodBarcode = goodsEntity.getProdBarcode();
                                    // 条码、sku、门店都需一致
                                    if (activitySku.equals(sku) && activityProductBarcode.equals(prodBarcode) && couponEntityStoreId.equals(goodsEntity.getStoreId())) {
                                        BigDecimal retailPrice = goodsEntity.getRetailPrice();
                                        if (couponPrice.compareTo(retailPrice) <= 0) {
                                            LOGGER.error("优惠券优惠金额【{}】大于或等于商品【条码：{}，sku：{}】的零售价【{}】，请检查优惠券金额设置！", couponPrice, prodBarcode, sku, retailPrice);
                                            throw new ServiceException(String.format("优惠券优惠金额【%s】大于或等于商品【条码：%s，sku：%s】的零售价【%s】，请检查优惠券金额设置！", couponPrice, prodBarcode, sku, retailPrice));
                                        }
                                        BigDecimal discountAfterPrice = retailPrice.subtract(couponPrice);
                                        GoodsDetailsDto goodsDetailsDto = new GoodsDetailsDto();
                                        BeanUtils.copyProperties(goodsEntity, goodsDetailsDto);
                                        // 除了限时促销（需要向海关备案)，其它活动都拿海关备案价来算税款
                                        BigDecimal tax = CalculateTax.calculateFinalTax(goodsEntity, goodsEntity.getRetailPrice(), goodsService).setScale(3, RoundingMode.HALF_UP);
                                        goodsDetailsDto.setActualPaymentAmount(discountAfterPrice);
                                        goodsDetailsDto.setGoodstaxes(String.valueOf(tax.multiply(new BigDecimal(goodsDetailsDto.getSellVolume()))));
                                        goodsDetailsDto.setActivity(Constants.ActivityTopicEnum.YHQ.getTopicName());
                                        goodsDetailsDto.setDiscountedPrice(retailPrice.subtract(discountAfterPrice));
                                        goodsDetailsDto.setDeductionPrice(null);
                                        goodsDetailsDtos.add(goodsDetailsDto);
                                        activityFlag.set(false);
                                    }
                                });
                            });
                            break;
                        default:
                            LOGGER.error("未知的优惠券活动分类类型：【{},{}】，请联系管理员！", activityTopicEnum.getTopicCode(), activityTopicEnum.getTopicName());
                            throw new ServiceException(String.format("未知的优惠券活动分类类型：【%s,%s】，请联系管理员！", activityTopicEnum.getTopicCode(), activityTopicEnum.getTopicName()));
                    }
                }
            } else {
                LOGGER.error("未知的活动类型：【{},{}】，请检查活动设置！！", activityTopicEnum.getTopicCode(), activityTopicEnum.getTopicName());
                throw new ServiceException(String.format("未知的活动类型：【%s,%s】，请检查活动设置！！", activityTopicEnum.getTopicCode(), activityTopicEnum.getTopicName()));
            }
        });
        orderTotalPrice = BigDecimal.ZERO;
        for (GoodsDetailsDto good : goodsDetailsDtos) {
            QueryGoodsVO queryGoodsVo = new QueryGoodsVO();
            BeanUtils.copyProperties(good, queryGoodsVo);
            queryGoodsVo.setSku(good.getGoodsSn());
            queryGoodsVo.setStoreId(Long.parseLong(storeId));
            queryGoodsVo.setDisCountedPrice(BigDecimal.ZERO);
            queryGoodsVo.setTotalPrice(good.getActualPaymentAmount());
            orderTotalPrice = orderTotalPrice.add(good.getActualPaymentAmount());
            goodsVos.add(queryGoodsVo);
        }
        calculateOrderDiscountPriceResponseVO.setOrderTotalPrice(orderTotalPrice);
        calculateOrderDiscountPriceResponseVO.setGoodsDetailsDtos(goodsDetailsDtos);


        // 计算完活动优惠后，计算积分抵扣。（活动与积分抵扣不互斥）
        if (!org.springframework.util.StringUtils.isEmpty(memberCode)) {
            String memberInfoByCodeResponseJson;
            Response<Object> response;
            try {
                // 查询会员信息
                memberInfoByCodeResponseJson = haiKongMemberTemplate.getMemberInfoByPhone("{\"phone\":" + memberCode + "}");
                response = JacksonUtil.fromListJson(memberInfoByCodeResponseJson, new TypeReference<Response<Object>>() {
                });
                if (Objects.isNull(response) || Objects.nonNull(response.getErrorCode())) {
                    LOGGER.error("请求会员系统出现异常！error：{}", memberInfoByCodeResponseJson);
                    throw new ServiceException(String.format("请求会员系统出现异常！会员码：%s，error：%s", memberCode, memberInfoByCodeResponseJson));
                }
            } catch (Exception e) {
                LOGGER.error("请求会员系统失败或处理响应失败！", e);
                throw new ServiceException(e);
            }
            BigDecimal afterDiscountPrice;
            if (response.getSuccess()) {
                MemberInfoDTO memberInfoDTO = JacksonUtil.fromStringJson(JacksonUtil.toJson(response.getData()), MemberInfoDTO.class);
                assert memberInfoDTO != null : String.format("会员码：【%s】会员信息错误！%s", memberCode, JacksonUtil.toJson(response));
                // 查询会员表
                UserEntity userEntity = userService.queryByOpenId(memberInfoDTO.getOpenId());
                if (Objects.isNull(userEntity)) {
                    userEntity = new UserEntity();
                    userEntity.setOpenId(memberInfoDTO.getOpenId());
                    userEntity.setMemberCode(memberCode);
                    userService.save(userEntity);
                }
                Integer score = memberInfoDTO.getScore();
                if (Objects.nonNull(score) && score > 0) {
                    // 有积分
                    afterDiscountPrice = calculatePreferentialPrice(orderTotalPrice, score, memberCode, calculateOrderDiscountPriceResponseVO, goodsDetailsDtos, promotionSkuList, mkActivitiesEntityList);
                    LOGGER.info("会员【{}】，当前积分：{}，积分抵扣后的订单金额：{}，积分抵扣前的订单金额：{}", memberCode, score, afterDiscountPrice, orderTotalPrice);
                    calculateOrderDiscountPriceResponseVO.setOrderTotalPrice(afterDiscountPrice);
                    calculateOrderDiscountPriceResponseVO.setGoodsDetailsDtos(goodsDetailsDtos);
                    calculateOrderDiscountPriceResponseVO.setBeforeScore(score);
                    calculateOrderDiscountPriceResponseVO.setOpenId(memberInfoDTO.getOpenId());
                    calculateOrderDiscountPriceResponseVO.setMemberPhone(memberInfoDTO.getPhone());
                    // 订单完成后再添加积分消费记录，以及同步积分信息
                    return calculateOrderDiscountPriceResponseVO;
                } else {
                    LOGGER.error("会员【{}】积分为0，积分抵扣失败！", memberCode);
                    throw new ServiceException(String.format("会员【%s】积分为0，积分抵扣失败！", memberCode));
                }
            } else {
                LOGGER.error("查询会员信息失败！响应结果：{}", memberInfoByCodeResponseJson);
                throw new ServiceException(String.format("会员码：%s，错误码：%s，错误信息：%s", memberCode, response.getErrorCode(), response.getErrorMessage()));
            }
        }
        calculateOrderDiscountPriceResponseVO.setGoodsDetailsDtos(goodsDetailsDtos);
        orderTotalPrice = BigDecimal.ZERO;
        for (GoodsDetailsDto goodsDetailsDto : goodsDetailsDtos) {
            orderTotalPrice = orderTotalPrice.add(goodsDetailsDto.getActualPaymentAmount());
        }
        calculateOrderDiscountPriceResponseVO.setOrderTotalPrice(orderTotalPrice);
        return calculateOrderDiscountPriceResponseVO;
    }

    /**
     * 计算积分抵扣后的订单总金额
     * @param orderTotalPrice   订单商品总价
     * @param score             积分
     * @param memberCode        会员码
     * @param goodsDetailsDtos  订单商品详情
     * @param calculateOrderDiscountPriceResponseVO 响应数据
     * @param promotionSkuList  参与了限时特价活动并且与积分抵扣互斥的sku集合
     *
     * @return                  积分抵扣后的订单总金额
     */
    private BigDecimal calculatePreferentialPrice(BigDecimal orderTotalPrice,
                                                  Integer score,
                                                  String memberCode,
                                                  CalculateOrderDiscountPriceResponseVO calculateOrderDiscountPriceResponseVO,
                                                  List<GoodsDetailsDto> goodsDetailsDtos,
                                                  List<String> promotionSkuList,
                                                  List<MkActivitiesEntity> mkActivitiesEntityList) {
        // 1. 判断是否有积分，是否需要计算积分抵扣后的价格
        AtomicBoolean isCalculateScorePrice = new AtomicBoolean(false);
        if (Objects.nonNull(score) && score > 0) {
            isCalculateScorePrice.set(true);
        }
        // 参与了积分抵扣的活动id
        List<Long> mkaIdList = mkActivitiesEntityList.stream().filter(mkActivitiesEntity -> Constants.ActivityTopicEnum.JFDK.getTopicCode().equals(mkActivitiesEntity.getMkaTopic()))
                .map(MkActivitiesEntity::getMkaId)
                .collect(Collectors.toList());
        if (CollectionUtils.isEmpty(mkaIdList)) {
            LOGGER.error("当前时间【{}】无积分抵扣活动！", new Date());
            return orderTotalPrice;
        }

        List<MkActivitiesScoreEntity> mkActivitiesScoreEntities = mkActivitiesScoreService.queryActivityInfoByMkaIdList(mkaIdList);

        if (CollectionUtils.isEmpty(mkActivitiesScoreEntities)) {
            LOGGER.error("查询积分抵扣活动SKU为空！");
            throw new ServiceException("查询积分抵扣活动SKU为空！请先导入积分抵扣活动信息！");
        }

        // 参与了积分抵扣的sku集合，过滤的是参与的sku，如果该list不为空，则默认其余的sku不参与积分抵扣
        List<String> scoreDeductionAllowSkuList = mkActivitiesScoreEntities.stream()
                .filter(m -> Constants.RejectStatus.ALLOW.getCode().equals(m.getReject()))
                .map(MkActivitiesScoreEntity::getSku)
                .collect(Collectors.toList());
        LOGGER.info("参与积分抵扣的sku集合：{}", scoreDeductionAllowSkuList);
        // 不参与积分抵扣的sku集合，如果该list不为空，则默认其余的sku参与积分抵扣
        List<String> scoreDeductionRejectSkuList = mkActivitiesScoreEntities.stream()
                .filter(m -> Constants.RejectStatus.REJECT.getCode().equals(m.getReject()))
                .map(MkActivitiesScoreEntity::getSku)
                .collect(Collectors.toList());
        LOGGER.info("不参与积分抵扣的sku集合：{}", scoreDeductionRejectSkuList);

        if (!CollectionUtils.isEmpty(scoreDeductionAllowSkuList) && !CollectionUtils.isEmpty(scoreDeductionRejectSkuList)) {
            LOGGER.error("积分抵扣表中既有参与又有不参与！与需求不符！");
            throw new ServiceException("导入的积分抵扣活动商品设置有误！请确保导入的数据中只有参与或者不参与！");
        }
        if (CollectionUtils.isEmpty(scoreDeductionAllowSkuList) && CollectionUtils.isEmpty(scoreDeductionRejectSkuList)) {
            LOGGER.error("积分抵扣表中无是否参与字段！");
            throw new ServiceException("导入的积分抵扣活动商品设置有误！导入的活动商品数据中必须有参与或者不参与！");
        }

        // 当前订单中参与了积分抵扣活动的sku总支付金额
        BigDecimal skuTotalPrice = BigDecimal.ZERO;
        for (GoodsDetailsDto goodsDetailsDto : goodsDetailsDtos) {
            String sku = goodsDetailsDto.getGoodsSn();
            if (!promotionSkuList.contains(sku)) {
                if (!CollectionUtils.isEmpty(scoreDeductionAllowSkuList) && CollectionUtils.isEmpty(scoreDeductionRejectSkuList)) {
                    if (scoreDeductionAllowSkuList.contains(sku)) {
                        BigDecimal skuActualPaymentAmount = goodsDetailsDto.getActualPaymentAmount();
                        skuTotalPrice = skuTotalPrice.add(skuActualPaymentAmount);
                    }
                }
            }
        }
        // 2. 计算积分抵扣后的总价格
        if (isCalculateScorePrice.get()) {
            // HAIKONG_MEMBER_SCORE_LIMIT 系统参数，海控平台统一30积分1块钱
            String scoreLimitStr = sysConfigDao.queryByKey(Constants.HAIKONG_MEMBER_SCORE_LIMIT);
            if (org.springframework.util.StringUtils.isEmpty(scoreLimitStr)) {
                LOGGER.error("计算优惠价格时，未设置统一的抵扣规则！");
                throw new ServiceException(String.format("请先设置统一的积分规则，设置方式：【系统管理】-->【系统参数】，参数名为：【%s】", Constants.HAIKONG_MEMBER_SCORE_LIMIT));
            }
            Integer scoreLimit = Integer.parseInt(scoreLimitStr);
            if (score < scoreLimit) {
                LOGGER.error("用户【{}】的积分数量为：{}，最低需要{}积分才能抵扣！", memberCode, score, scoreLimit);
                calculateOrderDiscountPriceResponseVO.setAfterScore(score);
                throw new ServiceException(String.format("用户【%s】的积分数量为：%s，最低需要%s积分才能抵扣！", memberCode, score, scoreLimit));
            } else {
                // 积分取整
                int scoreInteger = score % scoreLimit == 0 ? score : score - (score % scoreLimit);
                // 过滤掉参与过限时特价并且与积分抵扣互斥的sku，以及未参加积分抵扣活动的sku
                goodsDetailsDtos = goodsDetailsDtos.stream().filter(goodsDetailsDto -> {
                    String sku = goodsDetailsDto.getSku();

                    // 满赠商品不参与积分分摊计算
                    if (Constants.ActivityTopicEnum.MZ.getTopicName().equals(goodsDetailsDto.getActivity())) {
                        return false;
                    }
                    // 如果临时促销中定义了该sku不参与，那么根据优先级不管该商品在积分抵扣中如何设置，都认定为不参与
                    if (!promotionSkuList.contains(sku)) {
                        // 如果导入的商品都为不参与，则其余的商品都默认参与积分抵扣活动
                        if (CollectionUtils.isEmpty(scoreDeductionAllowSkuList) &&
                                !CollectionUtils.isEmpty(scoreDeductionRejectSkuList) &&
                                !scoreDeductionRejectSkuList.contains(sku)) {
                            return true;
                        }
                        // 如果导入的商品都为参与，则默认其余商品不参与
                        if (!CollectionUtils.isEmpty(scoreDeductionAllowSkuList) &&
                                CollectionUtils.isEmpty(scoreDeductionRejectSkuList) &&
                                scoreDeductionAllowSkuList.contains(sku)) {
                            return true;
                        }
                    }
                    // 临时促销中有这个sku，说明不参与积分抵扣
                    return false;
                }).collect(Collectors.toList());
                // 系统设置的最大抵扣比例（最多能抵扣订单金额的比例），在系统管理的系统参数中设置，KEY为 HAIKONG_MEMBER_MAX_SCORE_RATIO
                String scoreRatioStr = sysConfigDao.queryByKey(Constants.HAIKONG_MEMBER_MAX_SCORE_RATIO);
                if (org.springframework.util.StringUtils.isEmpty(scoreRatioStr)) {
                    LOGGER.error("计算优惠价格时，未设置订单的最大积分抵扣比例！");
                    throw new ServiceException(String.format("请先设置订单的最大积分抵扣比例，设置方式：【系统管理】-->【系统参数】，参数名为：【%s】", Constants.HAIKONG_MEMBER_MAX_SCORE_RATIO));
                }
                BigDecimal scoreRatio = new BigDecimal(scoreRatioStr);
                // 总分摊积分
                BigDecimal shareScore = BigDecimal.ZERO;
                // 取整后的积分数量
                BigDecimal scoreIntegerDecimal = BigDecimal.valueOf(scoreInteger);
                // 计算积分能抵扣的金额
                BigDecimal scoreCanDeductionPrice = scoreIntegerDecimal.divide(BigDecimal.valueOf(scoreLimit), 0, BigDecimal.ROUND_FLOOR);
                // 订单详情积分抵扣总金额
                BigDecimal goodsDetailScoreDeductionPrice = BigDecimal.ZERO;
                int size = goodsDetailsDtos.size();
                for (int i = 0; i < size; i++) {
                    GoodsDetailsDto goodsDetailsDto = goodsDetailsDtos.get(i);
                    // 抵扣积分分摊
                    int index = size - 1;
                    String activity = goodsDetailsDto.getActivity();
                    goodsDetailsDto.setActivity(org.springframework.util.StringUtils.isEmpty(activity) ? "积分抵扣" : activity.contains("积分抵扣") ? activity : activity + ",积分抵扣");
                    String sku = goodsDetailsDto.getGoodsSn();
                    String prodBarcode = goodsDetailsDto.getProdBarcode();
                    // 此字段 = 零售价 - 其他活动优惠金额
                    BigDecimal actualPaymentAmount = goodsDetailsDto.getActualPaymentAmount();
                    // 当前商品最大支持抵扣的金额
                    BigDecimal currentSkuMaxDeductionPrice = actualPaymentAmount.multiply(BigDecimal.valueOf(goodsDetailsDto.getSellVolume()))
                                                                                .multiply(scoreRatio).setScale(0, BigDecimal.ROUND_FLOOR);
                    // 其他活动优惠金额
                    BigDecimal otherDiscountedPrice = Objects.isNull(goodsDetailsDto.getDiscountedPrice()) ? BigDecimal.ZERO : goodsDetailsDto.getDiscountedPrice();

                    // 当前商品分摊积分数量，当前商品分摊积分 = 当前商品支付价 / 订单中所有参与积分抵扣商品支付价的和 * 积分取整
                    BigDecimal shareScoreItem = BigDecimal.ZERO;
                    // 当前商品分摊积分抵扣金额，保留两位小数，四舍五入
                    BigDecimal discountedPrice = BigDecimal.ZERO;
                    // 计算抵扣，当商品不是最后一个商品
                    if (i < index) {
                        shareScoreItem = actualPaymentAmount.multiply(scoreIntegerDecimal).divide(skuTotalPrice, 0, BigDecimal.ROUND_FLOOR);
                        discountedPrice = shareScoreItem.divide(BigDecimal.valueOf(scoreLimit), 2, BigDecimal.ROUND_HALF_UP);
                    }
                    // 订单商品详情最后一个商品并且详情不止一个商品
                    if (i == index && size > 1) {
                        // 最后一个商品分摊积分 = 积分总数 - 已分摊积分
                        shareScoreItem = scoreIntegerDecimal.subtract(shareScore);
//                        discountedPrice = shareScoreItem.divide(BigDecimal.valueOf(scoreLimit), 2, BigDecimal.ROUND_HALF_UP);
                        // 2021-12-13最后一个商品修改计算方式，原计算方式：(总抵扣积分 - 已分摊积分) / 30，改为：积分能抵扣的金额 - 已抵扣金额
                        discountedPrice = scoreCanDeductionPrice.subtract(goodsDetailScoreDeductionPrice);
                    }
                    // 订单商品详情只有一个商品的情况下
                    if (size == 1) {
                        // 总计分为所有积分取整
                        shareScoreItem = scoreIntegerDecimal;
                        // 3-3. 计算积分抵扣后的价格
                        discountedPrice = shareScoreItem.divide(BigDecimal.valueOf(scoreLimit), 2, BigDecimal.ROUND_HALF_UP);
                    }
                    // 当前计算出来的积分抵扣金额如果比最大的还要大，则积分抵扣金额为最大抵扣金额，并且积分需要重新计算
                    if (discountedPrice.compareTo(currentSkuMaxDeductionPrice) > 0) {
                        discountedPrice = currentSkuMaxDeductionPrice;
                        shareScoreItem = discountedPrice.multiply(BigDecimal.valueOf(scoreLimit)).setScale(0, BigDecimal.ROUND_FLOOR);
                    }
                    // 总分摊积分
                    shareScore = shareScore.add(shareScoreItem);
                    // 订单总积分抵扣金额，减去其他优惠金额
                    goodsDetailScoreDeductionPrice = goodsDetailScoreDeductionPrice.add(discountedPrice);
                    // 设置积分的优惠金额
                    goodsDetailsDto.setDeductionPrice(discountedPrice);
                    // 设置实际支付价
                    goodsDetailsDto.setActualPaymentAmount(actualPaymentAmount.subtract(discountedPrice));
                    // 设置抵扣积分数量
                    goodsDetailsDto.setDeductionScore(shareScoreItem.intValue());
                    if (Objects.nonNull(otherDiscountedPrice)) {
                        discountedPrice = discountedPrice.add(otherDiscountedPrice);
                    }
                    // 设置总优惠金额
                    goodsDetailsDto.setDiscountedPrice(discountedPrice);
                    LOGGER.info("--------------------------------------------------------");
                    LOGGER.info("【计算优惠价】sku：【{}】，条码：【{}】积分抵扣{}元，抵扣积分{}分", sku, prodBarcode, goodsDetailsDto.getDiscountedPrice(), shareScore.intValue());
                    LOGGER.info("--------------------------------------------------------");
                }
                orderTotalPrice = calculateOrderDiscountPriceResponseVO.getOrderTotalPrice().subtract(goodsDetailScoreDeductionPrice);
                int afterScore = score - shareScore.intValue();
                // 抵扣后的积分数量
                calculateOrderDiscountPriceResponseVO.setAfterScore(afterScore);
                // 最大抵扣比例
                calculateOrderDiscountPriceResponseVO.setScoreLimit(scoreLimit);
                // 抵扣的积分数量
                calculateOrderDiscountPriceResponseVO.setDeductionScore(score - afterScore);
                // 订单总价
                calculateOrderDiscountPriceResponseVO.setOrderTotalPrice(orderTotalPrice);
                // 积分抵扣的总金额
                calculateOrderDiscountPriceResponseVO.setScoreDeductionPrice(goodsDetailScoreDeductionPrice);
                LOGGER.info("会员【{}】，当前积分：{}，抵扣订单金额后剩余积分：{}", memberCode, score, afterScore);
            }
        } else {
            LOGGER.info("会员【{}】的积分小于积分抵扣最低值，不参加积分抵扣！", memberCode);
        }
        return orderTotalPrice;
    }

    /**
     * 重发订单
     * @param orderSn
     * @return
     */
    @Override
    public R resendOrderHkMall(String orderSn) {
        OrderEntity orderEntity = orderDao.queryObjectByOrderSn(orderSn);
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_100.getItem())||
                orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_101.getItem())||
                orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_500.getItem())||
                orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_401.getItem())||
                orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_402.getItem())||
                orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_0.getItem())
        ) {
            return R.error(500,"无法重发订单，请检查订单状态");
        }
        String orderCode = pickUpCodeDao.queryPickUpCodeStatus(orderEntity.getOrderSn());
        if(null==orderCode||"6".equals(orderCode)){
            return R.error(500,"订单尚未发送至下游系统，无法重发订单");
        }else{
            if(Dict.orderCustomsStatus.item_2.getItem().equals(orderCode)||
                    Dict.orderCustomsStatus.item_4.getItem().equals(orderCode)){
                return R.error(500,"订单处于清关放行状态或查验状态，无需重发订单");
            }
        }


        LOGGER.info("=======> [调用VMCShop接口开始发送退款订单数据]"+orderSn);
        Map<String,String> map = new HashMap<>();
        map.put("outer_order_no",orderSn);
        String body = JacksonUtil.toJson(map);
        String response = vmcShopTemplate.resendOrder(body);
        //解析响应数据
        LOGGER.info("=======> [resendOrderHkMall---重发订单数据成功，开始处理后续流程]"+response);
        Map<String,Object> res = JSON.parseObject(response,Map.class);
        if("0".equals(res.get("code").toString())){
            pickUpCodeService.updatePickUpCodeStatusByOrderSn(orderSn, Dict.PickUpCodeStatusEnum.item_0.getStatus());
            return R.ok();
        }else{
            return R.error(500,"重发订单失败");
        }
    }

    /**
     * 设置订单数据
     *
     * @return
     */
    public OrderVo setOrderVo(List<GoodsEntity> goodsList, UserEntity loginUser, Long storeId, String merchSn, BigDecimal disCountAmount, BigDecimal totalTax) {
        OrderVo orderInfo = new OrderVo();

        BigDecimal goodsTotalPrice = new BigDecimal(0.00);
        BigDecimal fullCutCouponDec = Constant.ZERO;  // 非现金抵扣 = 各种优惠价格 +优惠券的价格   暂时借用这个字段去，为了不改动ccnet系统
        BigDecimal couponPrice = disCountAmount;
        BigDecimal freightPrice = Constant.ZERO;
        BigDecimal actualPrice = Constant.ZERO;
        //订单价格计算：订单的总价+运费
        for (GoodsEntity goodsEntity : goodsList) {
            goodsTotalPrice = goodsTotalPrice
                    .add(goodsEntity.getRetailPrice().multiply(new BigDecimal(goodsEntity.getGoodsNumber()))).setScale(2, RoundingMode.HALF_UP);
            fullCutCouponDec = fullCutCouponDec
                    .add(goodsEntity.getDiscountedPrice()).setScale(2, RoundingMode.HALF_UP);
            actualPrice = actualPrice
                    .add(goodsEntity.getActualPaymentAmount()).setScale(2, RoundingMode.HALF_UP);

        }


        BigDecimal orderTotalPrice = goodsTotalPrice.add(new BigDecimal(0));
        fullCutCouponDec = fullCutCouponDec.add(couponPrice).setScale(2, RoundingMode.HALF_UP);

        // 加上税额
        goodsTotalPrice = goodsTotalPrice.subtract(totalTax).setScale(2, RoundingMode.HALF_UP);

        SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");

        String orderSn = "ZWCW" + format.format(new Date()) + CommonUtil.generateOrderNumber();
        orderInfo.setOrder_sn(orderSn);
        orderInfo.setMerchSn(merchSn);
        orderInfo.setUser_id(loginUser.getId().longValue());
        actualPrice = actualPrice.subtract(couponPrice);

        StoreEntity storeEntity = storeDao.queryObject(storeId);
        //收货地址和运费
        orderInfo.setConsignee(loginUser.getUsername());
        orderInfo.setMobile(loginUser.getMobile());
        orderInfo.setCountry("");
        orderInfo.setProvince(storeEntity.getProvinceName());
        orderInfo.setCity(storeEntity.getCityName());
        orderInfo.setDistrict(storeEntity.getCountyName());
        orderInfo.setAddress(storeEntity.getStoreAddress());
        orderInfo.setAddress_id(1L);
        orderInfo.setDelivery_date(new Date());
        orderInfo.setDelivery_remark("无");
        orderInfo.setStore_id(storeId);
        orderInfo.setFreight_price(freightPrice.intValue());

        orderInfo.setCoupon_id(Integer.parseInt(String.valueOf(0L)));
        orderInfo.setCoupon_price(couponPrice);
        orderInfo.setCoupon_name("无");
        orderInfo.setActivity_id(0L);

        //使用的促销费用
        orderInfo.setFull_cut_price(fullCutCouponDec);
        orderInfo.setCampMinusId(0);
        orderInfo.setCampName("");

        //留言
        orderInfo.setPostscript("无");
        orderInfo.setAdd_time(new Date());
        orderInfo.setGoods_price(goodsTotalPrice); // 商品总价
        orderInfo.setOrder_price(orderTotalPrice);
        orderInfo.setActual_price(actualPrice); // 实际支付金额
        orderInfo.setOrder_type("1");
        orderInfo.setOrder_status(0);
        orderInfo.setShipping_status(0);
        orderInfo.setPay_status(0);
        orderInfo.setShipping_id(0L);
        orderInfo.setShipping_fee(Constant.ZERO);
        orderInfo.setIntegral(0);
        orderInfo.setIntegral_money(Constant.ZERO);
        orderInfo.setCreateTime(new Date());
        orderInfo.setModTime(new Date());
        orderInfo.setPayMobile(loginUser.getMobile());
//        orderInfo.setPayTransactionId(orderInfo.getOrder_sn());
        orderInfo.setIsScan("0");//默认未扫描

        orderInfo.setPayMobile(loginUser.getMobile());
        orderInfo.setPay_name(loginUser.getUsername());
        orderInfo.setIsOnfflineOrder(Dict.isOnfflineOrder.item_1.getItem());
        orderInfo.setOrderBizType(Dict.orderBizType.item_10.getItem());

        return orderInfo;
    }

    /**
     * 设置订单数据
     *
     * @return
     */
    public OrderVo setOrderVo(List<GoodsEntity> goodsList, UserEntity loginUser, Long storeId, String merchSn, BigDecimal totalTax, int status, Map mapAddr, BigDecimal actualPrice) {
        OrderVo orderInfo = new OrderVo();

        BigDecimal goodsTotalPrice = BigDecimal.ZERO;
        BigDecimal fullCutCouponDec = Constant.ZERO;  // 非现金抵扣 = 各种优惠价格 +优惠券的价格   暂时借用这个字段去，为了不改动ccnet系统
        BigDecimal couponPrice = BigDecimal.ZERO;
        BigDecimal freightPrice = Constant.ZERO;
        Integer number = 0;
        //订单价格计算：订单的总价+运费
        for (GoodsEntity goodsEntity : goodsList) {
            goodsTotalPrice = goodsTotalPrice
                    .add(goodsEntity.getRetailPrice().multiply(new BigDecimal(goodsEntity.getSellVolume()))).setScale(2, RoundingMode.HALF_UP);
            fullCutCouponDec = fullCutCouponDec
                    .add(goodsEntity.getDiscountedPrice()).setScale(2, RoundingMode.HALF_UP);
            couponPrice = couponPrice.add(goodsEntity.getDiscountedPrice()).setScale(2, RoundingMode.HALF_UP);
            number += goodsEntity.getSellVolume();
        }


        BigDecimal orderTotalPrice = goodsTotalPrice.add(new BigDecimal(0));
        fullCutCouponDec = fullCutCouponDec.add(couponPrice).setScale(2, RoundingMode.HALF_UP);

        // 加上税额
        goodsTotalPrice = goodsTotalPrice.subtract(totalTax).setScale(2, RoundingMode.HALF_UP);

//        SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
//
//        String orderSn = "ZWCW" + format.format(new Date()) + CommonUtil.generateOrderNumber();
//        orderInfo.setOrder_sn(orderSn);
        orderInfo.setMerchSn(merchSn);
        orderInfo.setUser_id(loginUser.getId().longValue());
        orderInfo.setNumber(number);

        //StoreEntity storeEntity = storeDao.queryObject(storeId);
        //随机获取收货人地址
        AddressEntity addressEntity = addressDao.queryStoreAddress(storeId,Dict.addressStatus.item_2.getItem());
        if(null==addressEntity){
            LOGGER.error("setOrderVo---门店未配置收货人地址："+storeId);
            throw new RRException("门店未配置收货人地址");
        }
        //收货地址和运费
        orderInfo.setConsignee(loginUser.getUsername());
        orderInfo.setMobile(loginUser.getMobile());
        orderInfo.setCountry("");
        //根据 前端的选择方式 1 是柜取 0 是 邮寄
        if (status == 0) {
            //省
//            String cmbProvince = (String) mapAddr.get("cmbProvince");
//            //市
//            String cmbCity = (String) mapAddr.get("cmbCity");
//            //区
//            String cmbArea = (String) mapAddr.get("cmbArea");
//            //详细地址
//            String addrUser = (String) mapAddr.get("addrUser");
//            orderInfo.setProvince(cmbProvince);
//            orderInfo.setCity(cmbCity);
//            orderInfo.setDistrict(cmbArea);
//            orderInfo.setAddress(addrUser);
            orderInfo.setProvince(addressEntity.getProvinceName());
            orderInfo.setCity(addressEntity.getCityName());
            orderInfo.setDistrict(addressEntity.getCountyName());
            orderInfo.setAddress(addressEntity.getDetailInfo());
        } else {
            orderInfo.setProvince(addressEntity.getProvinceName());
            orderInfo.setCity(addressEntity.getCityName());
            orderInfo.setDistrict(addressEntity.getCountyName());
            orderInfo.setAddress(addressEntity.getDetailInfo());
        }
        orderInfo.setAddress_id(1L);
        orderInfo.setDelivery_date(new Date());
        orderInfo.setDelivery_remark("无");
        orderInfo.setStore_id(storeId);
        orderInfo.setFreight_price(freightPrice.intValue());

        orderInfo.setCoupon_id(Integer.parseInt(String.valueOf(0L)));
        orderInfo.setCoupon_price(couponPrice);
        orderInfo.setCoupon_name("无");
        orderInfo.setActivity_id(0L);

        //使用的促销费用
        orderInfo.setFull_cut_price(fullCutCouponDec);
        orderInfo.setCampMinusId(0);
        orderInfo.setCampName("");

        //留言
        orderInfo.setPostscript("无");
        orderInfo.setAdd_time(new Date());
        orderInfo.setGoods_price(actualPrice.subtract(totalTax));
        orderInfo.setOrder_price(actualPrice);
        orderInfo.setActual_price(actualPrice); // 实际支付金额
        orderInfo.setOrder_type("1");
        orderInfo.setOrder_status(0);
        orderInfo.setShipping_status(0);
        orderInfo.setPay_status(0);
        orderInfo.setShipping_id(0L);
        orderInfo.setShipping_fee(Constant.ZERO);
        orderInfo.setIntegral(0);
        orderInfo.setIntegral_money(Constant.ZERO);
        orderInfo.setCreateTime(new Date());
        orderInfo.setModTime(new Date());
        orderInfo.setPayMobile(loginUser.getMobile());
//        orderInfo.setPayTransactionId(orderInfo.getOrder_sn());
        orderInfo.setIsScan("0");//默认未扫描

        orderInfo.setPayMobile(loginUser.getMobile());
        orderInfo.setPay_name(loginUser.getUsername());
        orderInfo.setIsOnfflineOrder(Dict.isOnfflineOrder.item_1.getItem());
        orderInfo.setOrderBizType(Dict.orderBizType.item_10.getItem());

        // 添加快递信息

        try {
            StoreExprActiveDto activeExpr = addressInfoService.queryByStoreId(storeId);
            if (activeExpr == null) {
                throw new RRException("门店未配置快递信息");
            }

            orderInfo.setShipping_id(activeExpr.getExprId());
            orderInfo.setShipping_code(activeExpr.getExprCode());
            orderInfo.setShipping_name(activeExpr.getExprName());
        } catch (Exception e) {
            LOGGER.error("订单写入门店快递配置信息有误：", e);
        }
        return orderInfo;
    }

    public OrderGoodsVo setOrderGoodsVo(OrderVo orderInfo, GoodsEntity goodsDto) {
        OrderGoodsVo orderGoodsVo = new OrderGoodsVo();
        orderGoodsVo.setOrder_id(orderInfo.getId());
        orderGoodsVo.setGoods_id(goodsDto.getId());
        orderGoodsVo.setGoods_sn(goodsDto.getGoodsSn());
        orderGoodsVo.setProduct_id(Long.valueOf(goodsDto.getProductId()));
        orderGoodsVo.setGoods_name(goodsDto.getName());
        orderGoodsVo.setList_pic_url(goodsDto.getListPicUrl());
        orderGoodsVo.setMarket_price(goodsDto.getStoreRetailPrice());
        orderGoodsVo.setRetail_price(goodsDto.getStoreRetailPrice());
        orderGoodsVo.setOrderSn(orderInfo.getOrder_sn());
        orderGoodsVo.setBarcode(goodsDto.getProdBarcode());

        orderGoodsVo.setDiscountedPrice(goodsDto.getDiscountedPrice());
        orderGoodsVo.setActualPaymentAmount(goodsDto.getActualPaymentAmount());
        orderGoodsVo.setDeductionScore(goodsDto.getDeductionScore());
        orderGoodsVo.setDeductionPrice(goodsDto.getDeductionPrice());

        orderGoodsVo.setNumber(goodsDto.getSellVolume());
//        orderGoodsVo.setGoods_specification_name_value(goodsDto.get);
//        orderGoodsVo.setGoods_specification_ids(goodsItem.getGoods_specification_ids());
        orderGoodsVo.setOrderBizType(Dict.orderBizType.item_10.getItem());
        orderGoodsVo.setCreateTime(new Date());
        orderGoodsVo.setModTime(new Date());
        orderGoodsVo.setActivity(goodsDto.getActivity());

        orderGoodsVo.setGoodsRate(goodsDto.getGoodsRate());
        orderGoodsVo.setSku(goodsDto.getSku());

        orderGoodsVo.setWarehouseSn(goodsDto.getWarehouseSn());
        orderGoodsVo.setConsignorSn(goodsDto.getConsignorSn());
        orderGoodsVo.setWarehouseSysGoodId(goodsDto.getWarehousSysGoodId());
        orderGoodsVo.setInventoryType(goodsDto.getInventoryType());
        orderGoodsVo.setDefectiveProductsGrade(goodsDto.getDefectiveProductsGrade());

        /*BigDecimal number = new BigDecimal(Long.valueOf(goodsDto.getSellVolume()));
        BigDecimal goodsTotal = goodsDto.getRetailPrice().multiply(number);//单商品总价
        BigDecimal rate = goodsTotal.divide(orderInfo.getGoods_price(), 2, BigDecimal.ROUND_HALF_UP);//当前商品总价/订单总价（不含运费、不含优惠券）
        BigDecimal freightPrice = BigDecimal.valueOf(orderInfo.getFreight_price());
        BigDecimal settlePrice = Constant.ZERO;  // ccnet 取的这个而价格
        if (orderInfo.getFreight_price() != 0 && !"0".equalsIgnoreCase(orderInfo.getCoupon_price() + "")) {
            //运费-优惠券
            BigDecimal rateTotal = freightPrice.subtract(orderInfo.getCoupon_price());
            //商品结算平摊价格（含优惠券、运费金额） = 单商品总价 + 当前商品总价/订单总价（不含运费、不含优惠券） * 运费与优惠券合计税率
            settlePrice = goodsTotal.add(rate.multiply(rateTotal));
        } else {
            if (orderInfo.getFreight_price() != 0) {
                //运费税率 = 单商品总价/订单总价（不含运费）* 运费金额
                BigDecimal freightRate = rate.multiply(freightPrice);
                //商品结算平摊价格（含运费金额） = 单商品总价+运费税率
                settlePrice = goodsTotal.add(freightRate);
            }
            if (!"0".equalsIgnoreCase(orderInfo.getCoupon_price() + "")) {
                //优惠券税率 = 单商品总价/订单总价（不含优惠券）* 优惠券金额
                BigDecimal couponRate = rate.multiply(orderInfo.getCoupon_price());
                //商品结算平摊价格（含优惠券金额） = 单商品总价-优惠券税率
                settlePrice = goodsTotal.subtract(couponRate);
            }
        }
        if (settlePrice.compareTo(BigDecimal.valueOf(0)) == 0) {
            orderGoodsVo.setSettlePrice(goodsTotal);//商品结算平摊价格
        } else {
            orderGoodsVo.setSettlePrice(settlePrice);//商品结算平摊价格
        }*/

        // 计算税费
        /*GoodsEntity goodsEntity = goodsService.queryObject(goodsDto.getId().intValue());
        BigDecimal goodsTax = CalculateTax.calculateFinalTax(goodsEntity, goodsDto.getStoreRetailPrice(), goodsService).setScale(3, RoundingMode.HALF_UP);
        goodsTax = goodsTax.multiply(number).setScale(2, RoundingMode.HALF_UP);*/
        orderGoodsVo.setTaxPrice(goodsDto.getGoodsTaxes());

        return orderGoodsVo;
    }


    /**
     * 支付单凭证回传更新 buyer_pay_check
     *
     * @param wxMap 更新数据
     * @return 结果
     */
    @Override
    public int updateBuyerPayCheck(Map<String, Object> wxMap) {
        return orderDao.updateBuyerPayCheck(wxMap);
    }

    /**
     * 支付单重推
     * @param orderSn
     * @return
     */
    @Override
    public R resendWayHkBill(String orderSn) throws Exception {

        OrderEntity orderEntity = orderDao.queryObjectByOrderSn(orderSn);
        if(null==orderEntity){
            return R.error("该订单不存在");
        }
        StoreEntity store = storeService.queryObject(orderEntity.getStoreId().intValue());
        if(null==store){
            return R.error("该订单所属门店不存在:"+orderEntity.getOrderSn());
        }
        MerchEntity merchEntity = merchDao.findByMerchSn(orderEntity.getMerchSn());
        if(null==merchEntity){
            return R.error("该订单所属商户不存在:"+orderEntity.getOrderSn());
        }
        // 组装支付单信息
        Map<String, Object> orderSendCusParams = new HashMap<>();
        if(Dict.payFlag.item_weixin.getItem().equals(orderEntity.getPayFlag())){
            orderSendCusParams.put("merchSn", orderEntity.getMerchSn());
            orderSendCusParams.put("orderSn", orderEntity.getOrderSn());
            orderSendCusParams.put("merchName", merchEntity.getMerchName());
            orderSendCusParams.put("thirdPartyMerchCode", store.getThirdPartyMerchCode());
            orderSendCusParams.put("thirdPartyMerchName", store.getThirdPartyMerchName());
            orderSendCusParams.put("outTradeNo", orderEntity.getMerchOrderSn());
            //微信支付流水号
            orderSendCusParams.put("transactionId", orderEntity.getPayTransactionId());
            orderSendCusParams.put("subOrderId", "");   // ccnet原逻辑没有对该字段赋值
            orderSendCusParams.put("subOrderNo", orderEntity.getOrderSn());
            orderSendCusParams.put("feeType", "CNY");
            int orderFee = orderEntity.getActualPrice().multiply(new BigDecimal(100)).intValue();
            orderSendCusParams.put("orderFee", orderFee);
            orderSendCusParams.put("productFee", orderFee);
            orderSendCusParams.put("transportFee", 0);
            UserEntity userEntity = userService.queryByMobile(orderEntity.getMobile());
            orderSendCusParams.put("certId", userEntity.getIdNo());
            orderSendCusParams.put("name", orderEntity.getPayName());

            // 将支付单信息发送到当前项目下的 cuspay
            wxCusDeclareBiz.biz(orderSendCusParams);
        }else {
            // 组装支付单信息
            orderSendCusParams.put("merchSn", orderEntity.getMerchSn());
            orderSendCusParams.put("orderSn", orderEntity.getOrderSn());
            orderSendCusParams.put("merchName", merchEntity.getMerchName());
            orderSendCusParams.put("thirdPartyMerchCode", store.getThirdPartyMerchCode());
            orderSendCusParams.put("thirdPartyMerchName", store.getThirdPartyMerchName());
            //阿里支付流水号
            orderSendCusParams.put("tradeNo", orderEntity.getAliTradeNo());
            orderSendCusParams.put("amount", orderEntity.getActualPrice());

            // 将支付单信息发送到当前项目下的 cuspay
            aliCusDeclareBiz.biz(orderSendCusParams);
        }
        return R.ok();
    }

    /**
     *
     * 重推退款积分，最多五次
     */
    @Override
    public void integralTask() {
        //获取重推积分数据
        List<HaiKongResendMsgEntity> haiKongResendMsgEntities = haiKongResendMsgDao.queryResendMsg();
        try {
            if(haiKongResendMsgEntities.size()>0){
                for(HaiKongResendMsgEntity haiKongResendMsg:haiKongResendMsgEntities) {
                    Date date = new Date();
                    String integralGoBackEntityMsg = haiKongResendMsg.getRequestMsg();
                    String responseMsg = haiKongMemberTemplate.rollbackMemberScore(integralGoBackEntityMsg);
                    Map<String, Object> res = JSON.parseObject(responseMsg, Map.class);
                    LOGGER.info("=======> [integralTask-----重推退款积分]" + responseMsg);

                    //解析数据
                    if ("true".equals(res.get("success").toString())) {
                        LOGGER.info("=======> [integralTask-----重推退款积分]" + responseMsg);
                    } else {
                        LOGGER.error("=======> [integralTask-----重推退款积分]" + responseMsg);
                        HaiKongResendMsgEntity haiKongResendMsgEntity = new HaiKongResendMsgEntity();
                        haiKongResendMsgEntity.setResponseMsg(responseMsg);
                        haiKongResendMsgEntity.setResendNum(haiKongResendMsg.getResendNum()+1);
                        haiKongResendMsgEntity.setResendTime(date);
                        haiKongResendMsgEntity.setId(haiKongResendMsg.getId());
                        haiKongResendMsgDao.updateResendMsg(haiKongResendMsgEntity);
                    }

                }
            }

        } catch (Exception e) {
            e.printStackTrace();
            LOGGER.info("重推退款积分-----integralTask",e);
        }

    }
}