1109修改

101captain

2021-11-09 e7f03acfa5ee4ad4fd6d1ee9e9ae9a5655488f6d

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/service/impl/ComShopOrderServiceImpl.java

@@ -1,36 +1,36 @@
package com.panzhihua.service_community.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.panzhihua.common.model.dtos.PageDTO;
import com.panzhihua.common.model.dtos.shop.PageComShopOrderSearchDTO;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.service_community.dao.ComShopOrderDAO;
import com.panzhihua.service_community.model.dos.ComShopOrderDO;
import com.panzhihua.common.model.dtos.shop.ComShopOrderCreateDTO;
import com.panzhihua.common.model.dtos.shop.ComShopOrderCreateGoodsDTO;
import com.panzhihua.common.model.dtos.shop.ComShopOrderPreviewDTO;
import com.panzhihua.common.model.dtos.shop.PageComOrderListDTO;
import com.panzhihua.common.model.dtos.shop.*;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.shop.*;
import com.panzhihua.common.utlis.DateUtils;
import com.panzhihua.common.utlis.OrderNoUtils;
import com.panzhihua.common.utlis.StringUtils;
import com.panzhihua.common.utlis.WxPayUtils;
import com.panzhihua.service_community.dao.*;
import com.panzhihua.service_community.model.dos.*;
import com.panzhihua.service_community.service.ComShopOrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import lombok.extern.slf4j.Slf4j;

/**
 * @auther lyq
@@ -39,7 +39,8 @@
 */
