caimei365-hehe/src/main/java/com/caimei/service/impl/OrderServiceImpl.java

package com.caimei.service.impl;

import com.alibaba.fastjson.JSONArray;
import com.caimei.mapper.CollageMapper;
import com.caimei.mapper.CouponMapper;
import com.caimei.mapper.OrderMapper;
import com.caimei.mapper.ProductMapper;
import com.caimei.model.ResponseJson;
import com.caimei.model.po.CmPayShopRecordPo;
import com.caimei.model.po.CouponSharePo;
import com.caimei.model.po.ReceiveCouponPo;
import com.caimei.model.po.UserSearchHistoryPo;
import com.caimei.model.vo.*;
import com.caimei.service.OrderService;
import com.caimei.service.ShoppingCartService;
import com.caimei.util.MathUtil;
import com.caimei.util.ProductUtils;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * Description
 *
 * @author : plf
 * @date : 2021/3/26
 */
@Slf4j
@Service
public class OrderServiceImpl implements OrderService {
    @Resource
    private OrderMapper orderMapper;
    @Resource
    private CollageMapper collageMapper;
    @Resource
    private ProductMapper productMapper;
    @Resource
    private CouponMapper couponMapper;
    @Value("${caimei.oldapi}")
    private String domain;

    @Override
    public ResponseJson<PageInfo<OrderVo>> getOrderList(Integer orderState, Integer userId, Integer pageNum, Integer pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<OrderVo> orderList = orderMapper.findOrderList(userId, orderState);
        getOrderData(orderList);
        PageInfo<OrderVo> pageData = new PageInfo<>(orderList);
        return ResponseJson.success(pageData);
    }

    /**
     * 主订单下信息
     */
    private void getOrderData(List<OrderVo> orderList) {
        for (OrderVo order : orderList) {
            initOrder(order);

        }
    }

    @Override
    public ResponseJson<Map<String, Object>> getOrderDetail(Integer orderId) {
        Map<String, Object> map = new HashMap<>(6);
        //收货地址
        UserInfoVo userInfo = orderMapper.findUserInfo(orderId);
        //订单信息,运费
        OrderVo order = orderMapper.findOrder(orderId);
        if (order == null) {
            return ResponseJson.error("该订单已删除", null);
        }
        initOrder(order);
        map.put("order", order);
        map.put("userInfo", userInfo);
        map.put("shopOrderList", order.getShopOrderList());
        map.put("discernReceiptList", order.getDiscernReceiptVoList());
        if (order.getFlag()) {
            map.put("returnGoodsStutas", 2);
            map.put("helpContent", order.getHelpContent());
        } else {
            map.put("returnGoodsStutas", 1);
            map.put("helpContent", null);
        }
        return ResponseJson.success(map);
    }

    private void setOrderStatus(OrderVo order) {
        Integer orderId = order.getOrderId();
        //111,待付待收待发
        if ("11".equals(order.getStatus()) && "1".equals(order.getPayStatus())) {
            order.setStatus("111");
        }
        //判断交易全退情况下,是否发过货,77,交易全退可以查看物流
        List<LogisticsBatchVo> batchList = orderMapper.findLogistics(orderId);
        if ("7".equals(order.getStatus()) && batchList != null && batchList.size() > 0) {
            order.setStatus("77");
        }
        //部分付款/已付款订单，设置拼团状态
        if ((order.getStatus().startsWith("2") || order.getStatus().startsWith("3")) && null != order.getCollageStatus()) {
            if (1 == order.getCollageStatus()) {
                // 拼团中
                order.setStatus("81");
            } else if (2 == order.getCollageStatus()) {
                if (order.getStatus().endsWith("1") || order.getStatus().endsWith("2")) {
                    // 拼团成功，待发货
                    order.setStatus("82");
                } else if (order.getStatus().endsWith("3")) {
                    // 拼团成功，已发货
                    order.setStatus("83");
                }
            } else if (0 == order.getCollageStatus() && new Date().compareTo(order.getCollageEndTime()) > 0) {
                // 拼团结束，关闭订单
                order.setStatus("6");
            }
        }
    }

