Merge remote-tracking branch 'origin/master'

mitao

2024-06-13 464254ba0e542c22fac68c7512f06a9a8df34b28

 ruoyi-modules/ruoyi-order/src/main/java/com/ruoyi/order/service/impl/OrderServiceImpl.java

@@ -1,18 +1,72 @@
package com.ruoyi.order.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Lists;
import com.ruoyi.common.core.constant.CacheConstants;
import com.ruoyi.common.core.constant.SecurityConstants;
import com.ruoyi.common.core.enums.OrderFromEnum;
import com.ruoyi.common.core.enums.OrderStatusEnum;
import com.ruoyi.order.domain.OrderMall;
import com.ruoyi.common.core.enums.PaymentMethodEnum;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.core.utils.page.BeanUtils;
import com.ruoyi.common.core.utils.page.PageDTO;
import com.ruoyi.common.redis.service.RedisService;
import com.ruoyi.order.controller.management.dto.MgtMallOrderQuery;
import com.ruoyi.order.controller.management.dto.MgtOrderConfirmShipmentDTO;
import com.ruoyi.order.controller.management.vo.MgtMallOrderVO;
import com.ruoyi.order.controller.management.vo.MgtOrderReturnRequestVO;
import com.ruoyi.order.domain.OrderReturnRequest;
import com.ruoyi.order.domain.Paylog;
import com.ruoyi.order.mapper.OrderAuctionBondMapper;
import com.ruoyi.order.mapper.OrderMapper;
import com.ruoyi.order.service.IOrderMallService;
import com.ruoyi.order.service.IOrderReturnRequestService;
import com.ruoyi.order.service.IOrderService;
import com.ruoyi.order.service.IPaylogService;
import com.ruoyi.order.util.OrderUtil;
import com.ruoyi.order.util.SinataUtil;
import com.ruoyi.system.api.domain.CouponMember;
import com.ruoyi.system.api.domain.CustomConfig;
import com.ruoyi.system.api.domain.GoodsGroupPurchase;
import com.ruoyi.system.api.domain.GoodsSeckill;
import com.ruoyi.system.api.domain.GoodsSku;
import com.ruoyi.system.api.domain.Member;
import com.ruoyi.system.api.domain.MemberAddress;
import com.ruoyi.system.api.domain.Order;
import com.ruoyi.system.api.domain.OrderAuctionBond;
import com.ruoyi.system.api.domain.dto.CouponMemberDTO;
import com.ruoyi.system.api.domain.dto.GoodsStockUpdDTO;
import com.ruoyi.system.api.domain.dto.HomeGoodsSkuDTO;
import com.ruoyi.system.api.domain.dto.MemberDTO;
import com.ruoyi.system.api.domain.dto.MemberOrderDTO;
import com.ruoyi.system.api.domain.dto.MemberOrderListDTO;
import com.ruoyi.system.api.domain.dto.OrderDTO;
import com.ruoyi.system.api.domain.dto.updMembeOneDTO;
import com.ruoyi.system.api.domain.vo.MemberOrderListVO;
import com.ruoyi.system.api.domain.vo.MemberTiOrderVO;
import com.ruoyi.system.api.domain.vo.OrderVO;
import com.ruoyi.system.api.feignClient.GoodsSkuClient;
import com.ruoyi.system.api.feignClient.MemberClient;
import com.ruoyi.system.api.feignClient.PromotionClient;
import com.ruoyi.system.api.feignClient.SysUserClient;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import javax.annotation.Resource;

import lombok.Synchronized;
import org.apache.commons.beanutils.BeanUtils;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;