@Slf4j
@Service
public class ComShopOrderServiceImpl extends ServiceImpl<ComShopOrderDAO, ComShopOrderDO> implements ComShopOrderService {
public class ComShopOrderServiceImpl extends ServiceImpl<ComShopOrderDAO, ComShopOrderDO>
    implements ComShopOrderService {

    @Resource
    private ComShopGoodsDAO comShopGoodsDAO;
@@ -55,42 +56,64 @@
    private ComShopOrderOperateDAO comShopOrderOperateDAO;
    @Resource
    private ComShopOrderGoodsDAO comShopOrderGoodsDAO;
    @Resource
    private ComShopOrderDAO comShopOrderDAO;
    @Resource
    private ComShopOrderPayDAO comShopOrderPayDAO;
    @Value("${min.app.isTest}")
    private Boolean isTest;
    @Value("${min.app.appid}")
    private String appid;
    @Value("${min.app.payKey}")
    private String payKey;
    @Value("${min.app.mchId}")
    private String mchId;
    @Value("${min.app.notifyUrl}")
    private String notifyUrl;

    public static void main(String[] args) {
        BigDecimal one = BigDecimal.valueOf(Double.valueOf("1") / 100);
        System.out.println();
    }

    /**
     * 订单预览
     * @param orderPreviewDTO   请求参数
     * @return  订单预览数据
     *
     * @param orderPreviewDTO
     *            请求参数
     * @return 订单预览数据
     */
    @Override
    public R orderPreview(ComShopOrderPreviewDTO orderPreviewDTO){
    public R orderPreview(ComShopOrderPreviewDTO orderPreviewDTO) {

        //返回参数
        // 返回参数
        ComShopOrderPreviewVO orderPreviewVO = new ComShopOrderPreviewVO();
        //返回商品列表
        // 返回商品列表
        List<ComShopOrderGoodsVO> orderGoodsList = new ArrayList<>();
        Long storeId = 0L;
        BigDecimal orderTotal = BigDecimal.ZERO;
        Integer orderGoodsTotal = 0;
        //判断提交方式
        if(orderPreviewDTO.getSubmitType().equals(ComShopOrderPreviewDTO.submitType.details)){//详情页提交
            //查询商品信息
            ComShopGoodsDO goodsDO = comShopGoodsDAO.selectOne(new QueryWrapper<ComShopGoodsDO>().eq("id",orderPreviewDTO.getGoodsId())
                    .eq("status",ComShopGoodsDO.status.sell).eq("delete_status",ComShopGoodsDO.deleteStatus.no));
            if(goodsDO == null){
        // 判断提交方式
        if (orderPreviewDTO.getSubmitType().equals(ComShopOrderPreviewDTO.submitType.details)) {// 详情页提交
            // 查询商品信息
            ComShopGoodsDO goodsDO =
                comShopGoodsDAO.selectOne(new QueryWrapper<ComShopGoodsDO>().eq("id", orderPreviewDTO.getGoodsId())
                    .eq("status", ComShopGoodsDO.status.sell).eq("delete_status", ComShopGoodsDO.deleteStatus.no));
            if (goodsDO == null) {
                return R.fail("商品已下架或已删除");
            }
            //设置店铺id
            // 设置店铺id
            storeId = goodsDO.getStoreId();

            //查询商品规格信息
            // 查询商品规格信息
            ComShopGoodsAttrDO goodsAttrDO = comShopGoodsAttrDAO.selectById(orderPreviewDTO.getGoodsAttrId());
            if(goodsAttrDO == null){
            if (goodsAttrDO == null) {
                return R.fail("商品规格不存在");
            }

            orderTotal = goodsAttrDO.getPrice().multiply(BigDecimal.valueOf(orderPreviewDTO.getBuyNum()));
            orderGoodsTotal = orderPreviewDTO.getBuyNum();
            //商品信息赋值
            // 商品信息赋值
            ComShopOrderGoodsVO orderGoodsVO = new ComShopOrderGoodsVO();
            orderGoodsVO.setGoodsName(goodsDO.getName());
            orderGoodsVO.setGoodsId(goodsDO.getId());
@@ -99,27 +122,27 @@
            orderGoodsVO.setPrice(goodsAttrDO.getPrice());
            orderGoodsVO.setNum(orderPreviewDTO.getBuyNum());
            orderGoodsList.add(orderGoodsVO);
        }else if(orderPreviewDTO.getSubmitType().equals(ComShopOrderPreviewDTO.submitType.cart)){//购物车提交
        } else if (orderPreviewDTO.getSubmitType().equals(ComShopOrderPreviewDTO.submitType.cart)) {// 购物车提交
            List<ComShopCartDO> cartList = comShopCartDAO.selectBatchIds(orderPreviewDTO.getCartIds());
            if(cartList.isEmpty()){
            if (cartList.isEmpty()) {
                return R.fail("未找到购物车商品信息");
            }
            //设置店铺id
            // 设置店铺id
            storeId = cartList.get(0).getStoreId();
            //循环遍历购物车商品信息
            for (ComShopCartDO cartDO:cartList) {
                //商品信息赋值
            // 循环遍历购物车商品信息
            for (ComShopCartDO cartDO : cartList) {
                // 商品信息赋值
                ComShopOrderGoodsVO orderGoodsVO = new ComShopOrderGoodsVO();
                orderGoodsVO.setGoodsId(cartDO.getGoodsId());
                orderGoodsVO.setGoodsAttrId(cartDO.getGoodsAttrId());
                orderGoodsVO.setGoodsPic(cartDO.getGoodsAttrPic());
                orderGoodsVO.setNum(cartDO.getAmount());
                orderGoodsVO.setGoodsName(cartDO.getGoodsName());
                //查询商品规格
                // 查询商品规格
                ComShopGoodsAttrDO goodsAttrDO = comShopGoodsAttrDAO.selectById(cartDO.getGoodsAttrId());
                if(goodsAttrDO != null){
                if (goodsAttrDO != null) {
                    orderGoodsVO.setPrice(goodsAttrDO.getPrice());
                }else{
                } else {
                    orderGoodsVO.setPrice(BigDecimal.ZERO);
                }
                orderTotal = orderTotal.add(orderGoodsVO.getPrice().multiply(BigDecimal.valueOf(cartDO.getAmount())));
@@ -131,27 +154,41 @@
        orderPreviewVO.setOrderGoodsTotal(orderGoodsTotal);
        orderPreviewVO.setOrderGoodsList(orderGoodsList);

        //查询店铺信息
        // 查询店铺信息
        ComShopStoreDO storeDO = comShopStoreDAO.selectById(storeId);
        if(storeDO != null){
        if (storeDO != null) {
            PageShopStoreVO shopStoreVO = new PageShopStoreVO();
            BeanUtils.copyProperties(storeDO,shopStoreVO);
            BeanUtils.copyProperties(storeDO, shopStoreVO);
            orderPreviewVO.setShopStoreVO(shopStoreVO);
        }

        //查询默认收货地址
        //查询上次购买记录的收货地址
        List<ComShopOrderDO> shopOrders = this.baseMapper.selectList(new QueryWrapper<ComShopOrderDO>()
                .eq("user_id",orderPreviewDTO.getUserId()).orderByDesc("create_at"));
        if(shopOrders.isEmpty()){//未查询到用户上一笔订单
            //查询用户收货地址中的默认地址
            ComShopUserAddressDO userAddressDO = comShopUserAddressDAO.selectOne(new QueryWrapper<ComShopUserAddressDO>()
                    .eq("user_id",orderPreviewDTO.getUserId()).eq("is_default",ComShopUserAddressDO.isDefault.yes));
            if(userAddressDO != null){
                ComShopUserAddressVO userAddressVO = new ComShopUserAddressVO();
                BeanUtils.copyProperties(userAddressDO,userAddressVO);
                orderPreviewVO.setUserAddressVO(userAddressVO);
            }else{
        // 查询默认收货地址
        ComShopUserAddressDO userDefaultAddressDO =
            comShopUserAddressDAO.selectOne(new QueryWrapper<ComShopUserAddressDO>().eq("delete_status", 2)
                .eq("user_id", orderPreviewDTO.getUserId()).eq("is_default", ComShopUserAddressDO.isDefault.yes));

        // 查询用户收货地址中的默认地址
        if (userDefaultAddressDO != null) {
            ComShopUserAddressVO userAddressVO = new ComShopUserAddressVO();
            BeanUtils.copyProperties(userDefaultAddressDO, userAddressVO);
            orderPreviewVO.setUserAddressVO(userAddressVO);
        } else {
            // 查询上次购买记录的收货地址
            // 查询到用户上一笔订单
            List<ComShopOrderDO> shopOrders = this.baseMapper.selectList(new QueryWrapper<ComShopOrderDO>()
                .eq("delete_status", 2).eq("user_id", orderPreviewDTO.getUserId()).orderByDesc("create_at"));
            if (shopOrders != null && shopOrders.size() > 0) {
                ComShopUserAddressDO userAddressDO =
                    comShopUserAddressDAO.selectById(shopOrders.get(0).getReceiverId());
                if (userAddressDO != null) {
                    ComShopUserAddressVO userAddressVO = new ComShopUserAddressVO();
                    BeanUtils.copyProperties(userAddressDO, userAddressVO);
                    orderPreviewVO.setUserAddressVO(userAddressVO);
                }
            }
            // 无默认地址， 无上一单记录 地址
            /*
            if(orderPreviewVO.getUserAddressVO()==null){
                List<ComShopUserAddressDO> userAddressDOList = comShopUserAddressDAO.selectList(new QueryWrapper<ComShopUserAddressDO>()
                        .eq("user_id",orderPreviewDTO.getUserId()).orderByDesc("create_at"));
                if(!userAddressDOList.isEmpty()){
@@ -160,11 +197,7 @@
                    orderPreviewVO.setUserAddressVO(userAddressVO);
                }
            }
        }else{//查询到用户上一笔订单
            ComShopUserAddressDO userAddressDO = comShopUserAddressDAO.selectById(shopOrders.get(0).getReceiverId());
            ComShopUserAddressVO userAddressVO = new ComShopUserAddressVO();
            BeanUtils.copyProperties(userAddressDO,userAddressVO);
            orderPreviewVO.setUserAddressVO(userAddressVO);
            */
        }

        return R.ok(orderPreviewVO);
@@ -172,41 +205,40 @@

    /**
     * 创建订单
     * @param orderCreateDTO    创建订单请求参数
     * @return  创建结果
     *
     * @param orderCreateDTO
     *            创建订单请求参数
     * @return 创建结果
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public R orderCreate(ComShopOrderCreateDTO orderCreateDTO){
        //创建返回参数
    public R orderCreate(ComShopOrderCreateDTO orderCreateDTO) {
        // 创建返回参数
        ComShopOrderVO shopOrderVO = new ComShopOrderVO();

        //查询用户收货地址
        // 查询用户收货地址
        ComShopUserAddressDO userAddressDO = comShopUserAddressDAO.selectById(orderCreateDTO.getReceiverId());
        if(userAddressDO == null){
        if (userAddressDO == null || userAddressDO.getDeleteStatus() != 2) {
            return R.fail("收货地址不存在");
        }
        //用户id
        // 用户id
        Long userId = orderCreateDTO.getUserId();
        //店铺id
        // 店铺id
        Long storeId = 0L;
        //生成订单号
        // 生成订单号
        String orderNo = OrderNoUtils.NextOrderNo(userId);
        //配送方式
        // 配送方式
        Integer deliveryType = 0;

        //订单总金额
        // 订单总金额
        BigDecimal orderTotal = BigDecimal.ZERO;

        //创建订单商品信息
        // 创建订单商品信息
        List<ComShopOrderGoodsDO> orderGoodsDOList = new ArrayList<>();
        if(!orderCreateDTO.getOrderGoodsList().isEmpty()){
            for (ComShopOrderCreateGoodsDTO createGoodsDTO:orderCreateDTO.getOrderGoodsList()) {
                //查询当前商品信息
                ComShopGoodsDO goodsDO = comShopGoodsDAO.selectOne(new QueryWrapper<ComShopGoodsDO>()
                        .eq("id",createGoodsDTO.getGoodsId()).eq("delete_status",ComShopGoodsDO.deleteStatus.no)
                        .eq("status",ComShopGoodsDO.status.sell));
                if(goodsDO == null){
        if (!orderCreateDTO.getOrderGoodsList().isEmpty()) {
            for (ComShopOrderCreateGoodsDTO createGoodsDTO : orderCreateDTO.getOrderGoodsList()) {
                // 查询当前商品信息
                ComShopGoodsDO goodsDO =
                    comShopGoodsDAO.selectOne(new QueryWrapper<ComShopGoodsDO>().eq("id", createGoodsDTO.getGoodsId())
                        .eq("delete_status", ComShopGoodsDO.deleteStatus.no).eq("status", ComShopGoodsDO.status.sell));
                if (goodsDO == null) {
                    log.error("未查询到商品信息,商品已下架活已删除,商品id" + createGoodsDTO.getGoodsId());
                    continue;
                }
@@ -219,27 +251,27 @@
                orderGoodsDO.setUserId(userId);
                orderGoodsDO.setAmount(createGoodsDTO.getNum());
                orderGoodsDO.setOrderNo(orderNo);
                //查询当前商品规格
                // 查询当前商品规格
                ComShopGoodsAttrDO goodsAttrDO = comShopGoodsAttrDAO.selectById(createGoodsDTO.getGoodsAttrId());
                if(goodsAttrDO == null){
                    log.error("未查询到商品规格信息,商品id" + createGoodsDTO.getGoodsId() + "商品规格id:" + createGoodsDTO.getGoodsAttrId());
                if (goodsAttrDO == null) {
                    log.error(
                        "未查询到商品规格信息,商品id" + createGoodsDTO.getGoodsId() + "商品规格id:" + createGoodsDTO.getGoodsAttrId());
                    continue;
                }
                orderGoodsDO.setGoodsAttrId(goodsAttrDO.getId());
                orderGoodsDO.setGoodsAttrPrice(goodsAttrDO.getPrice());
                orderGoodsDO.setGoodsAttrPic(goodsAttrDO.getAttrPic());
                orderGoodsDOList.add(orderGoodsDO);
                //将商品金额计算到订单总金额
                orderTotal = orderTotal.add(orderGoodsDO.getGoodsAttrPrice().multiply(BigDecimal.valueOf(orderGoodsDO.getAmount())));
                // 将商品金额计算到订单总金额
                orderTotal = orderTotal
                    .add(orderGoodsDO.getGoodsAttrPrice().multiply(BigDecimal.valueOf(orderGoodsDO.getAmount())));
            }
        }

        //如果是购物车提交，需要将购物车内商品移除
        if(orderCreateDTO.getSubmitType().equals(ComShopOrderCreateDTO.submitType.cart)){
        // 如果是购物车提交，需要将购物车内商品移除
        if (orderCreateDTO.getSubmitType().equals(ComShopOrderCreateDTO.submitType.cart)) {
            comShopCartDAO.deleteBatchIds(orderCreateDTO.getCartIds());
        }

        //创建订单信息
        // 创建订单信息
        ComShopOrderDO shopOrderDO = new ComShopOrderDO();
        shopOrderDO.setOrderNo(orderNo);
        shopOrderDO.setStoreId(storeId);
@@ -251,57 +283,75 @@
        shopOrderDO.setTotalAmount(orderTotal);
        shopOrderDO.setDiscountAmount(BigDecimal.ZERO);
        shopOrderDO.setDeliveryType(deliveryType);
        if(StringUtils.isNotEmpty(orderCreateDTO.getRemark())){
        if (StringUtils.isNotEmpty(orderCreateDTO.getRemark())) {
            shopOrderDO.setRemark(orderCreateDTO.getRemark());
        }
        this.baseMapper.insert(shopOrderDO);

        if(!orderGoodsDOList.isEmpty()){
            orderGoodsDOList.forEach(orderGoods ->{
        if (!orderGoodsDOList.isEmpty()) {
            orderGoodsDOList.forEach(orderGoods -> {
                orderGoods.setOrderId(shopOrderDO.getId());
                comShopOrderGoodsDAO.insert(orderGoods);
            });
        }

        //创建订单操作记录
        // 创建订单操作记录
        ComShopOrderOperateDO orderOperateDO = new ComShopOrderOperateDO();
        orderOperateDO.setOrderNo(orderNo);

        orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.create);
        orderOperateDO.setOperationTime(new Date());
        if(StringUtils.isNotEmpty(orderCreateDTO.getPhone())){
        if (StringUtils.isNotEmpty(orderCreateDTO.getPhone())) {
            orderOperateDO.setOperationContent("用户" + orderCreateDTO.getPhone() + "下单");
            orderOperateDO.setOperationBy("用户" + orderCreateDTO.getPhone());
        }else {
        } else {
            orderOperateDO.setOperationContent("用户下单");
            orderOperateDO.setOperationBy("用户");
        }
        comShopOrderOperateDAO.insert(orderOperateDO);

        shopOrderVO.setOrderNo(orderNo);
        shopOrderVO.setOrderTotal(orderTotal);
        shopOrderVO.setOrderId(shopOrderDO.getId());

        try {
            BigDecimal money = orderTotal;
            if (isTest) {
                money = BigDecimal.valueOf(0.01);
            }
            // 调用wx支付
            String xml = WxPayUtils.getUnifiedorder(appid, mchId, payKey, notifyUrl, "商品购买", orderCreateDTO.getOpenId(),
                orderNo, money);
            log.info("微信支付返回参数:" + xml);
            shopOrderVO.setPayResult(xml);
        } catch (Exception e) {
            log.error("调用微信支付异常,异常原因：" + e.getMessage());
        }
        return R.ok(shopOrderVO);
    }

    /**
     * 分页查询用户订单列表
     * @param comOrderListDTO   请求参数
     * @return  查询结果
     *
     * @param comOrderListDTO
     *            请求参数
     * @return 查询结果
     */
    @Override
    public R pageOrderList(PageComOrderListDTO comOrderListDTO){
        Page page = new Page<>(comOrderListDTO.getPageNum(),comOrderListDTO.getPageSize());
        IPage<ComShopOrderPageVO> orderPageVOIPage = this.baseMapper.pageOrderList(page,comOrderListDTO);
        if(!orderPageVOIPage.getRecords().isEmpty()){
    public R pageOrderList(PageComOrderListDTO comOrderListDTO) {
        Page page = new Page<>(comOrderListDTO.getPageNum(), comOrderListDTO.getPageSize());
        IPage<ComShopOrderPageVO> orderPageVOIPage = this.baseMapper.pageOrderList(page, comOrderListDTO);
        if (!orderPageVOIPage.getRecords().isEmpty()) {
            orderPageVOIPage.getRecords().forEach(orderVo -> {
                List<ComShopOrderGoodsVO> orderGoodsVOS = new ArrayList<>();
                //查询订单下商品信息
                List<ComShopOrderGoodsDO> orderGoodsDOList = comShopOrderGoodsDAO.selectList(new QueryWrapper<ComShopOrderGoodsDO>()
                        .eq("order_no",orderVo.getOrderNo()));
                if(!orderGoodsDOList.isEmpty()){
                // 查询订单下商品信息
                List<ComShopOrderGoodsDO> orderGoodsDOList = comShopOrderGoodsDAO
                    .selectList(new QueryWrapper<ComShopOrderGoodsDO>().eq("order_no", orderVo.getOrderNo()));
                if (!orderGoodsDOList.isEmpty()) {
                    orderGoodsDOList.forEach(orderGoods -> {
                        ComShopOrderGoodsVO orderGoodsVO = new ComShopOrderGoodsVO();
                        BeanUtils.copyProperties(orderGoods,orderGoodsVO);
                        BeanUtils.copyProperties(orderGoods, orderGoodsVO);
                        // 根据商品规格id查询商品规格
                        ComShopGoodsAttrDO goodsAttrDO = comShopGoodsAttrDAO.selectById(orderGoods.getGoodsAttrId());
                        if (goodsAttrDO != null) {
                            orderGoodsVO.setGoodsAttr(goodsAttrDO.getGoodsAttr());
                        }
                        orderGoodsVO.setNum(orderGoods.getAmount());
                        orderGoodsVO.setGoodsPic(orderGoods.getGoodsAttrPic());
                        orderGoodsVO.setPrice(orderGoods.getGoodsAttrPrice());
@@ -311,10 +361,10 @@
                orderVo.setOrderGoodsVOList(orderGoodsVOS);

                PageShopStoreVO shopStoreVO = new PageShopStoreVO();
                //查询店铺信息
                // 查询店铺信息
                ComShopStoreDO shopStoreDO = comShopStoreDAO.selectById(orderVo.getStoreId());
                if(shopStoreDO != null){
                    BeanUtils.copyProperties(shopStoreDO,shopStoreVO);
                if (shopStoreDO != null) {
                    BeanUtils.copyProperties(shopStoreDO, shopStoreVO);
                }
                orderVo.setShopStoreVO(shopStoreVO);
            });
@@ -324,91 +374,124 @@

    /**
     * 根据订单id查询订单详情
     * @param orderId   订单id
     * @return  订单详情
     *
     * @param orderId
     *            订单id
     * @return 订单详情
     */
    @Override
    public R orderDetail(Long orderId) {

        ComShopOrderPageVO orderVO = new ComShopOrderPageVO();
        //查询订单信息
        // 查询订单信息
        ComShopOrderDO shopOrderDO = this.baseMapper.selectById(orderId);
        if(shopOrderDO == null){
        if (shopOrderDO == null) {
            return R.fail("未查询到订单");
        }
        BeanUtils.copyProperties(shopOrderDO,orderVO);
        BeanUtils.copyProperties(shopOrderDO, orderVO);
        orderVO.setOrderTotal(shopOrderDO.getTotalAmount());

        PageShopStoreVO shopStoreVO = new PageShopStoreVO();
        //查询店铺信息
        // 查询店铺信息
        ComShopStoreDO shopStoreDO = comShopStoreDAO.selectById(shopOrderDO.getStoreId());
        if(shopStoreDO != null){
            BeanUtils.copyProperties(shopStoreDO,shopStoreVO);
        if (shopStoreDO != null) {
            BeanUtils.copyProperties(shopStoreDO, shopStoreVO);
        }
        orderVO.setShopStoreVO(shopStoreVO);

        List<ComShopOrderGoodsVO> orderGoodsVOS = new ArrayList<>();
        //查询订单下商品信息
        List<ComShopOrderGoodsDO> orderGoodsDOList = comShopOrderGoodsDAO.selectList(new QueryWrapper<ComShopOrderGoodsDO>()
                .eq("order_no",shopOrderDO.getOrderNo()));
        if(!orderGoodsDOList.isEmpty()){
        // 查询订单下商品信息
        List<ComShopOrderGoodsDO> orderGoodsDOList = comShopOrderGoodsDAO
            .selectList(new QueryWrapper<ComShopOrderGoodsDO>().eq("order_no", shopOrderDO.getOrderNo()));
        StringBuilder sbr = new StringBuilder();
        if (!orderGoodsDOList.isEmpty()) {
            orderGoodsDOList.forEach(orderGoods -> {
                ComShopOrderGoodsVO orderGoodsVO = new ComShopOrderGoodsVO();
                BeanUtils.copyProperties(orderGoods,orderGoodsVO);
                BeanUtils.copyProperties(orderGoods, orderGoodsVO);
                orderGoodsVO.setNum(orderGoods.getAmount());
                orderGoodsVO.setGoodsPic(orderGoods.getGoodsAttrPic());
                orderGoodsVO.setPrice(orderGoods.getGoodsAttrPrice());
                // 查询商品信息判断商品状态
                ComShopGoodsDO goodsDO = comShopGoodsDAO.selectById(orderGoods.getGoodsId());
                if (goodsDO == null || goodsDO.getDeleteStatus().equals(ComShopGoodsDO.deleteStatus.yes)
                    || goodsDO.getDeleteStatus().equals(ComShopGoodsDO.status.recovery)) {
                    orderGoodsVO.setGoodsStatus(ComShopOrderGoodsVO.goodsStatus.ysc);
                } else if (goodsDO.getStatus().equals(ComShopGoodsDO.status.lower)) {
                    orderGoodsVO.setGoodsStatus(ComShopOrderGoodsVO.goodsStatus.yxj);
                } else if (goodsDO.getStatus().equals(ComShopGoodsDO.status.sell)) {
                    orderGoodsVO.setGoodsStatus(ComShopOrderGoodsVO.goodsStatus.csz);
                }

                // 根据商品规格id查询商品规格
                ComShopGoodsAttrDO goodsAttrDO = comShopGoodsAttrDAO.selectById(orderGoods.getGoodsAttrId());
                if (goodsAttrDO != null) {
                    orderGoodsVO.setGoodsAttr(goodsAttrDO.getGoodsAttr());
                }
                orderGoodsVOS.add(orderGoodsVO);
                sbr.append(orderGoods.getGoodsName() + " ");
            });
        }
        orderVO.setOrderGoodsVOList(orderGoodsVOS);
        orderVO.setGoodsName(sbr.toString());

        ComShopUserAddressVO userAddressVO = new ComShopUserAddressVO();
        //查询用户收货地址
        // 查询用户收货地址
        ComShopUserAddressDO userAddressDO = comShopUserAddressDAO.selectById(shopOrderDO.getReceiverId());
        if(userAddressDO != null){
            BeanUtils.copyProperties(userAddressDO,userAddressVO);
        if (userAddressDO != null) {
            BeanUtils.copyProperties(userAddressDO, userAddressVO);
            orderVO.setUserAddressVO(userAddressVO);
        }

        // 操作日志
        List<ComShopOrderOperateDO> listOperLog =
            comShopOrderOperateDAO.selectList(new LambdaQueryWrapper<ComShopOrderOperateDO>()
                .eq(ComShopOrderOperateDO::getOrderNo, shopOrderDO.getOrderNo()));
        List<ComShopOrderOperateVO> listOperLogVO = new ArrayList<>(listOperLog.size());
        listOperLog.forEach(logDO -> {
            ComShopOrderOperateVO copyVO = new ComShopOrderOperateVO();
            BeanUtils.copyProperties(logDO, copyVO);
            listOperLogVO.add(copyVO);
        });
        orderVO.setLogs(listOperLogVO);
        return R.ok(orderVO);
    }

    /**
     * 根据订单id取消订单
     * @param orderId   订单id
     * @param phone 操作用户手机号
     * @return  取消结果
     *
     * @param comShopOrderQueryDTO
     *            订单信息
     * @return 取消结果
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public R orderCancel(Long orderId,String phone){
        //查询订单
        ComShopOrderDO shopOrderDO = this.baseMapper.selectById(orderId);
        if(shopOrderDO == null){
    public R orderCancel(ComShopOrderQueryDTO comShopOrderQueryDTO) {
        // 查询订单
        ComShopOrderDO shopOrderDO = this.baseMapper.selectById(comShopOrderQueryDTO.getOrderId());
        if (shopOrderDO == null) {
            return R.fail("未查询到订单");
        }
        if(!shopOrderDO.getStatus().equals(ComShopOrderDO.status.dfk)){
        if (!shopOrderDO.getStatus().equals(ComShopOrderDO.status.dfk)) {
            return R.fail("已支付订单不可取消");
        }
        //取消订单
        // 取消订单
        shopOrderDO.setStatus(ComShopOrderDO.status.yqx);
        if(this.baseMapper.updateById(shopOrderDO) > 0){
            //添加订单操作记录
        if (this.baseMapper.updateById(shopOrderDO) > 0) {
            // 添加订单操作记录
            ComShopOrderOperateDO orderOperateDO = new ComShopOrderOperateDO();
            orderOperateDO.setOrderNo(shopOrderDO.getOrderNo());
            orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.cancel);
            orderOperateDO.setOperationTime(new Date());
            if(StringUtils.isNotEmpty(phone)){
                orderOperateDO.setOperationContent("用户" + phone + "取消订单");
                orderOperateDO.setOperationBy("用户" + phone);
            }else {
            if (comShopOrderQueryDTO.getIsAdmin()) {
                orderOperateDO.setOperationContent("管理员" + comShopOrderQueryDTO.getOperUserAccount() + "取消订单");
                orderOperateDO.setOperationBy("用户" + comShopOrderQueryDTO.getOperUserAccount());
            } else {
                orderOperateDO.setOperationContent("用户取消订单");
                orderOperateDO.setOperationBy("用户");
            }
            comShopOrderOperateDAO.insert(orderOperateDO);
            return R.ok();
        }else{
        } else {
            return R.fail("取消订单失败");
        }

@@ -416,90 +499,99 @@

    /**
     * 根据订单id删除订单
     * @param orderId   订单id
     * @return  删除结果
     *
     * @param orderId
     *            订单id
     * @return 删除结果
     */
    @Override
    public R orderDelete(Long orderId){
        //查询订单
    public R orderDelete(Long orderId) {
        // 查询订单
        ComShopOrderDO shopOrderDO = this.baseMapper.selectById(orderId);
        if(shopOrderDO == null){
        if (shopOrderDO == null) {
            return R.fail("未查询到订单");
        }
        if(!shopOrderDO.getStatus().equals(ComShopOrderDO.status.ywc) && !shopOrderDO.getStatus().equals(ComShopOrderDO.status.yqx)){
        if (!shopOrderDO.getStatus().equals(ComShopOrderDO.status.ywc)
            && !shopOrderDO.getStatus().equals(ComShopOrderDO.status.yqx)) {
            return R.fail("该订单状态不可删除");
        }

        shopOrderDO.setDeleteStatus(ComShopOrderDO.deleteStatus.yes);
        if(this.baseMapper.updateById(shopOrderDO) > 0){
        if (this.baseMapper.updateById(shopOrderDO) > 0) {
            return R.ok();
        }else{
        } else {
            return R.fail("取消订单失败");
        }
    }

    /**
     * 根据订单id确认收货
     * @param orderId   订单id
     * @param phone 手机号
     * @return  确认结果
     *
     * @param orderId
     *            订单id
     * @param phone
     *            手机号
     * @return 确认结果
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public R orderConfirm(Long orderId, String phone){
        //查询订单
    public R orderConfirm(Long orderId, String phone) {
        // 查询订单
        ComShopOrderDO shopOrderDO = this.baseMapper.selectById(orderId);
        if(shopOrderDO == null){
        if (shopOrderDO == null) {
            return R.fail("未查询到订单");
        }
        if(!shopOrderDO.getStatus().equals(ComShopOrderDO.status.dsh)){
        if (!shopOrderDO.getStatus().equals(ComShopOrderDO.status.dsh)) {
            return R.fail("该订单状态不可确认收货");
        }
        //订单确认收货
        // 订单确认收货
        shopOrderDO.setStatus(ComShopOrderDO.status.ywc);
        if(this.baseMapper.updateById(shopOrderDO) > 0){
            //添加订单操作记录
        shopOrderDO.setReceivingTime(new Date());
        if (this.baseMapper.updateById(shopOrderDO) > 0) {
            // 添加订单操作记录
            ComShopOrderOperateDO orderOperateDO = new ComShopOrderOperateDO();
            orderOperateDO.setOrderNo(shopOrderDO.getOrderNo());
            orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.complete);
            orderOperateDO.setOperationTime(new Date());
            if(StringUtils.isNotEmpty(phone)){
            if (StringUtils.isNotEmpty(phone)) {
                orderOperateDO.setOperationContent("用户" + phone + "确认收货");
                orderOperateDO.setOperationBy("用户" + phone);
            }else {
            } else {
                orderOperateDO.setOperationContent("用户确认收货");
                orderOperateDO.setOperationBy("用户");
            }
            comShopOrderOperateDAO.insert(orderOperateDO);
            return R.ok();
        }else{
        } else {
            return R.fail("确认收货失败");
        }
    }

    /**
     * 统计用户订单数量
     * @param userId    用户id
     * @return  统计结果
     *
     * @param userId
     *            用户id
     * @return 统计结果
     */
    @Override
    public R orderStatistics(Long userId){
    public R orderStatistics(Long userId) {
        OrderStatisticsVO orderStatisticsVO = new OrderStatisticsVO();
        //待付款订单数
        // 待付款订单数
        Integer paymentNum = 0;
        //待发货订单数
        // 待发货订单数
        Integer deliverNum = 0;
        //待收货订单数
        // 待收货订单数
        Integer receivingNum = 0;
        List<ComShopOrderDO> shopOrderList = this.baseMapper.selectList(new QueryWrapper<ComShopOrderDO>()
                .eq("user_id",userId).eq("delete_status",ComShopOrderDO.deleteStatus.no));
        if(!shopOrderList.isEmpty()){
            for (ComShopOrderDO orderDO:shopOrderList) {
                if(orderDO.getStatus().equals(ComShopOrderDO.status.dfk)){
            .eq("user_id", userId).eq("delete_status", ComShopOrderDO.deleteStatus.no));
        if (!shopOrderList.isEmpty()) {
            for (ComShopOrderDO orderDO : shopOrderList) {
                if (orderDO.getStatus().equals(ComShopOrderDO.status.dfk)) {
                    paymentNum++;
                }else if(orderDO.getStatus().equals(ComShopOrderDO.status.dfh)){
                } else if (orderDO.getStatus().equals(ComShopOrderDO.status.dfh)) {
                    deliverNum++;
                }else if(orderDO.getStatus().equals(ComShopOrderDO.status.dsh)){
                } else if (orderDO.getStatus().equals(ComShopOrderDO.status.dsh)) {
                    receivingNum++;
                }
            }
@@ -511,22 +603,318 @@
    }

    @Override
    public R pageShopOrder(PageComShopOrderSearchDTO pageComShopOrderSearchDTO) {
    public R shipOrder(ComShopOrderShipDTO orderShipDTO) {
        ComShopOrderDO comShopOrderDO = comShopOrderDAO.selectById(orderShipDTO.getOrderId());
        if (comShopOrderDO == null) {
            return R.fail("订单不存在");
        }
        if (!(comShopOrderDO.getStatus() == 2) || !(comShopOrderDO.getDeliveryStatus() == 1)) {
            return R.fail("订单发货失败,订单状态不允许发货");
        }

        ComShopStoreDO storeDO = comShopStoreDAO.selectById(comShopOrderDO.getStoreId());
        if (storeDO.getDeliveryType() != 2) {
            return R.fail("该商家不支持通过快递物流发货");
        }
        comShopOrderDO.setDeliveryStatus(2);
        comShopOrderDO.setDeliveryType(2);
        comShopOrderDO.setStatus(3);
        comShopOrderDO.setDeliveryTime(Calendar.getInstance().getTime());
        comShopOrderDO.setLogisticsCompany(orderShipDTO.getLogisticsCompany());
        comShopOrderDO.setLogisticsNo(orderShipDTO.getLogisticsNo());
        int updated = comShopOrderDAO.updateById(comShopOrderDO);
        if (updated == 1) {
            // 创建订单操作记录
            ComShopOrderOperateDO orderOperateDO = new ComShopOrderOperateDO();
            orderOperateDO.setOrderNo(comShopOrderDO.getOrderNo());
            orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.deliver);
            orderOperateDO.setOperationTime(new Date());
            if (orderShipDTO.getIsAdmin()) {
                orderOperateDO.setOperationContent(orderShipDTO.getOperUserAccount() + "已发货");
                orderOperateDO.setOperationBy(orderShipDTO.getOperUserAccount());
            } else {
                orderOperateDO.setOperationContent(orderShipDTO.getOperUserAccount() + "已发货");
                orderOperateDO.setOperationBy(orderShipDTO.getOperUserAccount());
            }
            int inserted = comShopOrderOperateDAO.insert(orderOperateDO);
            if (inserted != 1) {
                log.error("订单发货日志保存错误");
            }
            return R.ok("发货成功");
        }
        return R.fail("发货失败!");
    }

    @Override
    public R deliverOrder(ComShopOrderDeliverDTO orderDeliverDTO) {
        ComShopOrderDO comShopOrderDO = comShopOrderDAO.selectById(orderDeliverDTO.getOrderId());
        if (comShopOrderDO == null) {
            return R.fail("订单不存在");
        }
        if (!(comShopOrderDO.getStatus() == 2) || !(comShopOrderDO.getDeliveryStatus() == 1)) {
            return R.fail("当前订单不能配送");
        }
        ComShopStoreDO storeDO = comShopStoreDAO.selectById(comShopOrderDO.getStoreId());
        if (storeDO.getDeliveryType() != 1) {
            return R.fail("该商家不支持通过商家配送");
        }
        comShopOrderDO.setDeliveryStatus(4);
        comShopOrderDO.setDeliveryType(1);
        comShopOrderDO.setStatus(3);
        comShopOrderDO.setDeliveryTime(Calendar.getInstance().getTime());
        int updated = comShopOrderDAO.updateById(comShopOrderDO);
        if (updated == 1) {

            // 创建订单操作记录
            ComShopOrderOperateDO orderOperateDO = new ComShopOrderOperateDO();
            orderOperateDO.setOrderNo(comShopOrderDO.getOrderNo());
            orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.deliver);
            orderOperateDO.setOperationTime(new Date());
            if (orderDeliverDTO.getIsAdmin()) {
                orderOperateDO.setOperationContent(orderDeliverDTO.getOperUserAccount() + "已发货");
                orderOperateDO.setOperationBy(orderDeliverDTO.getOperUserAccount());
            } else {
                orderOperateDO.setOperationContent(orderDeliverDTO.getOperUserAccount() + "已发货");
                orderOperateDO.setOperationBy(orderDeliverDTO.getOperUserAccount());
            }
            int inserted = comShopOrderOperateDAO.insert(orderOperateDO);
            if (inserted != 1) {
                log.error("订单发货日志保存错误");
            }
            return R.ok("开始配送");
        }
        return R.fail("操作失败!");
    }

    @Override
    public R finishDeliverOrder(ComShopOrderDeliverDTO orderDeliverDTO) {
        ComShopOrderDO comShopOrderDO = comShopOrderDAO.selectById(orderDeliverDTO.getOrderId());
        if (comShopOrderDO == null) {
            return R.fail("订单不存在");
        }
        if (comShopOrderDO.getDeliveryStatus() != 4 && comShopOrderDO.getDeliveryStatus() != 3) {
            return R.fail("订单还未开始配送");
        }
        if (!(comShopOrderDO.getStatus() == 3)) {
            return R.fail("订单还未发货");
        }
        // comShopOrderDO.setStatus(4);
        comShopOrderDO.setDeliveryStatus(5);
        int updated = comShopOrderDAO.updateById(comShopOrderDO);
        if (updated == 1) {
            // 创建订单操作记录
            ComShopOrderOperateDO orderOperateDO = new ComShopOrderOperateDO();
            orderOperateDO.setOrderNo(comShopOrderDO.getOrderNo());
            orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.complete);
            orderOperateDO.setOperationTime(new Date());
            if (orderDeliverDTO.getIsAdmin()) {
                orderOperateDO.setOperationContent("订单已完成");
                orderOperateDO.setOperationBy(orderDeliverDTO.getOperUserAccount());
            } else {
                orderOperateDO.setOperationContent("订单已完成");
                orderOperateDO.setOperationBy(orderDeliverDTO.getOperUserAccount());
            }
            int inserted = comShopOrderOperateDAO.insert(orderOperateDO);
            if (inserted != 1) {
                log.error("订单发货日志保存错误");
            }
            return R.ok("配送完成");
        }
        return R.fail("操作失败!");
    }

    @Override
    public R shopOrderExportData(ComShopOrderExportDTO comShopOrderExportDTO) {
        Page page = new Page();
        page.setSize(10000);
        page.setCurrent(1);
        IPage<ExcelShopOrderDTO> excelShopOrderDTO = comShopOrderDAO.selectOrderExport(page, comShopOrderExportDTO);
        return R.ok(excelShopOrderDTO.getRecords());
    }

    @Override
    public R shopOrderFundsExportData(ComShopFundsExportDTO comShopFundsExportDTO) {
        Page page = new Page();
        page.setSize(10000);
        page.setCurrent(1);
        IPage<ExcelShopFundsDTO> excelShopFundsDTO = comShopOrderDAO.selectFundsExport(page, comShopFundsExportDTO);
        return R.ok(excelShopFundsDTO.getRecords());
    }

    @Override
    public R getFundsStat(Long userId) {
        ComShopFundsVO comShopFundsVO = comShopOrderDAO.queryStatis(userId);
        if (comShopFundsVO == null) {
            comShopFundsVO = new ComShopFundsVO();
            comShopFundsVO.setMonthTotal(new BigDecimal(0));
            comShopFundsVO.setTodayTotal(new BigDecimal(0));
            comShopFundsVO.setWeekTotal(new BigDecimal(0));
        }
        return R.ok(comShopFundsVO);
    }

    @Override
    public R pageShopFunds(PageComShopFundsSearchDTO pageComShopFundsSearchDTO) {
        Long pageNum = pageComShopFundsSearchDTO.getPageNum();
        Long pageSize = pageComShopFundsSearchDTO.getPageSize();
        Page page = new Page();
        if (pageNum == null || 0 == pageNum.longValue()) {
            pageNum = 1l;
        }
        if (pageSize == null || 0 == pageSize.longValue()) {
            pageSize = 10l;
        }
        page.setCurrent(pageNum);
        page.setSize(pageSize);
        IPage<ComShopFundsOrderVO> comShopFundsOrderVOIPage =
            comShopOrderDAO.pageShopFunds(page, pageComShopFundsSearchDTO);
        return R.ok(comShopFundsOrderVOIPage);
    }

    @Override
    public R pageShopOrder(PageComShopOrderSearchDTO pageComShopOrderSearchDTO) {
        Long pageNum = pageComShopOrderSearchDTO.getPageNum();
        Long pageSize = pageComShopOrderSearchDTO.getPageSize();
        PageDTO page = new PageDTO();
        Page page = new Page();

        page.setPageNum(pageNum);
        page.setPageSize(pageSize);
        if(pageNum==null||new Long(0).equals(pageNum.longValue())){
            page.setPageNum(1l);
        page.setCurrent(pageNum);
        page.setSize(pageSize);
        if (pageNum == null || 0 == pageNum.longValue()) {
            page.setCurrent(1l);
        }
        if(pageSize==null||new Long(0).equals(pageSize.longValue())){
            page.setPageSize(10l);
        if (pageSize == null || 0 == pageSize.longValue()) {
            page.setSize(10l);
        }

        this.baseMapper.pageOrderBy(page, pageComShopOrderSearchDTO);
        return null;
        IPage<ComShopOrderSearchVO> ipage = this.baseMapper.pageOrderBy(page, pageComShopOrderSearchDTO);
        return R.ok(ipage);
    }

    @Override
    public R capitalDetailByStore(Long id) {
        if (id == null) {
            R.fail("订单号不能为空！");
        }
        CapitalDetailVO vo = this.baseMapper.capitalDetailByStore(id);
        return R.ok(vo);
    }

    /**
     * 微信支付订单回调
     *
     * @param wxPayNotifyOrderDTO
     *            订单支付回调参数
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void wxOrderPayNotify(WxPayNotifyOrderDTO wxPayNotifyOrderDTO) {
        log.info("微信订单支付回调开始处理逻辑");
        if (StringUtils.isEmpty(wxPayNotifyOrderDTO.getOrderTradeNo())) {
            log.error("微信支付回调失败，订单号为空");
            return;
        }

        log.info("微信订单支付回调开始查询订单");
        // 查询订单
        ComShopOrderDO shopOrderDO = this.baseMapper.selectOne(new QueryWrapper<ComShopOrderDO>().lambda()
            .eq(ComShopOrderDO::getOrderNo, wxPayNotifyOrderDTO.getOrderTradeNo()));
        if (shopOrderDO == null) {
            log.error("未查询到支付订单,订单回调失败,订单号:" + wxPayNotifyOrderDTO.getOrderTradeNo());
            return;
        }
        shopOrderDO.setStatus(ComShopOrderDO.status.dfh);
        shopOrderDO.setPayType(ComShopOrderDO.payType.wx);
        shopOrderDO.setPayStatus(ComShopOrderDO.payStatus.yes);
        shopOrderDO.setPayAmount(BigDecimal.valueOf(Double.valueOf(wxPayNotifyOrderDTO.getCashFee()) / 100));
        shopOrderDO.setWxTardeNo(wxPayNotifyOrderDTO.getWxTradeNo());
        shopOrderDO.setPayTime(
            DateUtils.stringToDate(wxPayNotifyOrderDTO.getPayTime(), new SimpleDateFormat("yyyyMMddHHmmss")));
        this.baseMapper.updateById(shopOrderDO);

        // 查询订单商品
        List<ComShopOrderGoodsDO> orderGoodsList =
            comShopOrderGoodsDAO.selectList(new QueryWrapper<ComShopOrderGoodsDO>().lambda()
                .eq(ComShopOrderGoodsDO::getOrderNo, shopOrderDO.getOrderNo()));
        if (!orderGoodsList.isEmpty()) {
            int goodsNub = 0;
            for (ComShopOrderGoodsDO orderGood : orderGoodsList) {
                goodsNub += orderGood.getAmount();
                // 更新商品信息
                ComShopGoodsDO goodsDO = comShopGoodsDAO.selectById(orderGood.getGoodsId());
                if (goodsDO != null) {
                    goodsDO.setSale(goodsDO.getSale() + orderGood.getAmount());
                    comShopGoodsDAO.updateById(goodsDO);
                }

                // 更新商品规格
                ComShopGoodsAttrDO goodsAttrDO = comShopGoodsAttrDAO.selectById(orderGood.getGoodsAttrId());
                if (goodsAttrDO != null) {
                    goodsAttrDO.setSale(goodsAttrDO.getSale() + orderGood.getAmount());
                    comShopGoodsAttrDAO.updateById(goodsAttrDO);
                }
            }

            // 更新店铺销量以及销售额
            ComShopStoreDO storeDO = comShopStoreDAO.selectById(shopOrderDO.getStoreId());
            if (storeDO != null) {
                storeDO.setSale(storeDO.getSale() + goodsNub);
                storeDO.setSaleVolume(storeDO.getSaleVolume().add(shopOrderDO.getTotalAmount()));
                comShopStoreDAO.updateById(storeDO);
            }
        }

        // 添加订单操作记录
        ComShopOrderOperateDO orderOperateDO = new ComShopOrderOperateDO();
        orderOperateDO.setOrderNo(shopOrderDO.getOrderNo());
        orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.pay);
        orderOperateDO.setOperationTime(new Date());
        orderOperateDO.setOperationContent("用户支付订单");
        orderOperateDO.setOperationBy("用户");
        comShopOrderOperateDAO.insert(orderOperateDO);

        // 添加订单支付记录表
        ComShopOrderPayDO orderPayDO = new ComShopOrderPayDO();
        orderPayDO.setOrderNo(shopOrderDO.getOrderNo());
        orderPayDO.setOrderAmount(shopOrderDO.getTotalAmount());
        orderPayDO.setWxTradeNo(wxPayNotifyOrderDTO.getWxTradeNo());
        orderPayDO.setPayStatus(ComShopOrderPayDO.payStatus.yes);
        orderPayDO.setPayAmount(shopOrderDO.getPayAmount());
        orderPayDO.setPayTime(shopOrderDO.getPayTime());
        comShopOrderPayDAO.insert(orderPayDO);
    }

    /**
     * 订单去支付
     *
     * @param orderPayDTO
     *            请求参数
     * @return 支付对象
     */
    public R wxPay(OrderPayDTO orderPayDTO) {
        // 创建返回参数
        ComShopOrderVO shopOrderVO = new ComShopOrderVO();
        // 查询订单
        ComShopOrderDO orderDO = comShopOrderDAO.selectOne(
            new QueryWrapper<ComShopOrderDO>().lambda().eq(ComShopOrderDO::getOrderNo, orderPayDTO.getOrderNo()));
        if (orderDO == null) {
            return R.fail("订单不存在");
        }
        try {
            BigDecimal money = orderDO.getTotalAmount();
            if (isTest) {
                money = BigDecimal.valueOf(0.01);
            }
            // 调用wx支付
            String xml = WxPayUtils.getUnifiedorder(appid, mchId, payKey, notifyUrl, "商品购买", orderPayDTO.getOpenId(),
                orderDO.getOrderNo(), money);
            log.info("微信支付返回参数:" + xml);
            shopOrderVO.setPayResult(xml);
        } catch (Exception e) {
            log.error("调用微信支付异常,异常原因：" + e.getMessage());
        }
        shopOrderVO.setOrderId(orderDO.getId());
        shopOrderVO.setOrderNo(orderDO.getOrderNo());
        shopOrderVO.setOrderTotal(orderDO.getTotalAmount());
        return R.ok(shopOrderVO);
    }
}