    @Override
    public ResponseJson<List<LogisticsBatchVo>> logistics(Integer orderId) {
        OrderVo order = orderMapper.findOrder(orderId);
        if (order == null) {
            return ResponseJson.error("订单已删除", null);
        }
        List<LogisticsBatchVo> batchList = orderMapper.findLogistics(orderId);
        for (LogisticsBatchVo batch : batchList) {
            List<ShopOrderVo> shopOrderList = orderMapper.findAllShopOrder(orderId);
            for (ShopOrderVo shopOrder : shopOrderList) {
                initShopOrder(shopOrder);
                List<LogisticsRecordVo> logisticsRecordList = orderMapper.findLogisticsRecord(shopOrder.getShopOrderId(), batch.getId());
                for (LogisticsRecordVo logisticsRecord : logisticsRecordList) {
                    logisticsRecord.setImage(ProductUtils.getImageURL("product", logisticsRecord.getImage(), 0, domain));
                }
                shopOrder.setLogisticsRecordList(logisticsRecordList);
                shopOrder.setShopLogo(ProductUtils.getImageURL("shopLogo", shopOrder.getShopLogo(), 0, domain));
            }
            //物流信息
            List<LogisticsInformationVo> logisticsInfoList = orderMapper.findLogisticsInfo(batch.getId());
            for (LogisticsInformationVo logisticsInfo : logisticsInfoList) {
                List<RouterVo> routers = JSONArray.parseArray(logisticsInfo.getInfo(), RouterVo.class);
                logisticsInfo.setRouterList(routers);
            }
            batch.setLogisticsInformationList(logisticsInfoList);
            batch.setShopOrderList(shopOrderList);
        }
        return ResponseJson.success(batchList);
    }