/**
@@ -26,29 +80,100 @@
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements IOrderService {

    @Resource
    private GoodsSkuClient goodsSkuClient;

    @Resource
    private  IOrderService orderService;
    private MemberClient memberClient;

    @Resource
    private IOrderMallService orderMallService;
    private PromotionClient promotionClient;

    @Resource
    private OrderAuctionBondMapper orderAuctionBondMapper;

    @Resource
    private IPaylogService iPaylogService;

    @Resource
    private PaylogServiceImpl paylogService;

    @Resource
    private SysUserClient sysUserClient;

    @Resource
    private IOrderReturnRequestService orderReturnRequestService;

    @Resource
    private RedissonClient redissonClient;

    @Resource
    private RedisService redisService;


    @Override
    public void saveOrderOne(OrderDTO OrderDTO) {
        Order order=new Order();
        String prefix = OrderUtil.getOrderNoForPrefix("XM");
        order.setOrderNo(prefix);
        if (OrderDTO.getOrderFrom().getCode()==1){
            order.setOrderFrom(OrderFromEnum.COMMODITY_ORDER);
            order.setOrderNo(OrderUtil.getOrderNoForPrefix("SP"));
        }
        if (OrderDTO.getOrderFrom().getCode()==2){
            order.setOrderFrom(OrderFromEnum.SNAP_ORDERS);
            order.setOrderNo(OrderUtil.getOrderNoForPrefix("MS"));
        }
        if (OrderDTO.getOrderFrom().getCode()==3){
            order.setOrderFrom(OrderFromEnum.GROUP_PURCHASE_ORDERS);
            order.setOrderNo(OrderUtil.getOrderNoForPrefix("TG"));
        }if (OrderDTO.getOrderFrom().getCode()==4){
            order.setOrderFrom(OrderFromEnum.GROUP_PURCHASE_ORDERS);
            order.setOrderNo(OrderUtil.getOrderNoForPrefix("PM"));
        }
        order.setOrderTime(OrderDTO.getOrderTime());
        order.setOrderFrom(OrderDTO.getOrderFrom());
        order.setAuctionType(OrderDTO.getAuctionType());
        order.setGoodsSkuId(OrderDTO.getGoodsSkuId());
        order.setMemberId(OrderDTO.getMemberId());
        order.setTotalAmount(OrderDTO.getTotalAmount());
        order.setOrderStatus(OrderStatusEnum.TO_PLAY);
        order.setPoints(OrderDTO.getPoints());
        order.setGoodsQuantity(OrderDTO.getGoodsQuantity());
        order.setReceiverName(OrderDTO.getReceiverName());
        order.setReceiverphone(OrderDTO.getReceiverphone());
        order.setReceiverCity(OrderDTO.getReceiverCity());
        order.setReceiverDetailAddress(OrderDTO.getReceiverDetailAddress());
        order.setBound(OrderDTO.getBound());
        orderService.save(order);
        order.setSkuName(OrderDTO.getSkuName());
        order.setPrice(OrderDTO.getPrice());
        order.setCoverPic(OrderDTO.getCoverPic());
        this.save(order);

        if (OrderDTO.getOrderFrom().getCode()==4){
            if (OrderDTO.getAuctionType().getCode()==1){
                LambdaQueryWrapper<OrderAuctionBond> wrapper= Wrappers.lambdaQuery();
                wrapper.eq(OrderAuctionBond::getMemberId,OrderDTO.getMemberId());
                wrapper.eq(OrderAuctionBond::getAuctionGoodsId,OrderDTO.getGoodsSkuId());
                wrapper.eq(OrderAuctionBond::getBoundStatus,2);
                wrapper.eq(OrderAuctionBond::getBondType,1);
                OrderAuctionBond orderAuctionBond = orderAuctionBondMapper.selectOne(wrapper);
                orderAuctionBond.setOrderId(order.getId());
                orderAuctionBondMapper.updateById(orderAuctionBond);
            }
            if (OrderDTO.getAuctionType().getCode()==2){
                LambdaQueryWrapper<OrderAuctionBond> wrapper= Wrappers.lambdaQuery();
                wrapper.eq(OrderAuctionBond::getMemberId,OrderDTO.getMemberId());
                wrapper.eq(OrderAuctionBond::getAuctionGoodsId,OrderDTO.getGoodsSkuId());
                wrapper.eq(OrderAuctionBond::getBoundStatus,2);
                wrapper.eq(OrderAuctionBond::getAuctionSalesroomId,OrderDTO.getAuctionSalesroomId());
                wrapper.eq(OrderAuctionBond::getBondType,2);
                OrderAuctionBond orderAuctionBond = orderAuctionBondMapper.selectOne(wrapper);
                orderAuctionBond.setOrderId(order.getId());
                orderAuctionBondMapper.updateById(orderAuctionBond);
            }

        }


    }

    /**
@@ -70,11 +195,7 @@
     */
    @Override
    public Integer getGroupPurchasesGoodsNum(Long id) {
        Set<Long> orderIdSet = orderMallService.lambdaQuery().eq(OrderMall::getActivityId, id)
                .list()
                .stream().map(OrderMall::getOrderId).collect(
                        Collectors.toSet());
        List<Order> list = this.lambdaQuery().in(Order::getId, orderIdSet)
        List<Order> list = this.lambdaQuery().eq(Order::getId, id)
                .in(Order::getOrderStatus, OrderStatusEnum.TO_BE_SHIPPED,
                        OrderStatusEnum.GOODS_TO_BE_RECEIVED, OrderStatusEnum.FINISHED).list();
        return list.stream().map(Order::getGoodsQuantity).reduce(0, Integer::sum);
@@ -90,4 +211,579 @@
    public List<Order> getOrderByGroupPurchaseId(Long id) {
        return baseMapper.getOrderByGroupPurchaseId(id);
    }

    @Override
    public Order getOrderByGroupPurchaseMemberId(HomeGoodsSkuDTO homeGoodsSkuDTO) {
        return baseMapper.getOrderByGroupPurchaseMemberId(homeGoodsSkuDTO);
    }

    @Override
    public List<OrderVO> getOrderByGroupPurchaseMemberList(HomeGoodsSkuDTO homeGoodsSkuDTO) {
        return baseMapper.getOrderByGroupPurchaseMemberList(homeGoodsSkuDTO);
    }

    @Override
    @Synchronized
    public MemberTiOrderVO saveMemberOrder(MemberOrderDTO memberOrderDTO) {

        MemberTiOrderVO memberOrderVO=new MemberTiOrderVO();
        BigDecimal pice=new BigDecimal(0);

        Order order=new Order();
        if (memberOrderDTO.getOrderFrom()==1){
            order.setOrderFrom(OrderFromEnum.COMMODITY_ORDER);
            order.setOrderNo(OrderUtil.getOrderNoForPrefix("SP"));
        }
        if (memberOrderDTO.getOrderFrom()==2){
            order.setOrderFrom(OrderFromEnum.SNAP_ORDERS);
            order.setOrderNo(OrderUtil.getOrderNoForPrefix("MS"));
        }
        if (memberOrderDTO.getOrderFrom()==3){
            order.setOrderFrom(OrderFromEnum.GROUP_PURCHASE_ORDERS);
            order.setOrderNo(OrderUtil.getOrderNoForPrefix("TG"));
        }
        if (memberOrderDTO.getPaymentMethod()==1){
            order.setPaymentMethod(PaymentMethodEnum.WECHAT);
        }if (memberOrderDTO.getPaymentMethod()==2){
            order.setPaymentMethod(PaymentMethodEnum.ALIPAY);
        }

        if (memberOrderDTO.getOrderFrom()==1){
            GoodsSku goodsSku = goodsSkuClient.getGoodsSkuOne(memberOrderDTO.getGoodsSkuId(), SecurityConstants.INNER).getData();
            if (goodsSku.getStock()<memberOrderDTO.getGoodsQuantity()){
                throw new ServiceException("对不起，购买数大于库存");
            }else{
                GoodsStockUpdDTO goodsStockUpdDTO = new GoodsStockUpdDTO();
                goodsStockUpdDTO.setGoodsSkuId(goodsSku.getId());
                goodsStockUpdDTO.setAuctionStock(memberOrderDTO.getGoodsQuantity()*-1);
                goodsSkuClient.updGoodsStock(Lists.newArrayList(goodsStockUpdDTO),
                        SecurityConstants.INNER);

                order.setSkuName(goodsSku.getSkuName());
                order.setPrice(goodsSku.getPrice());
                order.setCoverPic(goodsSku.getCoverPic());
            }
            memberOrderVO.setGoodsSkuId(memberOrderDTO.getGoodsSkuId());
            memberOrderVO.setPrice(goodsSku.getPrice());
            memberOrderVO.setCoverPic(goodsSku.getCoverPic());
            memberOrderVO.setSkuName(goodsSku.getSkuName());
            pice=goodsSku.getPrice();
        }
        if (memberOrderDTO.getOrderFrom()==2){
            GoodsSeckill data = goodsSkuClient.getGoodsSeckillOne(memberOrderDTO.getGoodsSkuId(), SecurityConstants.INNER).getData();
      /*      String goodsLock = "goods_lock_" + CacheConstants.SECKILL_GOODS + data.getId();
            RLock redissonLock = redissonClient.getLock(goodsLock);
            Integer surpNum = 0;
            try {
                redissonLock.lock(30, TimeUnit.SECONDS);
                surpNum = redisService.getCacheObject(CacheConstants.SECKILL_GOODS + data.getId());
                if (surpNum == null || surpNum < memberOrderDTO.getGoodsQuantity()) {
                    throw new ServiceException("商品已被抢完");
                }

            }catch (Exception e){
                throw new ServiceException("reids 出错");
            }*/
            order.setOrderFrom(OrderFromEnum.SNAP_ORDERS);

            GoodsSku goodsSku = goodsSkuClient.getGoodsSkuOne(data.getGoodsSkuId(), SecurityConstants.INNER).getData();
            memberOrderVO.setGoodsSkuId(memberOrderDTO.getGoodsSkuId());
            memberOrderVO.setPrice(goodsSku.getPrice());
            memberOrderVO.setCoverPic(goodsSku.getCoverPic());
            memberOrderVO.setSkuName(goodsSku.getSkuName());
            memberOrderVO.setYouhiPrice(data.getSeckillPrice());
            pice=data.getSeckillPrice();

            if (data.getSeckillStock()<memberOrderDTO.getGoodsQuantity()){
                throw new ServiceException("对不起，购买数大于库存");
            }else{
                GoodsStockUpdDTO goodsStockUpdDTO = new GoodsStockUpdDTO();
                goodsStockUpdDTO.setGoodsSkuId(goodsSku.getId());
                goodsStockUpdDTO.setAuctionStock(data.getSeckillStock()-memberOrderDTO.getGoodsQuantity());
                goodsSkuClient.updGoodsSeckill(goodsStockUpdDTO,SecurityConstants.INNER);

            }
            order.setSkuName(goodsSku.getSkuName());
            order.setPrice(data.getSeckillPrice());
            order.setCoverPic(goodsSku.getCoverPic());
            /*redisService.setCacheObject(CacheConstants.SECKILL_GOODS + data.getId(), surpNum - memberOrderDTO.getGoodsQuantity());*/
        }
        if (memberOrderDTO.getOrderFrom()==3){
            order.setOrderFrom(OrderFromEnum.GROUP_PURCHASE_ORDERS);
            GoodsGroupPurchase data = goodsSkuClient.getGoodsSeckiGoodsGroupPurchaseOne(memberOrderDTO.getGoodsSkuId(), SecurityConstants.INNER).getData();
            GoodsSku goodsSku = goodsSkuClient.getGoodsSkuOne(data.getGoodsSkuId(), SecurityConstants.INNER).getData();
            memberOrderVO.setGoodsSkuId(memberOrderDTO.getGoodsSkuId());
            memberOrderVO.setPrice(goodsSku.getPrice());
            memberOrderVO.setCoverPic(goodsSku.getCoverPic());
            memberOrderVO.setSkuName(goodsSku.getSkuName());
            memberOrderVO.setYouhiPrice(data.getGroupPurchasePrice());
            pice=data.getGroupPurchasePrice();

            order.setSkuName(goodsSku.getSkuName());
            order.setPrice(data.getGroupPurchasePrice());
            order.setCoverPic(goodsSku.getCoverPic());
        }
        order.setMemberId(memberOrderDTO.getMemberId());
        order.setGoodsQuantity(memberOrderDTO.getGoodsQuantity());
        order.setOrderTime(LocalDateTime.now());
        order.setGoodsQuantity(memberOrderDTO.getGoodsQuantity());
        order.setTotalAmount(pice.multiply(new BigDecimal(memberOrderDTO.getGoodsQuantity())));
        CustomConfig memberPointsMoney = sysUserClient.getconfig("MEMBER_POINTS_MONEY").getData();
        CustomConfig memberPointsPoints = sysUserClient.getconfig("MEMBER_POINTS_POINTS").getData();

       BigDecimal pic=pice.multiply(new BigDecimal(memberOrderDTO.getGoodsQuantity()));
       Double aDouble= Double.valueOf(memberPointsMoney.getConfigValue()) * Double.valueOf(memberPointsPoints.getConfigValue());
       BigDecimal pi=pic.multiply(new BigDecimal(aDouble));
        order.setPoints(pi.intValue());
        order.setOrderStatus(OrderStatusEnum.TO_PLAY);

        if (memberOrderDTO.getOrderFrom()==3){
            order.setReceiverName(memberOrderDTO.getReceiverName());
            order.setReceiverCity(memberOrderDTO.getReceiverCity());
            order.setReceiverDetailAddress(memberOrderDTO.getReceiverDetailAddress());
            order.setReceiverphone(memberOrderDTO.getReceiverphone());
        }else{
            MemberAddress data = memberClient.getMemberAddressOne(
                    memberOrderDTO.getMemberId(), SecurityConstants.INNER).getData();
            if (StringUtils.isNotNull(data)) {
                order.setReceiverName(data.getRecipientName());
                order.setReceiverCity(data.getReceiverCity());
                order.setReceiverDetailAddress(data.getDetailedAddress());
                order.setReceiverphone(data.getRecipientPhone());
            }
        }

        order.setGoodsSkuId(memberOrderDTO.getGoodsSkuId());
        baseMapper.insert(order);

        memberOrderVO.setId(order.getId());
        memberOrderVO.setOrderStatus(OrderStatusEnum.TO_PLAY);
        memberOrderVO.setOrderNo(order.getOrderNo());
        memberOrderVO.setGoodsSkuId(memberOrderDTO.getGoodsSkuId());
        memberOrderVO.setOrderTime(order.getOrderTime());
        memberOrderVO.setOrderFrom(order.getOrderFrom());
        memberOrderVO.setMemberId(memberOrderDTO.getMemberId());
        memberOrderVO.setPaymentMethod(order.getPaymentMethod());
        memberOrderVO.setTotalAmount(order.getTotalAmount());
        memberOrderVO.setOrderStatus(order.getOrderStatus());
        memberOrderVO.setGoodsQuantity(order.getGoodsQuantity());
        memberOrderVO.setReceiverName(order.getReceiverName());
        memberOrderVO.setReceiverCity(order.getReceiverCity());
        memberOrderVO.setReceiverDetailAddress(order.getReceiverDetailAddress());
        memberOrderVO.setReceiverphone(order.getReceiverphone());
        Integer delayTime = 30;
        redisService.setCacheObject(CacheConstants.ORDER_AUTOMATIC_CANCEL + "-" + order.getId(), order.getId() , delayTime.longValue(), TimeUnit.MINUTES);

        return memberOrderVO;
    }

    @Override
    public MemberTiOrderVO updMemberOrder(MemberOrderDTO memberOrderDTO) {
        Order order = baseMapper.selectById(memberOrderDTO.getId());
        MemberTiOrderVO memberOrderVO=new MemberTiOrderVO();
        if (memberOrderDTO.getReceiverDetailAddress()!=null){
            order.setReceiverName(memberOrderDTO.getReceiverName());
            order.setReceiverCity(memberOrderDTO.getReceiverCity());
            order.setReceiverDetailAddress(memberOrderDTO.getReceiverDetailAddress());
            order.setReceiverphone(memberOrderDTO.getReceiverphone());
        }
        if (memberOrderDTO.getOrderRemark()!=null){
            order.setOrderRemark(memberOrderDTO.getOrderRemark());
        }if (memberOrderDTO.getGoodsQuantity()!=null){
            if (order.getOrderFrom().getCode()==1){
                GoodsSku goodsSku = goodsSkuClient.getGoodsSkuOne(memberOrderDTO.getGoodsSkuId(), SecurityConstants.INNER).getData();
                if (goodsSku.getStock()<memberOrderDTO.getGoodsQuantity()){
                    throw new ServiceException("对不起，购买数大于库存");
                }else{
                    GoodsStockUpdDTO goodsStockUpdDTO = new GoodsStockUpdDTO();
                    goodsStockUpdDTO.setGoodsSkuId(goodsSku.getId());
                    goodsStockUpdDTO.setAuctionStock(order.getGoodsQuantity()*1);
                    goodsSkuClient.updGoodsStock(Lists.newArrayList(goodsStockUpdDTO),
                            SecurityConstants.INNER);

                    GoodsStockUpdDTO goodsStockUpdDTO1 = new GoodsStockUpdDTO();
                    goodsStockUpdDTO1.setGoodsSkuId(goodsSku.getId());
                    goodsStockUpdDTO1.setAuctionStock(memberOrderDTO.getGoodsQuantity()*-1);
                    goodsSkuClient.updGoodsStock(Lists.newArrayList(goodsStockUpdDTO),
                            SecurityConstants.INNER);

                    order.setTotalAmount(goodsSku.getPrice().multiply(new BigDecimal(memberOrderDTO.getGoodsQuantity())));
                    memberOrderVO.setGoodsSkuId(memberOrderDTO.getGoodsSkuId());
                    memberOrderVO.setPrice(goodsSku.getPrice());
                    memberOrderVO.setCoverPic(goodsSku.getCoverPic());
                    memberOrderVO.setSkuName(goodsSku.getSkuName());
                }

            }
            if (order.getOrderFrom().getCode()==2){
                MemberOrderDTO memberOrderDTO1=new MemberOrderDTO();
                memberOrderDTO1.setMemberId(memberOrderDTO.getMemberId());
                memberOrderDTO1.setGoodsSkuId(memberOrderDTO.getGoodsSkuId());
                Integer num=baseMapper.getSeckillMembers1(memberOrderDTO1);
                GoodsSeckill data = goodsSkuClient.getGoodsSeckillOne(memberOrderDTO.getGoodsSkuId(), SecurityConstants.INNER).getData();
                GoodsSku goodsSku = goodsSkuClient.getGoodsSkuOne(memberOrderDTO.getGoodsSkuId(), SecurityConstants.INNER).getData();
                if (data.getLimitNumber()<=num){
                    throw new ServiceException("对不起，大于商品购买数");
                }else{
                    if (data.getSeckillStock()<memberOrderDTO.getGoodsQuantity()){
                        throw new ServiceException("对不起，购买数大于库存");
                    }else{
                    GoodsStockUpdDTO goodsStockUpdDTO = new GoodsStockUpdDTO();
                    goodsStockUpdDTO.setGoodsSkuId(data.getId());
                    goodsStockUpdDTO.setAuctionStock(data.getSeckillStock()+order.getGoodsQuantity());
                    goodsSkuClient.updGoodsSeckill(goodsStockUpdDTO,SecurityConstants.INNER);

                    GoodsStockUpdDTO goodsStockUpdDTO1 = new GoodsStockUpdDTO();
                    goodsStockUpdDTO1.setGoodsSkuId(data.getId());
                    goodsStockUpdDTO1.setAuctionStock(data.getSeckillStock()-memberOrderDTO.getGoodsQuantity());
                    goodsSkuClient.updGoodsSeckill(goodsStockUpdDTO,SecurityConstants.INNER);

                    order.setTotalAmount(data.getSeckillPrice().multiply(new BigDecimal(memberOrderDTO.getGoodsQuantity())));

                }
            }
                memberOrderVO.setGoodsSkuId(memberOrderDTO.getGoodsSkuId());
                memberOrderVO.setPrice(goodsSku.getPrice());
                memberOrderVO.setCoverPic(goodsSku.getCoverPic());
                memberOrderVO.setSkuName(goodsSku.getSkuName());
                memberOrderVO.setYouhiPrice(data.getSeckillPrice());
        }
        }

        if (memberOrderDTO.getCouponId()!=null){
            CouponMemberDTO couponMemberDTO=new CouponMemberDTO();
            couponMemberDTO.setId(memberOrderDTO.getCouponId());
            CouponMember data = promotionClient.getCouponMember(couponMemberDTO, SecurityConstants.INNER).getData();


            if (order.getCouponId()!=null){
                CouponMemberDTO couponMemberDTO1=new CouponMemberDTO();
                couponMemberDTO1.setId(memberOrderDTO.getCouponId());
                couponMemberDTO1.setCouponStatus(1);
                promotionClient.updCouponMember(couponMemberDTO1, SecurityConstants.INNER);
            }

            BigDecimal pice=new BigDecimal(0);
            if (data.getCouponType().getCode()==1){
                pice= order.getTotalAmount();
                if (pice.doubleValue()>=data.getFullReductionAmount().doubleValue()){
                    pice.subtract(data.getReductionAmount());
                    order.setDiscountMoney(data.getReductionAmount());
                }
            }
            if (data.getCouponType().getCode()==2){
                pice= order.getTotalAmount();
                pice.subtract(data.getVoucherAmount());
                order.setDiscountMoney(data.getVoucherAmount());
            }
            if (data.getCouponType().getCode()==3){
                pice= order.getTotalAmount();
                BigDecimal pice1=new BigDecimal(data.getDiscountRate());
                BigDecimal pice2=new BigDecimal(0.1);
                BigDecimal pice3=pice.multiply(pice1.multiply(pice2));
                BigDecimal pice4= pice.subtract(pice3);
               if (pice4.doubleValue()>data.getMaxDiscount().doubleValue()){
                   pice=pice.subtract(data.getMaxDiscount());
                   order.setDiscountMoney(data.getMaxDiscount());
               }else{
                   order.setDiscountMoney(pice4);
                   pice=pice3;
               }

            }
            order.setCouponId(memberOrderDTO.getCouponId());
            CouponMemberDTO couponMemberDTO2=new CouponMemberDTO();
            couponMemberDTO2.setId(memberOrderDTO.getCouponId());
            couponMemberDTO2.setCouponStatus(2);
            promotionClient.updCouponMember(couponMemberDTO2, SecurityConstants.INNER);

            order.setTotalAmount(pice);

            CustomConfig memberPointsMoney = sysUserClient.getconfig("MEMBER_POINTS_MONEY").getData();
            CustomConfig memberPointsPoints = sysUserClient.getconfig("MEMBER_POINTS_POINTS").getData();

            BigDecimal pic=pice.multiply(new BigDecimal(memberOrderDTO.getGoodsQuantity()));
            Double aDouble= Double.valueOf(memberPointsMoney.getConfigValue()) * Double.valueOf(memberPointsPoints.getConfigValue());
            BigDecimal pi=pic.multiply(new BigDecimal(aDouble));
            order.setPoints(pi.intValue());

        }

        baseMapper.updateById(order);

        memberOrderVO.setId(order.getId());
        memberOrderVO.setOrderStatus(OrderStatusEnum.TO_PLAY);
        memberOrderVO.setOrderNo(order.getOrderNo());
        memberOrderVO.setGoodsSkuId(memberOrderDTO.getGoodsSkuId());
        memberOrderVO.setOrderTime(order.getOrderTime());
        memberOrderVO.setOrderFrom(order.getOrderFrom());
        memberOrderVO.setMemberId(memberOrderDTO.getMemberId());
        memberOrderVO.setPaymentMethod(order.getPaymentMethod());
        memberOrderVO.setTotalAmount(order.getTotalAmount());
        memberOrderVO.setOrderStatus(order.getOrderStatus());
        memberOrderVO.setGoodsQuantity(order.getGoodsQuantity());
        memberOrderVO.setReceiverName(order.getReceiverName());
        memberOrderVO.setReceiverCity(order.getReceiverCity());
        memberOrderVO.setReceiverDetailAddress(order.getReceiverDetailAddress());
        memberOrderVO.setReceiverphone(order.getReceiverphone());
        memberOrderVO.setYouhiPrice(order.getDiscountMoney());

        return memberOrderVO;
    }

    @Override
    public PageDTO<MemberOrderListVO> MemberrderList(MemberOrderListDTO memberOrderListDTO) {
        Page<Order> page = new Page<>(memberOrderListDTO.getPageCurr(), memberOrderListDTO.getPageSize());
        LambdaQueryWrapper<Order> wrapper= Wrappers.lambdaQuery();
        wrapper.eq(Order::getMemberId,memberOrderListDTO.getMemberId());
        wrapper.like(Order::getSkuName,memberOrderListDTO.getGoodsSkuName());
        wrapper.like(Order::getOrderNo,memberOrderListDTO.getOrderNo());
        wrapper.eq(Order::getOrderStatus,memberOrderListDTO.getOrderStatus());
        wrapper.eq(Order::getDelFlag,0);
        wrapper.orderByDesc(Order::getCancelTime);
        Page<Order> page1 = this.page(page, wrapper);

        PageDTO<MemberOrderListVO> memberOrderListVOPageDTO = PageDTO.of(page1, MemberOrderListVO.class);
        return memberOrderListVOPageDTO;
    }

    @Override
    public OrderVO MemberOrderOne(MemberOrderListDTO memberOrderListDTO) {
        Order order = baseMapper.selectById(memberOrderListDTO.getId());
        OrderVO orderVO=new OrderVO();
        try {
            orderVO = BeanUtils.copyBean(order, OrderVO.class);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return orderVO;
    }

    @Override
    public void CancelOrderOne(MemberOrderListDTO memberOrderListDTO) {
        Order order = baseMapper.selectById(memberOrderListDTO.getId());
        if (order.getOrderStatus().getCode()==1){
            order.setOrderStatus(OrderStatusEnum.CANCELED);
            order.setCancelTime(LocalDateTime.now());
            baseMapper.updateById(order);
        }
        if (order.getOrderStatus().getCode()==2) {
            order.setOrderStatus(OrderStatusEnum.CANCELED);
            order.setCancelTime(LocalDateTime.now());
            baseMapper.updateById(order);

            updMembeOneDTO MembeOneDTO=new updMembeOneDTO();
            MembeOneDTO.setType(2);
            MembeOneDTO.setMemberId(order.getMemberId());
            MembeOneDTO.setMoney(order.getTotalAmount());
            MembeOneDTO.setTotalPoints(order.getPoints());
            memberClient.updMembeOne(MembeOneDTO);


            if (order.getPaymentMethod() != null && order.getPaymentMethod().getCode() == 1) {//支付宝
                //获取支付信息
                LambdaQueryWrapper<Paylog> paylogEntityWrapper = Wrappers.lambdaQuery();
                paylogEntityWrapper.eq(Paylog::getOutTradeNo, order.getOrderNo());
                Paylog paylog = iPaylogService.getOne(paylogEntityWrapper);
                boolean bo = paylogService.refundForAlipay(paylog.getOutTradeNo(), paylog.getTradeNo(), paylog.getPayMoney());
                if (!bo) {
                    System.out.println("支付宝退款失败");
                }
            } else if (order.getPaymentMethod() != null && order.getPaymentMethod().getCode() == 2) {//微信
                //获取支付信息
                LambdaQueryWrapper<Paylog> paylogEntityWrapper = Wrappers.lambdaQuery();
                paylogEntityWrapper.eq(Paylog::getOutTradeNo, order.getOrderNo());
                Paylog paylog = iPaylogService.getOne(paylogEntityWrapper);

                String refundMoney = SinataUtil.doubleRetainTwo(paylog.getPayMoney() * 100d);
                Integer refundFee = Integer.parseInt(refundMoney.substring(0, refundMoney.length() - 3));
                String money = SinataUtil.doubleRetainTwo(paylog.getPayMoney() * 100d);
                Integer totalFee = Integer.parseInt(money.substring(0, money.length() - 3));
                refundFee = 1;

                String regEx = "[^0-9]";
                Pattern p = Pattern.compile(regEx);
                Matcher m = p.matcher(order.getOrderNo());
                String ma = m.replaceAll("").trim();
                boolean bo = paylogService.refundForWxpay(4, paylog.getTradeNo(), paylog.getOutTradeNo(), "R" + ma, totalFee, refundFee, "2");
                if (!bo) {
                    System.out.println("微信退款失败");
                }
            }
        }}

    @Override
    public void AffirmOrderOne(MemberOrderListDTO memberOrderListDTO) {
        Order order = baseMapper.selectById(memberOrderListDTO.getId());
        if (order.getOrderFrom().getCode()==4){
            order.setOrderStatus(OrderStatusEnum.FINISHED);
            order.setReceiveTime(LocalDateTime.now());
            baseMapper.updateById(order);

            LambdaQueryWrapper<OrderAuctionBond> wrapper= Wrappers.lambdaQuery();
            wrapper.eq(OrderAuctionBond::getOrderId,order.getId());
            OrderAuctionBond orderAuctionBond = orderAuctionBondMapper.selectOne(wrapper);

            if (order.getPaymentMethod() != null && order.getPaymentMethod().getCode() == 1) {//支付宝
                //获取支付信息
                LambdaQueryWrapper<Paylog> paylogEntityWrapper = Wrappers.lambdaQuery();
                paylogEntityWrapper.eq(Paylog::getOutTradeNo, orderAuctionBond.getOrderNo());
                Paylog paylog = iPaylogService.getOne(paylogEntityWrapper);
                boolean bo = paylogService.refundForAlipay(paylog.getOutTradeNo(), paylog.getTradeNo(), paylog.getPayMoney());
                if (!bo) {
                    System.out.println("支付宝退款失败");
                }
            } else if (order.getPaymentMethod() != null && order.getPaymentMethod().getCode() == 2) {//微信
                //获取支付信息
                LambdaQueryWrapper<Paylog> paylogEntityWrapper = Wrappers.lambdaQuery();
                paylogEntityWrapper.eq(Paylog::getOutTradeNo, orderAuctionBond.getOrderNo());
                Paylog paylog = iPaylogService.getOne(paylogEntityWrapper);

                String refundMoney = SinataUtil.doubleRetainTwo(paylog.getPayMoney() * 100d);
                Integer refundFee = Integer.parseInt(refundMoney.substring(0, refundMoney.length() - 3));
                String money = SinataUtil.doubleRetainTwo(paylog.getPayMoney() * 100d);
                Integer totalFee = Integer.parseInt(money.substring(0, money.length() - 3));
                refundFee = 1;

                String regEx = "[^0-9]";
                Pattern p = Pattern.compile(regEx);
                Matcher m = p.matcher(order.getOrderNo());
                String ma = m.replaceAll("").trim();
                boolean bo = paylogService.refundForWxpay(4, paylog.getTradeNo(), paylog.getOutTradeNo(), "R" + ma, totalFee, refundFee, "2");
                if (!bo) {
                    System.out.println("微信退款失败");
                }
            }
        }else{
            order.setOrderStatus(OrderStatusEnum.FINISHED);
            order.setReceiveTime(LocalDateTime.now());
            baseMapper.updateById(order);
        }
    }

    /**
     * 根据优惠券id集合查询订单列表
     *
     * @param couponIds 优惠券id集合
     * @return List<Order>
     */
    @Override
    public List<Order> getOrderByCouponIds(Collection<Long> couponIds) {
        return this.lambdaQuery().in(Order::getCouponId, couponIds)
                .eq(Order::getOrderStatus, OrderStatusEnum.FINISHED).list();
    }

    /**
     * 商城订单分页列表
     *
     * @param query 商城订单查询对象
     * @return PageDTO<MgtMallOrderVO>
     */
    @Override
    public PageDTO<MgtMallOrderVO> getMallOrderPage(MgtMallOrderQuery query) {
        PageDTO<MgtMallOrderVO> pageVO;
        // 封装会员条件查询对象
        MemberDTO memberDTO = null;
        Set<Long> memberIdSet = null;
        Page<Order> page = new Page<>(query.getPageCurr(), query.getPageSize());
        if (StringUtils.isNotBlank(query.getNickname()) || StringUtils.isNotBlank(
                query.getPhone())) {
            memberDTO = new MemberDTO();
            memberDTO.setNickname(query.getNickname());
            memberDTO.setPhone(query.getPhone());
        }
        if (StringUtils.isNotNull(memberDTO)) {
            // 远程调用会员服务进行条件查询
            List<Member> memberList = memberClient.getMemberListByCondition(memberDTO,
                    SecurityConstants.INNER).getData();
            if (StringUtils.isEmpty(memberList)) {
                return PageDTO.empty(page);
            }
            memberIdSet = memberList.stream().map(Member::getId)
                    .collect(Collectors.toSet());
        }
        page = this.lambdaQuery()
                .in(StringUtils.isNotEmpty(memberIdSet), Order::getMemberId, memberIdSet)
                .like(StringUtils.isNotBlank(query.getOrderNo()), Order::getOrderNo,
                        query.getOrderNo())
                .eq(StringUtils.isNotNull(query.getOrderFrom()), Order::getOrderFrom,
                        query.getOrderFrom())
                .like(StringUtils.isNotBlank(query.getSkuName()), Order::getSkuName,
                        query.getSkuName())
                .eq(StringUtils.isNotNull(query.getOrderStatus()), Order::getOrderStatus,
                        query.getOrderStatus())
                .page(new Page<>(query.getPageCurr(), query.getPageSize()));
        if (StringUtils.isEmpty(page.getRecords())) {
            pageVO = PageDTO.empty(page);
        }
        pageVO = PageDTO.of(page, MgtMallOrderVO.class);
        return pageVO;
    }

    /**
     * 获取商城订单详情
     *
     * @param id 订单id
     * @return MgtMallOrderVO
     */
    @Override
    public MgtMallOrderVO getMallOrderDetail(Long id) {
        Order order = this.getById(id);
        MgtMallOrderVO mgtMallOrderVO = BeanUtils.copyBean(order, MgtMallOrderVO.class);
        // 查询用户信息
        Member member = memberClient.getMembeOne(order.getMemberId(), SecurityConstants.INNER)
                .getData();
        if (StringUtils.isNotNull(member)) {
            mgtMallOrderVO.setNickname(member.getNickname());
            mgtMallOrderVO.setPhone(member.getPhone());
        }
        // 查询售后信息
        if (order.getOrderStatus() == OrderStatusEnum.AFTER_SALE) {
            OrderReturnRequest orderReturnRequest = orderReturnRequestService.getOne(
                    Wrappers.lambdaQuery(OrderReturnRequest.class)
                            .eq(OrderReturnRequest::getOrderId,
                                    order.getId()).last("limit 1"));
            if (StringUtils.isNotNull(orderReturnRequest)) {
                mgtMallOrderVO.setReturnRequestVO(BeanUtils.copyBean(orderReturnRequest,
                        MgtOrderReturnRequestVO.class));
            }
        }
        return mgtMallOrderVO;
    }

    /**
     * 确认发货
     *
     * @param dto 确认收货请求对象
     */
    @Override
    public void confirmShipmentOrder(MgtOrderConfirmShipmentDTO dto) {
        Order order = this.getById(dto.getId());
        if (StringUtils.isNull(order)) {
            throw new ServiceException("订单不存在");
        }
        order.setOrderStatus(OrderStatusEnum.GOODS_TO_BE_RECEIVED);
        order.setDeliveryTime(LocalDateTime.now());
        order.setCourierNumber(dto.getCourierNumber());
        order.setLogisticsNum(dto.getLogisticsNum());
        this.updateById(order);
    }

    /**
     * 已收货
     *
     * @param id 订单id
     */
    @Override
    public void receivedGoods(Long id) {
        Order order = this.getById(id);
        if (StringUtils.isNull(order)) {
            throw new ServiceException("订单不存在");
        }
        if (order.getOrderStatus() == OrderStatusEnum.GOODS_TO_BE_RECEIVED) {
            order.setOrderStatus(OrderStatusEnum.FINISHED);
            order.setReceiveTime(LocalDateTime.now());
            this.updateById(order);
        }
    }
}