    @Override
    public ResponseJson<String> affirmCargo(Integer orderId) {
        OrderVo order = orderMapper.findOrder(orderId);
        if (order == null) {
            return ResponseJson.error("订单不存在", null);
        }
        if ("33".equals(order.getStatus()) && "3".equals(order.getPayStatus())) {
            //已付款供应商,订单完成
            order.setStatus("5");
            orderMapper.updateOrderStatus(order);
            orderMapper.updateLogisticsBatch(orderId);
        } else if ("33".equals(order.getStatus())) {
            //交易完成
            order.setStatus("4");
            orderMapper.updateOrderStatus(order);
            orderMapper.updateLogisticsBatch(orderId);
        } else {
            return ResponseJson.error("订单异常", null);
        }
        return ResponseJson.success("");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseJson<String> deleteOrder(Integer orderId) {
        OrderVo order = orderMapper.findOrder(orderId);
        if (order == null) {
            return ResponseJson.error("订单不存在", null);
        }
        if (!("6".equals(order.getStatus()))) {
            return ResponseJson.error("订单异常", null);
        }
        orderMapper.deleteOrder(orderId);
        //逻辑删除子订单
        orderMapper.deleteShopOrder(orderId);
        //逻辑删除收款记录
        List<DiscernReceiptVo> discernReceipt = orderMapper.findDiscernReceipt(orderId);
        if (discernReceipt != null && discernReceipt.size() > 0) {
            orderMapper.deleteReceiptOrderRelation(orderId);
            for (DiscernReceiptVo receipt : discernReceipt) {
                orderMapper.deleteDiscernReceipt(receipt.getId());
            }
        }
        String[] shopOrderIds = order.getShopOrderIds().split(",");
        //逻辑删除付款记录
        for (String shopOrderId : shopOrderIds) {
            if (StringUtils.isNotBlank(shopOrderId)) {
                List<CmPayShopRecordPo> payShopRecordList = orderMapper.findPayShopRecord(Integer.valueOf(shopOrderId));
                if (payShopRecordList != null && payShopRecordList.size() > 0) {
                    orderMapper.deletePayShopRecord(Integer.valueOf(shopOrderId));
                    for (CmPayShopRecordPo payShopRecord : payShopRecordList) {
                        orderMapper.updatePayShop(payShopRecord.getPayShopID());
                    }
                }
            }
        }
        return ResponseJson.success(null);
    }

    @Override
    public ResponseJson<String> cancelOrder(Integer orderId) {
        OrderVo order = orderMapper.findOrder(orderId);
        if (order == null) {
            return ResponseJson.error("订单不存在", null);
        }
        if (!("11".equals(order.getStatus()) || "0".equals(order.getStatus()))) {
            return ResponseJson.error("订单异常", null);
        }
        order.setStatus("6");
        orderMapper.cancelOrder(orderId,"用户主动取消订单");
        orderMapper.cancelShopOrder(orderId,"用户主动取消订单");
        Integer receiveCouponId = orderMapper.findOrderCoupon(orderId);
        ReceiveCouponPo receiveCoupon = couponMapper.getReceiveCouponById(receiveCouponId);
        if (null != receiveCoupon) {
            if (1 == receiveCoupon.getSource() || 2 == receiveCoupon.getSource()) {
                // 取消订单回退优惠券
                orderMapper.revertCoupon(receiveCouponId);
            }
            if (3 == receiveCoupon.getSource()) {
                // 领券购买取消订单撤销领取
                couponMapper.deleteReceiveCoupon(receiveCouponId);
            }
        }
        return ResponseJson.success(null);
    }

    @Override
    public ResponseJson<PageInfo<OrderVo>> searchOrder(String searchWord, Integer userId, Integer pageNum, Integer pageSize) {
        //保存订单搜索记录
        saveHistory(searchWord, userId);
        PageHelper.startPage(pageNum, pageSize);
        List<OrderVo> orderList = orderMapper.searchOrder(searchWord, userId);

        //获取主订单数据
        getOrderData(orderList);

        PageInfo<OrderVo> pageData = new PageInfo<>(orderList);
        return ResponseJson.success(pageData);
    }

    /**
     * 保存订单搜索记录
     */
    private void saveHistory(String searchWord, Integer userId) {
        //保存并删除大于10条的历史记录
        UserSearchHistoryPo historyRecord = new UserSearchHistoryPo();
        historyRecord.setUserId(userId.longValue());
        historyRecord.setSearchDate(new Date());
        historyRecord.setSearchWord(searchWord);
        historyRecord.setDelFlag("0");
        Long recordId = orderMapper.getHistoryIdByWord(userId, searchWord);
        if (recordId != null && recordId > 0L) {
            historyRecord.setId(recordId);
            orderMapper.updateHistoryById(historyRecord);
        } else {
            orderMapper.insertHistory(historyRecord);
        }
        orderMapper.deleteHistoryByUserId(userId);
    }

    @Override
    public ResponseJson<List<String>> getSearchHistory(Integer userId) {
        List<String> searchHistoryList = orderMapper.getSearchHistoryList(userId);
        return ResponseJson.success(searchHistoryList);
    }

    @Override
    public ResponseJson<String> deleteSearchHistory(Integer userId) {
        orderMapper.deleteSearchHistory(userId);
        return ResponseJson.success(null);
    }

    @Override
    public ResponseJson<Map<String, Object>> orderTotal(Integer userId) {
        Map<String, Object> map = new HashMap<>(5);
        //待付款数量
        Integer paymentCount = orderMapper.findOrderCount(userId, 1);
        paymentCount = paymentCount == null ? 0 : paymentCount;
        map.put("paymentCount", paymentCount);
        //待发货数量
        Integer waitShipmentsCount = orderMapper.findOrderCount(userId, 2);
        waitShipmentsCount = waitShipmentsCount == null ? 0 : waitShipmentsCount;
        map.put("waitShipmentsCount", waitShipmentsCount);
        //已发货数量
        Integer shipmentsCount = orderMapper.findOrderCount(userId, 3);
        shipmentsCount = shipmentsCount == null ? 0 : shipmentsCount;
        map.put("shipmentsCount", shipmentsCount);
        //退货款数量
        Integer salesReturnCount = orderMapper.findOrderCount(userId, 4);
        salesReturnCount = salesReturnCount == null ? 0 : salesReturnCount;
        map.put("salesReturnCount", salesReturnCount);
        return ResponseJson.success(map);
    }

    @Override
    public ResponseJson<PageInfo<OrderVo>> dealerOrderList(Integer orderState, Integer orderType, Integer userId, String searchWord, Integer pageNum, Integer pageSize) {
        //保存订单搜索记录
        if (StringUtils.isNotBlank(searchWord)) {
            saveHistory(searchWord, userId);
        }
        PageHelper.startPage(pageNum, pageSize);
        List<OrderVo> orderList = orderMapper.dealerOrderList(orderState, orderType, userId, searchWord);
        getOrderData(orderList);
        PageInfo<OrderVo> pageData = new PageInfo<>(orderList);
        return ResponseJson.success(pageData);
    }

    @Override
    public ResponseJson<List<OrderProductVo>> buyAgain(Integer orderId) {
        List<OrderProductVo> orderProductList = orderMapper.findOrderProductAll(orderId);
        List<OrderProductVo> list = new ArrayList<>();
        //商品是否全部下架
        AtomicBoolean isOff = new AtomicBoolean(true);
        orderProductList.forEach(orderProduct -> {
            orderProduct.setProductImage(ProductUtils.getImageURL("product", orderProduct.getProductImage(), 0, domain));
            Integer validFlag = orderMapper.findProductStatus(orderProduct.getProductId());
            if (validFlag == 2) {
                list.add(orderProduct);
            } else {
                isOff.set(false);
            }
        });
        if (isOff.get()) {
            return ResponseJson.error("订单内商品已全部下架,不能购买!", null);
        }
        if (list.size() > 0) {
            return ResponseJson.error(list);
        }
        return ResponseJson.success(null);
    }

    @Override
    public ResponseJson<CollageDetailsVo> collageDetails(Integer collageId, Integer userId) {
        CollageDetailsVo collageDetails = collageMapper.getCollageDetails(collageId);
        if (2 == collageDetails.getStatus()) {
            collageDetails.setExistNum(collageDetails.getMemberNum());
        }
        ProductDetailsVo product = productMapper.findProductByProductId(collageDetails.getSkuId());
        // 拼团价
        product.setPrice(collageDetails.getPrice());
        collageDetails.setUnit(product.getUnit());
        if (null != userId && userId > 0) {
            Integer orderId = collageMapper.getMemberOrderId(collageId, userId);
            collageDetails.setOrderId(orderId);
            //税费
            boolean addTaxFlag = ("0".equals(product.getIncludedTax()) && ("1".equals(product.getInvoiceType()) || "2".equals(product.getInvoiceType())));
            if (addTaxFlag) {
                BigDecimal addedValueTax = MathUtil.div(MathUtil.mul(product.getPrice(), product.getClubTaxPoint()), BigDecimal.valueOf(100), 2);
                BigDecimal price = MathUtil.add(product.getPrice(), addedValueTax);
                product.setPrice(price);
                if (null != product.getNormalPrice()) {
                    addedValueTax = MathUtil.div(MathUtil.mul(product.getNormalPrice(), product.getClubTaxPoint()), BigDecimal.valueOf(100), 2);
                    price = MathUtil.add(product.getNormalPrice(), addedValueTax);
                    product.setNormalPrice(price);
                }
            }
            collageDetails.setPrice(product.getPrice());
            collageDetails.setNormalPrice(product.getNormalPrice());
            // 查询该订单是否已有分享记录
            Integer shareRecordCount = couponMapper.getShareRecordCount(orderId);
            if (0 == shareRecordCount) {
                collageDetails.setShareFlag(1);
            }
        }
        return ResponseJson.success(collageDetails);
    }

    @Override
    public ResponseJson shareOrder(Integer orderId, Integer userId) {
        // 查询该订单是否已有分享记录
        Integer shareRecordCount = couponMapper.getShareRecordCount(orderId);
        if (0 == shareRecordCount) {
            // 只能获得一次优惠券领取资格
            List<Integer> couponIds = couponMapper.getCurrentCouponIds(6);
            CouponSharePo couponSharePo = new CouponSharePo();
            couponSharePo.setShareUserId(userId);
            couponSharePo.setOrderId(orderId);
            couponSharePo.setType(3);
            couponIds.forEach(couponId->{
                couponSharePo.setShareCouponId(couponId);
                couponMapper.insertCouponShare(couponSharePo);
            });
        }
        return ResponseJson.success("分享成功");
    }

    /**
     * 支付金额,待付金额
     */
    public List<DiscernReceiptVo> getDiscernReceipt(OrderVo order) {
        //支付记录
        List<DiscernReceiptVo> discernReceiptList = orderMapper.findDiscernReceipt(order.getOrderId());
        BigDecimal receiptAmount = BigDecimal.ZERO;
        //订单款
        if (discernReceiptList != null && discernReceiptList.size() > 0) {
            for (DiscernReceiptVo discernReceipt : discernReceiptList) {
                receiptAmount = receiptAmount.add(discernReceipt.getAssociateAmount());
            }
            order.setReceiptDate(discernReceiptList.get(0).getReceiptDate());
        }
        //待付总金额
        order.setPendingPayments(MathUtil.sub(order.getPayableAmount(), receiptAmount));
        //支付总金额
        order.setReceiptAmount(receiptAmount);
        return discernReceiptList;
    }

    public void initShopOrder(ShopOrderVo shopOrder) {
        if (1 == shopOrder.getShopStatus()) {
            if ("1".equals(shopOrder.getReceiptStatus()) && "1".equals(shopOrder.getSendOutStatus())) {
                shopOrder.setShopStatus(11);
            } else if ("1".equals(shopOrder.getReceiptStatus()) && "2".equals(shopOrder.getSendOutStatus())) {
                shopOrder.setShopStatus(12);
            } else if ("1".equals(shopOrder.getReceiptStatus()) && "3".equals(shopOrder.getSendOutStatus())) {
                shopOrder.setShopStatus(13);
            } else if ("2".equals(shopOrder.getReceiptStatus()) && "1".equals(shopOrder.getSendOutStatus())) {
                shopOrder.setShopStatus(21);
            } else if ("2".equals(shopOrder.getReceiptStatus()) && "2".equals(shopOrder.getSendOutStatus())) {
                shopOrder.setShopStatus(22);
            } else if ("2".equals(shopOrder.getReceiptStatus()) && "3".equals(shopOrder.getSendOutStatus())) {
                shopOrder.setShopStatus(23);
            } else if ("3".equals(shopOrder.getReceiptStatus()) && "1".equals(shopOrder.getSendOutStatus())) {
                shopOrder.setShopStatus(31);
            } else if ("3".equals(shopOrder.getReceiptStatus()) && "2".equals(shopOrder.getSendOutStatus())) {
                shopOrder.setShopStatus(32);
            } else if ("3".equals(shopOrder.getReceiptStatus()) && "3".equals(shopOrder.getSendOutStatus())) {
                shopOrder.setShopStatus(33);
            }
        }
        //拼接运费
        Double ColdChina = Double.valueOf(700);
        String shopPostFlag = shopOrder.getShopPostFlag() != null ? shopOrder.getShopPostFlag() : "-2";
        String postageInfo = null;
        if (null != shopOrder.getIsColdChina() && shopOrder.getIsColdChina() == 1) {
            if ("2" == shopOrder.getShopPostFlag()) {
                // 到付
                postageInfo = "￥" + ColdChina + "(" + (shopOrder.getIsColdChina() == 1 ? "冷链费: ￥" + ColdChina + "," : "") + "其他: 到付)";
            } else if ("0" == shopOrder.getShopPostFlag()) {
                // 包邮
                postageInfo = "￥" + ColdChina + "(" + (shopOrder.getIsColdChina() == 1 ? "冷链费: ￥" + ColdChina + "," : "") + "其他: 包邮)";
            } else {
                // 有运费
                postageInfo = "￥" + MathUtil.add(shopOrder.getShopPostFee(), ColdChina) + "(" + (shopOrder.getIsColdChina() == 1 ? "冷链费: ￥" + ColdChina + "," : "") + "其他: ￥" + shopOrder.getShopPostFee() + ")";
            }
        } else {
            postageInfo = shopPostFlag.equals("2") ? "到付" : shopPostFlag.equals("0") ? "包邮" : "￥" + shopOrder.getShopPostFee();
        }
        shopOrder.setPostageInfo(postageInfo);
    }

    public void initOrder(OrderVo order) {
        order.setOrderMark("#" + order.getOrderId() + "#");
        setOrderStatus(order);
        //商品信息
        List<ShopOrderVo> shopOrderList = orderMapper.findAllShopOrder(order.getOrderId());
        BigDecimal expensesOfTaxation = new BigDecimal(0);
        int returnedNumTotal = 0;
        int actualCancelNumTotal = 0;
        String helpContent = null;
        boolean flag = false;
        //bug
        order.setPayTotalFee(new BigDecimal(0));
        order.setPayableAmount(new BigDecimal(0));
        order.setPendingPayments(new BigDecimal(0));
        for (ShopOrderVo shopOrder : shopOrderList) {
            order.setPayTotalFee(MathUtil.add(order.getPayTotalFee(),shopOrder.getTotalAmount()));
            order.setPayableAmount(MathUtil.add(order.getPayableAmount(),shopOrder.getRealPay()));
            order.setPendingPayments(MathUtil.add(order.getPendingPayments(),shopOrder.getRestAmount()));

            if ("81".equals(order.getStatus())) {
                shopOrder.setShopStatus(81);
            } else if ("82".equals(order.getStatus())) {
                shopOrder.setShopStatus(82);
            } else if ("83".equals(order.getStatus())) {
                shopOrder.setShopStatus(83);
            } else if ("6".equals(order.getStatus())) {
                shopOrder.setShopStatus(4);
            }
            initShopOrder(shopOrder);
            List<OrderProductVo> orderProductList = orderMapper.findOrderProduct(shopOrder.getShopOrderId());
            for (OrderProductVo orderProduct : orderProductList) {
                //订单中存在不能退货的商品则给出不能退货提示
                if (null != orderProduct.getReturnGoodsStutas() && orderProduct.getReturnGoodsStutas() == 2) {
                    flag = true;
                    helpContent = orderMapper.getHelpContent(1040);
                }
                //运费
                if (shopOrder.getShopId() == 998) {
                    order.setFreight(orderProduct.getPrice());
                }
                //总税费
                expensesOfTaxation = expensesOfTaxation.add(orderProduct.getTotalAddedValueTax());
                orderProduct.setProductImage(ProductUtils.getImageURL("product", orderProduct.getProductImage(), 0, domain));
                //已发货数量
                orderProduct.setShipmentsNum(orderProduct.getNum() + orderProduct.getPresentNum() - orderProduct.getNotOutStore());
                //已退货数量
                Integer returnedNum = orderMapper.returnedPurchase(orderProduct.getShopOrderId(), orderProduct.getProductId());
                returnedNum = null != returnedNum ? returnedNum : 0;
                returnedNumTotal += returnedNum;
                orderProduct.setReturnedNum(returnedNum);
                //已取消发货数量
                Integer actualCancelNum = orderMapper.actualCancelNum(orderProduct.getShopOrderId(), orderProduct.getProductId());
                actualCancelNum = null != actualCancelNum ? actualCancelNum : 0;
                actualCancelNumTotal += actualCancelNum;
                orderProduct.setActualCancelNum(actualCancelNum);
                //判断商品价格是否含税
                if ("1".equals(orderProduct.getIncludedTax()) || ("0".equals(orderProduct.getIncludedTax()) && ("1".equals(orderProduct.getInvoiceType()) || "2".equals(orderProduct.getInvoiceType())))) {
                    orderProduct.setIncludedTaxFlag("2");
                } else if (orderProduct.getIncludedTax() != null && "0".equals(orderProduct.getIncludedTax()) && "3".equals(orderProduct.getInvoiceType())) {
                    orderProduct.setIncludedTaxFlag("1");
                } else {
                    orderProduct.setIncludedTaxFlag("3");
                }
                //不含税可开票商品,单价/折后单价在原基础上加上税费
                if ("0".equals(orderProduct.getIncludedTax()) && ("1".equals(orderProduct.getInvoiceType()) || "2".equals(orderProduct.getInvoiceType()))) {
                    //计算单价的税费
                    BigDecimal valueTax = MathUtil.div(MathUtil.mul(orderProduct.getPrice(), orderProduct.getTaxRate()), 100);
                    orderProduct.setPrice(MathUtil.add(orderProduct.getPrice(), valueTax));
                    orderProduct.setDiscountPrice(MathUtil.add(orderProduct.getDiscountPrice(), orderProduct.getAddedValueTax()));
                }
            }
            shopOrder.setOrderProductList(orderProductList);
            shopOrder.setShopLogo(ProductUtils.getImageURL("shopLogo", shopOrder.getShopLogo(), 0, domain));
        }
        order.setExpensesOfTaxation(expensesOfTaxation);
        order.setReturnedNum(returnedNumTotal);
        order.setActualCancelNum(actualCancelNumTotal);

        order.setFlag(flag);
        order.setHelpContent(helpContent);

        // 查询该订单是否已有分享记录
        Integer shareRecordCount = couponMapper.getShareRecordCount(order.getOrderId());
        if (0 == shareRecordCount) {
            order.setShareFlag(1);
        }
        //删除运费商品
        shopOrderList.removeIf(student -> 998 == student.getShopId());
        List<DiscernReceiptVo> discernReceiptList = getDiscernReceipt(order);
        //退款总金额
        BigDecimal returnedPurchaseFee = orderMapper.findReturnedPurchase(order.getOrderId());
        order.setReturnedPurchaseFee(returnedPurchaseFee);
        order.setShopOrderList(shopOrderList);
        order.setDiscernReceiptVoList(discernReceiptList);
    }
}