修改bug

puzhibing

1 天以前 6058af744bdf4fe6a3856c46fe31cfb4dbd8e255

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

@@ -17,6 +17,12 @@
import com.github.binarywang.wxpay.service.WxPayService;
import com.google.common.collect.Lists;
import com.google.gson.Gson;
import com.kuaishou.locallife.open.api.domain.locallife_order.OpenApiOrderAmountV1;
import com.kuaishou.locallife.open.api.domain.locallife_order.OpenApiQueryOrderDetailInfoV1;
import com.kuaishou.locallife.open.api.domain.locallife_trade.SimpleCertificateTimesCard;
import com.kuaishou.locallife.open.api.domain.locallife_trade.SkuTImesCard;
import com.kuaishou.locallife.open.api.domain.locallife_trade.VerifyPrepareDataNew;
import com.kuaishou.locallife.open.api.domain.locallife_trade.VerifyResult;
import com.ruoyi.common.core.constant.CacheConstants;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.enums.UserStatus;
@@ -52,6 +58,8 @@
import com.ruoyi.order.util.HuiFuTianXiaUtil;
import com.ruoyi.order.util.douyin.OrderUtil;
import com.ruoyi.order.util.douyin.VerifyUtil;
import com.ruoyi.order.util.kuaishou.KSOrderUtil;
import com.ruoyi.order.util.kuaishou.KSVerifyUtil;
import com.ruoyi.system.api.constant.AppErrorConstant;
import com.ruoyi.system.api.constant.DelayTaskEnum;
import com.ruoyi.system.api.constant.SecurityConstant;
@@ -84,6 +92,9 @@
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.TimeUnit;
@@ -391,6 +402,17 @@
        appSureOrderVo.setOrderPayMoney(orderPayMoney);
        // 设置订单商品列表
        appSureOrderVo.setAppSureOrderGoodsVoList(appSureOrderGoodsVoList);
        appSureOrderVo.setLotteryDraw(false);
        // 返回AppPlaceOrderVo对象
        List<TLotteryEvent> data = lotteryEventClient.getLotteryEventList(2).getData();
        if (data.size() > 0) {
            BigDecimal finalOrderPayMoney = orderPayMoney;
            List<TLotteryEvent> collect = data.stream().filter(s -> s.getPayMoney().compareTo(finalOrderPayMoney) <= 0).collect(Collectors.toList());
            if (collect.size() > 0) {
                appSureOrderVo.setLotteryDraw(true);
                appSureOrderVo.setLotteryEventId(collect.get(0).getId());
            }
        }
        return appSureOrderVo;
    }

@@ -499,6 +521,17 @@
        appPanicBuyVo.setOrderGoodsMoney(orderGoodsMoney);
        appPanicBuyVo.setOrderPayDeposit(orderPayDeposit);
        appPanicBuyVo.setOrderPayMoney(orderPayMoney);
        appPanicBuyVo.setLotteryDraw(false);
        // 返回AppPlaceOrderVo对象
        List<TLotteryEvent> data = lotteryEventClient.getLotteryEventList(2).getData();
        if (data.size() > 0) {
            BigDecimal finalOrderPayMoney = orderPayMoney;
            List<TLotteryEvent> collect = data.stream().filter(s -> s.getPayMoney().compareTo(finalOrderPayMoney) <= 0).collect(Collectors.toList());
            if (collect.size() > 0) {
                appPanicBuyVo.setLotteryDraw(true);
                appPanicBuyVo.setLotteryEventId(collect.get(0).getId());
            }
        }
        return appPanicBuyVo;
    }

@@ -1494,7 +1527,7 @@
        appUserOrderGetVo.setCouponDiscount(order.getCouponMoney());
        appUserOrderGetVo.setReceivableDeposit(order.getReceivableDeposit());
        appUserOrderGetVo.setReceivableMoney(order.getReceivableMoney());
        appUserOrderGetVo.setUnpaidMoney(order.getReceivableMoney().subtract(order.getOnlinePayMoney()));
        appUserOrderGetVo.setUnpaidMoney(order.getReceivableMoney().subtract(null == order.getOnlinePayMoney() ? BigDecimal.ZERO : order.getOnlinePayMoney()));
        appUserOrderGetVo.setPayType(order.getPayType());
        appUserOrderGetVo.setPayMoney(order.getPayMoney());
        appUserOrderGetVo.setOrderRemark(order.getOrderRemark());
@@ -1514,6 +1547,7 @@
            delayTime = redisService.getCacheObject(SecurityConstant.AUTO_CANCEL_ORDER_TIME);
        }
        appUserOrderGetVo.setEndTime(DateUtils.addMinutes(order.getCreateTime(), delayTime));
        appUserOrderGetVo.setCancelType(order.getCancelType());
        return appUserOrderGetVo;
    }

@@ -1532,10 +1566,10 @@
            //删除待支付超时取消延时任务
            redisService.deleteObject(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + orderId);
            remoteConfigService.deleteDelayTask(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode()+"-"+orderId);
            this.autoCancelOrder(orderId);
            this.autoCancelOrder(orderId, 3);
        } else if (order.getOrderStatus() == 2) {
            // 2.待核销 -> 订单退款
            this.refundOrder(orderId);
            this.refundOrder(orderId, 3);
        } else {
            throw new ServiceException(AppErrorConstant.CANCEL_ERROR_ORDER);
        }
@@ -1589,16 +1623,15 @@
        appPlaceOrderVo.setSignType(payArr[4]);
        appPlaceOrderVo.setPaySign(payArr[5]);
        appPlaceOrderVo.setPrepayId(orderPayment.getPrepayId());
        appPlaceOrderVo.setLotteryDraw(false);
        // 返回AppPlaceOrderVo对象
        List<TLotteryEvent> data = lotteryEventClient.getLotteryEventList(2).getData();
        if (data.size() > 0) {
            List<TLotteryEvent> collect = data.stream().filter(s -> s.getPayMoney().compareTo(order.getPayMoney()) >= 0).collect(Collectors.toList());
            appPlaceOrderVo.setLotteryDraw(collect.size() > 0);
            List<TLotteryEvent> collect = data.stream().filter(s -> s.getPayMoney().compareTo(order.getPayMoney()) <= 0).collect(Collectors.toList());
            if (collect.size() > 0) {
                appPlaceOrderVo.setLotteryDraw(true);
                appPlaceOrderVo.setLotteryEventId(collect.get(0).getId());
            }
        } else {
            appPlaceOrderVo.setLotteryDraw(false);
        }
        return appPlaceOrderVo;
    }
@@ -1690,12 +1723,12 @@
        shopId = merHomeShopTotalVo.getShopId();
        
        //获取今日到店
        Integer todayShop = userServiceRecordService.countShopServicePerson(shopId);
        List<Integer> todayShop = userServiceRecordService.countShopServicePerson(shopId);
        //获取待处理订单和营业额
        merHomeShopTotalVo = orderMapper.getMerHomeShopTotalVo(shopId);
        //获取服务统计
        MerHomeShopTotalVo serviceTotalVo = orderMapper.getMerHomeShopServiceTotalVo(shopId);
        merHomeShopTotalVo.setTodayShop(todayShop);
        merHomeShopTotalVo.setTodayShop(todayShop.size());
        merHomeShopTotalVo.setCycleSurp(serviceTotalVo.getCycleSurp());
        merHomeShopTotalVo.setExplorationSurp(serviceTotalVo.getExplorationSurp());
        return merHomeShopTotalVo;
@@ -1867,13 +1900,55 @@
        // 设置返回对象的属性值
        merVerifyOrderVo.setOrderId(orderId);
        merVerifyOrderVo.setOrderFrom(6);
        merVerifyOrderVo.setOrderStatus(status.intValue() == 1 ? 2 : 3);
        merVerifyOrderVo.setOrderStatus((null == status || status.intValue() == 1) ? 2 : 3);
        List<AppUserOrderGoodsPageVo> appUserOrderGoodsPageVoList = new ArrayList<>();
        AppUserOrderGoodsPageVo orderGoodsPageVo = new AppUserOrderGoodsPageVo();
        orderGoodsPageVo.setGoodsName(sku.getTitle());
        appUserOrderGoodsPageVoList.add(orderGoodsPageVo);
        merVerifyOrderVo.setAppUserOrderGoodsPageVoList(appUserOrderGoodsPageVoList);
        merVerifyOrderVo.setLaveTime(timeCard.getTimesCount() - timeCard.getTimesUsed());
        if(null != timeCard){
            merVerifyOrderVo.setLaveTime(timeCard.getTimesCount() - timeCard.getTimesUsed());
        }else{
            merVerifyOrderVo.setLaveTime(-1);
        }
        // 返回结果
        return merVerifyOrderVo;
    }
    
    
    @Override
    public MerVerifyOrderVo verifyOrderKuaiShou(String orderId, Long shopId) {
        VerifyPrepareDataNew data = KSVerifyUtil.certificatePrepare(redisService, orderId);
        if (null == data) {
            throw new ServiceException("查询券信息失败");
        }
        List<SimpleCertificateTimesCard> itemList = data.getCertificates();
        if (null == itemList || itemList.isEmpty()) {
            throw new ServiceException("查询券信息失败");
        }
        SimpleCertificateTimesCard certificatesItem = itemList.get(0);
        Long expire_time = certificatesItem.getExpire_time();
        if(LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8")) > expire_time){
            throw new ServiceException("优惠券已过期");
        }
        //商品信息
        SkuTImesCard sku = certificatesItem.getSku();
        // 创建返回对象
        MerVerifyOrderVo merVerifyOrderVo = new MerVerifyOrderVo();
        // 设置返回对象的属性值
        merVerifyOrderVo.setOrderId(orderId);
        merVerifyOrderVo.setOrderFrom(7);
        merVerifyOrderVo.setOrderStatus(2);
        List<AppUserOrderGoodsPageVo> appUserOrderGoodsPageVoList = new ArrayList<>();
        AppUserOrderGoodsPageVo orderGoodsPageVo = new AppUserOrderGoodsPageVo();
        orderGoodsPageVo.setGoodsName(sku.getTitle());
        appUserOrderGoodsPageVoList.add(orderGoodsPageVo);
        merVerifyOrderVo.setAppUserOrderGoodsPageVoList(appUserOrderGoodsPageVoList);
        if(null != sku.getTimes_count()){
            merVerifyOrderVo.setLaveTime(sku.getTimes_count());
        }else{
            merVerifyOrderVo.setLaveTime(-1);
        }
        // 返回结果
        return merVerifyOrderVo;
    }
@@ -2140,27 +2215,43 @@
            throw new ServiceException("查询券信息失败");
        }
        List<CertificatePrepareResponseDataCertificatesItem> itemList = data.getCertificates();
        if (null == itemList || itemList.isEmpty()) {
        if (null == itemList && itemList.isEmpty()) {
            throw new ServiceException("查询券信息失败");
        }
        CertificatePrepareResponseDataCertificatesItem certificatesItem = itemList.get(0);
        //商品信息
        CertificatePrepareResponseDataCertificatesItemSku sku = certificatesItem.getSku();
        //次卡信息
        CertificatePrepareResponseDataCertificatesItemTimeCard timeCard = certificatesItem.getTimeCard();
        Number status = certificatesItem.getStatus();
        if (status.intValue() == 2) {
        if (null != status && status.intValue() == 2) {
            throw new ServiceException("该抖音券不能重复核销");
        }
        if (status.intValue() != 1) {
        if (null != status && status.intValue() != 1) {
            throw new ServiceException("抖音券核销失败");
        }
        Member member = remoteMemberService.getMemberByMobile(phone).getData();//绑定用户判断核销商户
        if(null == member){
            throw new ServiceException("手机号还未注册账户，请先进行注册");
        }
        if (member.getBindingFlag() == 1) {
            if (!member.getRelationShopId().equals(shopId)) {
                throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
            }
        }
        //不是次卡才校验是否重复核销
        if(null == timeCard){
            Order one = this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getTripartiteOrderId, data.getOrderId()));
            if (null != one) {
                throw new ServiceException("该抖音券不能重复核销");
            }
        }
        String encryptedCode = certificatesItem.getEncryptedCode();
        List<CertificateVerifyResponseDataVerifyResultsItem> items = VerifyUtil.certificateVerify(data.getVerifyToken(), shop.getPoiId(), new ArrayList<String>() {{
        List<CertificateVerifyResponseDataVerifyResultsItem> items = VerifyUtil.certificateVerify(data.getVerifyToken(), shop.getDyPoiId(), new ArrayList<String>() {{
            add(encryptedCode);
        }});
        if (null == items || items.isEmpty()) {
            throw new ServiceException("抖音券核销失败");
        }
        Order one = this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getTripartiteOrderId, data.getOrderId()));
        if (null != one) {
            throw new ServiceException("该抖音券不能重复核销");
        }
        
        TradeOrderQueryResponseData tradeOrderQueryResponseData = OrderUtil.queryOrderList(1, 10, data.getOrderId());
@@ -2170,159 +2261,481 @@
        BigDecimal payAmount = BigDecimal.ZERO;
        //优惠金额
        BigDecimal payDiscountAmount = BigDecimal.ZERO;
        Long createOrderTime = LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8"));
        Long payTime = LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8"));
        if (null != tradeOrderQueryResponseData) {
            TradeOrderQueryResponseDataOrdersItem ordersItem = tradeOrderQueryResponseData.getOrders().get(0);
            TradeOrderQueryResponseDataOrdersItemAmountInfo amountInfo = ordersItem.getAmountInfo();
            originAmount = BigDecimal.valueOf(amountInfo.getOriginAmount()).divide(new BigDecimal(100));
            payAmount = BigDecimal.valueOf(amountInfo.getPayAmount()).divide(new BigDecimal(100));
            payDiscountAmount = BigDecimal.valueOf(amountInfo.getPayDiscountAmount()).divide(new BigDecimal(100));
            originAmount = BigDecimal.valueOf(ordersItem.getOriginalAmount()).divide(new BigDecimal(100));
            payAmount = BigDecimal.valueOf(ordersItem.getPayAmount()).divide(new BigDecimal(100));
            payDiscountAmount = BigDecimal.valueOf(ordersItem.getDiscountAmount()).divide(new BigDecimal(100));
            createOrderTime = ordersItem.getCreateOrderTime();
            payTime = ordersItem.getPayTime();
        }
        
        Date nowTime = new Date();
        Member member = remoteMemberService.getMemberByMobile(phone).getData();
        //开始添加订单数据
        Order order = new Order();
        order.setOrderId(IdUtils.fastSimpleUUID());
        order.setDelFlag(0);
        order.setOrderStatus(3);
        order.setOrderNo(CodeFactoryUtil.getShopOrderNo());
        order.setOrderFrom(6);
        order.setShopId(shopId);
        order.setUserId(member.getUserId());
        order.setOrderMoney(originAmount);
        order.setDiscountMoney(payDiscountAmount);
        order.setReceivableMoney(payAmount);
        order.setPayType(1);
        order.setPayMoney(payAmount);
        order.setOnlinePayMoney(payAmount);
        order.setOrderRemark("抖音订单");
        order.setCreateTime(nowTime);
        order.setPayTime(nowTime);
        order.setTripartiteOrderId(data.getOrderId());
        
        Order order = this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getTripartiteOrderId, data.getOrderId()));
        if(null == order){
            order = new Order();
            order.setOrderId(IdUtils.fastSimpleUUID());
            order.setDelFlag(0);
            order.setOrderStatus(3);
            order.setOrderNo(CodeFactoryUtil.getShopOrderNo());
            order.setOrderFrom(6);
            order.setShopId(shopId);
            order.setUserId(member.getUserId());
            order.setOrderMoney(originAmount);
            order.setDiscountMoney(payDiscountAmount);
            order.setReceivableMoney(payAmount);
            order.setPayType(1);
            order.setPayMoney(payAmount);
            order.setOnlinePayMoney(payAmount);
            order.setOrderRemark("抖音订单");
            order.setCreateTime(new Date(createOrderTime * 1000));
            order.setPayTime(new Date(payTime * 1000));
            order.setTripartiteOrderId(data.getOrderId());
            order.setUseTime(nowTime);
            order.setUseUserId(merVerifyOrderDto.getUserId());
            order.setCloseFlag(1);
            order.setGoodsNum(1);
            order.setCouponMoney(BigDecimal.ZERO);
            this.save(order);
            //创建服务商品
            //获取商品信息(商品简介,调理问题)

            OrderGoods orderGoods = new OrderGoods();
            orderGoods.setOrderGoodsId(IdUtils.simpleUUID());
            orderGoods.setDelFlag(0);
            orderGoods.setOrderId(order.getOrderId());

            ConsumerGoods consumerGoods = new ConsumerGoods();
            if(null != timeCard){
                orderGoods.setBuyNum(timeCard.getTimesCount());
                orderGoods.setServiceNum(timeCard.getTimesCount());
                consumerGoods.setServiceNum(timeCard.getTimesCount());
                consumerGoods.setUsedNum(1);
                consumerGoods.setUseTime(new Date());
            }
            orderGoods.setCycleNumFlag(1);
            orderGoods.setGoodsType(2);
            orderGoods.setGoodsName(sku.getTitle());
            orderGoodsService.save(orderGoods);

            consumerGoods.setConsumerGoodsId(IdUtils.simpleUUID());
            consumerGoods.setDelFlag(0);
            consumerGoods.setServiceStatus(1);
            consumerGoods.setShopId(order.getShopId());
            consumerGoods.setUserId(order.getUserId());
            consumerGoods.setOrderId(orderId);
            consumerGoods.setOrderGoodsId(orderGoods.getOrderGoodsId());
            consumerGoods.setGoodsName(sku.getTitle());
            consumerGoods.setCycleNumFlag(1);
            consumerGoods.setCreateTime(nowTime);
            consumerGoods.setGoodsType(2);
            consumerGoods.setSourceFrom(1);
            consumerGoodsService.save(consumerGoods);

            //生成返回
            MerVerifyOrderVo merVerifyOrderVo = new MerVerifyOrderVo();
            merVerifyOrderVo.setOrderId(orderId);
            merVerifyOrderVo.setOrderNo(order.getOrderNo());
            merVerifyOrderVo.setOrderStatus(order.getOrderStatus());
            merVerifyOrderVo.setOrderFrom(order.getOrderFrom());
            merVerifyOrderVo.setOrderGoodsMoney(order.getOrderMoney());
            merVerifyOrderVo.setCouponDiscount(order.getCouponMoney());
            merVerifyOrderVo.setReceivableDeposit(order.getReceivableDeposit());
            merVerifyOrderVo.setPayMoney(order.getPayMoney());
            merVerifyOrderVo.setOrderRemark(order.getOrderRemark());
            merVerifyOrderVo.setAppUserOrderGoodsPageVoList(new ArrayList<AppUserOrderGoodsPageVo>() {{
                add(new AppUserOrderGoodsPageVo() {{
                    setOrderGoodsId(orderGoods.getOrderGoodsId());
                    setGoodsName(orderGoods.getGoodsName());
                    setGoodsType(orderGoods.getGoodsType());
                    setBuyNum(orderGoods.getBuyNum());
                }});
            }});
            merVerifyOrderVo.setCreateTime(order.getCreateTime());
            merVerifyOrderVo.setPayTime(order.getPayTime());
            merVerifyOrderVo.setUseTime(order.getUseTime());
            merVerifyOrderVo.setPayType(order.getPayType());
            merVerifyOrderVo.setRealReceiveMoney(order.getChangeReceivableMoney());
            //根据支付方式返回应收金额和已收金额
            if (order.getPayType() == 1) {
                merVerifyOrderVo.setReceivableMoney(order.getOrderMoney().subtract(order.getPayMoney()));
                merVerifyOrderVo.setReceiveMoney(order.getPayMoney());
            } else {
                merVerifyOrderVo.setReceivableMoney(order.getOrderMoney().subtract(order.getCouponMoney()).subtract(order.getReceivableDeposit()));
                if (order.getOfflinePayMoney() != null) {
                    merVerifyOrderVo.setReceiveMoney(order.getOfflinePayMoney());
                } else {
                    merVerifyOrderVo.setReceiveMoney(BigDecimal.ZERO);
                }
            }
            merVerifyOrderVo.setUnReceiveMoney(BigDecimal.ZERO);
            merVerifyOrderVo.setUserId(order.getUserId());
            merVerifyOrderVo.setUserName(member.getRealName());
            merVerifyOrderVo.setUserMobile(member.getMobile());
            merVerifyOrderVo.setCloseFlag(order.getCloseFlag());
            //判断用户是否绑定  2023-09-05需求改变核销时绑定用户
            if (member.getBindingFlag() != 1) {
                //绑定商户
                AppMemberBindingDto appMemberBindingDto = new AppMemberBindingDto();
                appMemberBindingDto.setShopId(order.getShopId());
                appMemberBindingDto.setUserId(order.getUserId());
                appMemberBindingDto.setBindingFlag(1);
                if (order.getOrderFrom() == 1) {
                    appMemberBindingDto.setBindingType(1);
                } else if (order.getOrderFrom() == 2) {
                    appMemberBindingDto.setBindingType(2);
                }
                remoteMemberService.updateMemberBinding(appMemberBindingDto);
                order.setNewMemberFlag(1);
            } else {
                order.setNewMemberFlag(0);
            }
            this.saveOrUpdate(order);
            //更新用户积分和消费统计
            MemberTotalChangeDto memberTotalChangeDto = new MemberTotalChangeDto();
            memberTotalChangeDto.setUserId(order.getUserId());
            // 如果存在积分兑换比例，则计算积分
            if (redisService.hasKey(SecurityConstant.PAY_MONEY_INTEGRAL)) {
                Integer moneyValue = redisService.getCacheObject(SecurityConstant.PAY_MONEY_INTEGRAL);
                BigDecimal moneyValueBig = BigDecimal.valueOf(moneyValue);
                BigDecimal integralBig = moneyValueBig.multiply(order.getOnlinePayMoney()).setScale(0, BigDecimal.ROUND_HALF_UP);
                Integer integral = Integer.valueOf(integralBig.toString());
                if (integral > 0) {
                    memberTotalChangeDto.setChangeIntegral(integral);
                    memberTotalChangeDto.setTypeIntegral(1);
                    memberTotalChangeDto.setOrderId(orderId);
                    memberTotalChangeDto.setOrderNo(order.getOrderNo());
                }
            }
            //更新消费时间
            memberTotalChangeDto.setConsumeTime(nowTime);
            remoteMemberService.changeMemberTotal(memberTotalChangeDto);
            return merVerifyOrderVo;
        }else{
            //扣减剩余次数
            OrderGoods orderGoods = orderGoodsService.getOne(new LambdaQueryWrapper<OrderGoods>().eq(OrderGoods::getOrderId, order.getOrderId()));
            ConsumerGoods consumerGoods = consumerGoodsService.getOne(new LambdaQueryWrapper<ConsumerGoods>().eq(ConsumerGoods::getOrderId, order.getOrderId()).eq(ConsumerGoods::getOrderGoodsId, orderGoods.getOrderGoodsId()));
            consumerGoods.setUsedNum(consumerGoods.getUsedNum() + 1);
            consumerGoods.setUseTime(new Date());
            if(consumerGoods.getUsedNum() == consumerGoods.getServiceNum()){
                consumerGoods.setCompleteTime(new Date());
            }
            consumerGoodsService.updateById(consumerGoods);
            //生成返回
            MerVerifyOrderVo merVerifyOrderVo = new MerVerifyOrderVo();
            merVerifyOrderVo.setOrderId(orderId);
            merVerifyOrderVo.setOrderNo(order.getOrderNo());
            merVerifyOrderVo.setOrderStatus(order.getOrderStatus());
            merVerifyOrderVo.setOrderFrom(order.getOrderFrom());
            merVerifyOrderVo.setOrderGoodsMoney(order.getOrderMoney());
            merVerifyOrderVo.setCouponDiscount(order.getCouponMoney());
            merVerifyOrderVo.setReceivableDeposit(order.getReceivableDeposit());
            merVerifyOrderVo.setPayMoney(order.getPayMoney());
            merVerifyOrderVo.setOrderRemark(order.getOrderRemark());
            merVerifyOrderVo.setAppUserOrderGoodsPageVoList(new ArrayList<AppUserOrderGoodsPageVo>() {{
                add(new AppUserOrderGoodsPageVo() {{
                    setOrderGoodsId(orderGoods.getOrderGoodsId());
                    setGoodsName(orderGoods.getGoodsName());
                    setGoodsType(orderGoods.getGoodsType());
                    setBuyNum(orderGoods.getBuyNum());
                }});
            }});
            merVerifyOrderVo.setCreateTime(order.getCreateTime());
            merVerifyOrderVo.setPayTime(order.getPayTime());
            merVerifyOrderVo.setUseTime(order.getUseTime());
            merVerifyOrderVo.setPayType(order.getPayType());
            merVerifyOrderVo.setRealReceiveMoney(order.getChangeReceivableMoney());
            //根据支付方式返回应收金额和已收金额
            if (order.getPayType() == 1) {
                merVerifyOrderVo.setReceivableMoney(order.getOrderMoney().subtract(order.getPayMoney()));
                merVerifyOrderVo.setReceiveMoney(order.getPayMoney());
            } else {
                merVerifyOrderVo.setReceivableMoney(order.getOrderMoney().subtract(order.getCouponMoney()).subtract(order.getReceivableDeposit()));
                if (order.getOfflinePayMoney() != null) {
                    merVerifyOrderVo.setReceiveMoney(order.getOfflinePayMoney());
                } else {
                    merVerifyOrderVo.setReceiveMoney(BigDecimal.ZERO);
                }
            }
            merVerifyOrderVo.setUnReceiveMoney(BigDecimal.ZERO);
            merVerifyOrderVo.setUserId(order.getUserId());
            merVerifyOrderVo.setUserName(member.getRealName());
            merVerifyOrderVo.setUserMobile(member.getMobile());
            merVerifyOrderVo.setCloseFlag(order.getCloseFlag());
            return merVerifyOrderVo;
        }
    }
    
    
    /**
     * 核销快手券
     *
     * @return
     */
    @Override
    @Transactional
//    @GlobalTransactional(rollbackFor = Exception.class) todo 放开分布式事务注解
    public MerVerifyOrderVo sureVerifyOrderKuaiShou(MerVerifyOrderDto merVerifyOrderDto) {
        String phone = merVerifyOrderDto.getPhone();
        String orderId = merVerifyOrderDto.getOrderId();
        Long shopId = merVerifyOrderDto.getShopId();
        //获取核销商户
        Shop shop = remoteShopService.getShop(shopId).getData();
        VerifyPrepareDataNew data = KSVerifyUtil.certificatePrepare(redisService, orderId);
        if (null == data) {
            throw new ServiceException("查询券信息失败");
        }
        List<SimpleCertificateTimesCard> itemList = data.getCertificates();
        if (null == itemList || itemList.isEmpty()) {
            throw new ServiceException("查询券信息失败");
        }
        SimpleCertificateTimesCard certificatesItem = itemList.get(0);
        Long expire_time = certificatesItem.getExpire_time();
        if(LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8")) > expire_time){
            throw new ServiceException("优惠券已过期");
        }
        //商品信息
        SkuTImesCard sku = certificatesItem.getSku();
        if(null == sku.getTimes_count()){
            Order one = this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getTripartiteOrderId, data.getOrder_id()));
            if (null != one) {
                throw new ServiceException("该快手券不能重复核销");
            }
        }

        Member member = remoteMemberService.getMemberByMobile(phone).getData();
        //绑定用户判断核销商户
        if (member.getBindingFlag() == 1) {
            if (!member.getRelationShopId().equals(shopId)) {
                throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
            }
        }
        order.setUseTime(nowTime);
        order.setUseUserId(merVerifyOrderDto.getUserId());
        order.setCloseFlag(1);
        this.save(order);
        //创建服务商品
        //获取商品信息(商品简介,调理问题)
        //商品信息
        CertificatePrepareResponseDataCertificatesItemSku sku = certificatesItem.getSku();
        //次卡信息
        CertificatePrepareResponseDataCertificatesItemTimeCard timeCard = certificatesItem.getTimeCard();
        
        OrderGoods orderGoods = new OrderGoods();
        orderGoods.setOrderGoodsId(IdUtils.simpleUUID());
        orderGoods.setDelFlag(0);
        orderGoods.setOrderId(order.getOrderId());
        orderGoods.setBuyNum(timeCard.getTimesCount());
        orderGoods.setCycleNumFlag(1);
        orderGoods.setServiceNum(timeCard.getTimesCount());
        orderGoods.setGoodsType(2);
        orderGoods.setGoodsName(sku.getTitle());
        orderGoodsService.save(orderGoods);
        String encryptedCode = certificatesItem.getEncrypted_code();
        List<VerifyResult> items = KSVerifyUtil.certificateVerify(redisService, data.getVerify_token(), shop.getKsPoiId(), new ArrayList<String>() {{
            add(encryptedCode);
        }}, data.getOrder_id());
        if (null == items || items.isEmpty()) {
            throw new ServiceException("快手券核销失败");
        }
    
        OpenApiQueryOrderDetailInfoV1 orderDetailInfoV1 = KSOrderUtil.queryOrderInfo(redisService, data.getOrder_id());
        //原始金额
        BigDecimal originAmount = BigDecimal.ZERO;
        //支付金额
        BigDecimal payAmount = BigDecimal.ZERO;
        //优惠金额
        BigDecimal payDiscountAmount = BigDecimal.ZERO;
        Long create_order_time = LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8"));
        Long pay_time = LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8"));
        if (null != orderDetailInfoV1) {
            OpenApiOrderAmountV1 amountInfo = orderDetailInfoV1.getAmount();
            originAmount = BigDecimal.valueOf(amountInfo.getTotal_amount());
            payAmount = BigDecimal.valueOf(amountInfo.getPay_amount());
            payDiscountAmount = originAmount.subtract(payAmount);
            create_order_time = orderDetailInfoV1.getCreate_order_time();
            pay_time = orderDetailInfoV1.getPay_time();
        }
        
        ConsumerGoods consumerGoods = new ConsumerGoods();
        consumerGoods.setConsumerGoodsId(IdUtils.simpleUUID());
        consumerGoods.setDelFlag(0);
        consumerGoods.setServiceStatus(1);
        consumerGoods.setShopId(order.getShopId());
        consumerGoods.setUserId(order.getUserId());
        consumerGoods.setOrderId(orderId);
        consumerGoods.setOrderGoodsId(orderGoods.getOrderGoodsId());
        consumerGoods.setGoodsName(sku.getTitle());
        consumerGoods.setCycleNumFlag(1);
        consumerGoods.setServiceNum(timeCard.getTimesCount());
        consumerGoods.setCreateTime(nowTime);
        consumerGoods.setGoodsType(2);
        consumerGoods.setSourceFrom(1);
        consumerGoodsService.save(consumerGoods);
        //生成返回
        MerVerifyOrderVo merVerifyOrderVo = new MerVerifyOrderVo();
        merVerifyOrderVo.setOrderId(orderId);
        merVerifyOrderVo.setOrderNo(order.getOrderNo());
        merVerifyOrderVo.setOrderStatus(order.getOrderStatus());
        merVerifyOrderVo.setOrderFrom(order.getOrderFrom());
        merVerifyOrderVo.setOrderGoodsMoney(order.getOrderMoney());
        merVerifyOrderVo.setCouponDiscount(order.getCouponMoney());
        merVerifyOrderVo.setReceivableDeposit(order.getReceivableDeposit());
        merVerifyOrderVo.setPayMoney(order.getPayMoney());
        merVerifyOrderVo.setOrderRemark(order.getOrderRemark());
        merVerifyOrderVo.setAppUserOrderGoodsPageVoList(new ArrayList<AppUserOrderGoodsPageVo>() {{
            add(new AppUserOrderGoodsPageVo() {{
                setOrderGoodsId(orderGoods.getOrderGoodsId());
                setGoodsName(orderGoods.getGoodsName());
                setGoodsType(orderGoods.getGoodsType());
                setBuyNum(orderGoods.getBuyNum());
        Date nowTime = new Date();
        Order order = this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getTripartiteOrderId, data.getOrder_id()));
        if(null == order){
            //开始添加订单数据
            order = new Order();
            order.setOrderId(IdUtils.fastSimpleUUID());
            order.setDelFlag(0);
            order.setOrderStatus(3);
            order.setOrderNo(CodeFactoryUtil.getShopOrderNo());
            order.setOrderFrom(7);
            order.setShopId(shopId);
            order.setUserId(member.getUserId());
            order.setOrderMoney(originAmount);
            order.setDiscountMoney(payDiscountAmount);
            order.setReceivableMoney(payAmount);
            order.setPayType(1);
            order.setPayMoney(payAmount);
            order.setOnlinePayMoney(payAmount);
            order.setOrderRemark("快手订单");
            order.setCreateTime(new Date(create_order_time * 1000));
            order.setPayTime(new Date(pay_time * 1000));
            order.setTripartiteOrderId(data.getOrder_id());
            order.setUseTime(nowTime);
            order.setUseUserId(merVerifyOrderDto.getUserId());
            order.setCloseFlag(1);
            order.setGoodsNum(1);
            order.setCouponMoney(BigDecimal.ZERO);
            this.save(order);
            //创建服务商品
            //获取商品信息(商品简介,调理问题)

            OrderGoods orderGoods = new OrderGoods();
            orderGoods.setOrderGoodsId(IdUtils.simpleUUID());
            orderGoods.setDelFlag(0);
            orderGoods.setOrderId(order.getOrderId());
            orderGoods.setGoodsId(sku.getSku_id());
            orderGoods.setBuyNum(sku.getTimes_count());
            orderGoods.setCycleNumFlag(1);
            orderGoods.setServiceNum(sku.getTimes_count());
            orderGoods.setGoodsType(2);
            orderGoods.setGoodsName(sku.getTitle());
            orderGoodsService.save(orderGoods);

            ConsumerGoods consumerGoods = new ConsumerGoods();
            consumerGoods.setConsumerGoodsId(IdUtils.simpleUUID());
            consumerGoods.setDelFlag(0);
            consumerGoods.setServiceStatus(1);
            consumerGoods.setShopId(order.getShopId());
            consumerGoods.setUserId(order.getUserId());
            consumerGoods.setOrderId(orderId);
            consumerGoods.setGoodsId(sku.getSku_id());
            consumerGoods.setOrderGoodsId(orderGoods.getOrderGoodsId());
            consumerGoods.setGoodsName(sku.getTitle());
            consumerGoods.setCycleNumFlag(1);
            consumerGoods.setServiceNum(sku.getTimes_count());
            consumerGoods.setUsedNum(1);
            consumerGoods.setUseTime(new Date());
            consumerGoods.setCreateTime(nowTime);
            consumerGoods.setGoodsType(2);
            consumerGoods.setSourceFrom(1);
            consumerGoodsService.save(consumerGoods);
            //生成返回
            MerVerifyOrderVo merVerifyOrderVo = new MerVerifyOrderVo();
            merVerifyOrderVo.setOrderId(orderId);
            merVerifyOrderVo.setOrderNo(order.getOrderNo());
            merVerifyOrderVo.setOrderStatus(order.getOrderStatus());
            merVerifyOrderVo.setOrderFrom(order.getOrderFrom());
            merVerifyOrderVo.setOrderGoodsMoney(order.getOrderMoney());
            merVerifyOrderVo.setCouponDiscount(order.getCouponMoney());
            merVerifyOrderVo.setReceivableDeposit(order.getReceivableDeposit());
            merVerifyOrderVo.setPayMoney(order.getPayMoney());
            merVerifyOrderVo.setOrderRemark(order.getOrderRemark());
            merVerifyOrderVo.setAppUserOrderGoodsPageVoList(new ArrayList<AppUserOrderGoodsPageVo>() {{
                add(new AppUserOrderGoodsPageVo() {{
                    setOrderGoodsId(orderGoods.getOrderGoodsId());
                    setGoodsName(orderGoods.getGoodsName());
                    setGoodsType(orderGoods.getGoodsType());
                    setBuyNum(orderGoods.getBuyNum());
                }});
            }});
        }});
        merVerifyOrderVo.setCreateTime(order.getCreateTime());
        merVerifyOrderVo.setPayTime(order.getPayTime());
        merVerifyOrderVo.setUseTime(order.getUseTime());
        merVerifyOrderVo.setPayType(order.getPayType());
        merVerifyOrderVo.setRealReceiveMoney(order.getChangeReceivableMoney());
        //根据支付方式返回应收金额和已收金额
        if (order.getPayType() == 1) {
            merVerifyOrderVo.setReceivableMoney(order.getOrderMoney().subtract(order.getPayMoney()));
            merVerifyOrderVo.setReceiveMoney(order.getPayMoney());
        } else {
            merVerifyOrderVo.setReceivableMoney(order.getOrderMoney().subtract(order.getCouponMoney()).subtract(order.getReceivableDeposit()));
            if (order.getOfflinePayMoney() != null) {
                merVerifyOrderVo.setReceiveMoney(order.getOfflinePayMoney());
            merVerifyOrderVo.setCreateTime(order.getCreateTime());
            merVerifyOrderVo.setPayTime(order.getPayTime());
            merVerifyOrderVo.setUseTime(order.getUseTime());
            merVerifyOrderVo.setPayType(order.getPayType());
            merVerifyOrderVo.setRealReceiveMoney(order.getChangeReceivableMoney());
            //根据支付方式返回应收金额和已收金额
            if (order.getPayType() == 1) {
                merVerifyOrderVo.setReceivableMoney(order.getOrderMoney().subtract(order.getPayMoney()));
                merVerifyOrderVo.setReceiveMoney(order.getPayMoney());
            } else {
                merVerifyOrderVo.setReceiveMoney(BigDecimal.ZERO);
                merVerifyOrderVo.setReceivableMoney(order.getOrderMoney().subtract(order.getCouponMoney()).subtract(order.getReceivableDeposit()));
                if (order.getOfflinePayMoney() != null) {
                    merVerifyOrderVo.setReceiveMoney(order.getOfflinePayMoney());
                } else {
                    merVerifyOrderVo.setReceiveMoney(BigDecimal.ZERO);
                }
            }
        }
        merVerifyOrderVo.setUnReceiveMoney(merVerifyOrderVo.getRealReceiveMoney().subtract(merVerifyOrderVo.getReceiveMoney()));
        merVerifyOrderVo.setUserId(order.getUserId());
        merVerifyOrderVo.setUserName(member.getRealName());
        merVerifyOrderVo.setUserMobile(member.getMobile());
        merVerifyOrderVo.setCloseFlag(order.getCloseFlag());
        //判断用户是否绑定  2023-09-05需求改变核销时绑定用户
        if (member.getBindingFlag() != 1) {
            //绑定商户
            AppMemberBindingDto appMemberBindingDto = new AppMemberBindingDto();
            appMemberBindingDto.setShopId(order.getShopId());
            appMemberBindingDto.setUserId(order.getUserId());
            appMemberBindingDto.setBindingFlag(1);
            if (order.getOrderFrom() == 1) {
                appMemberBindingDto.setBindingType(1);
            } else if (order.getOrderFrom() == 2) {
                appMemberBindingDto.setBindingType(2);
            merVerifyOrderVo.setUnReceiveMoney(BigDecimal.ZERO);
            merVerifyOrderVo.setUserId(order.getUserId());
            merVerifyOrderVo.setUserName(member.getRealName());
            merVerifyOrderVo.setUserMobile(member.getMobile());
            merVerifyOrderVo.setCloseFlag(order.getCloseFlag());
            //判断用户是否绑定  2023-09-05需求改变核销时绑定用户
            if (member.getBindingFlag() != 1) {
                //绑定商户
                AppMemberBindingDto appMemberBindingDto = new AppMemberBindingDto();
                appMemberBindingDto.setShopId(order.getShopId());
                appMemberBindingDto.setUserId(order.getUserId());
                appMemberBindingDto.setBindingFlag(1);
                if (order.getOrderFrom() == 1) {
                    appMemberBindingDto.setBindingType(1);
                } else if (order.getOrderFrom() == 2) {
                    appMemberBindingDto.setBindingType(2);
                }
                remoteMemberService.updateMemberBinding(appMemberBindingDto);
                order.setNewMemberFlag(1);
            } else {
                order.setNewMemberFlag(0);
            }
            remoteMemberService.updateMemberBinding(appMemberBindingDto);
            order.setNewMemberFlag(1);
        } else {
            order.setNewMemberFlag(0);
        }
        this.saveOrUpdate(order);
        //更新用户积分和消费统计
        MemberTotalChangeDto memberTotalChangeDto = new MemberTotalChangeDto();
        memberTotalChangeDto.setUserId(order.getUserId());
        // 如果存在积分兑换比例，则计算积分
        if (redisService.hasKey(SecurityConstant.PAY_MONEY_INTEGRAL)) {
            Integer moneyValue = redisService.getCacheObject(SecurityConstant.PAY_MONEY_INTEGRAL);
            BigDecimal moneyValueBig = BigDecimal.valueOf(moneyValue);
            BigDecimal integralBig = moneyValueBig.multiply(order.getOnlinePayMoney()).setScale(0, BigDecimal.ROUND_HALF_UP);
            Integer integral = Integer.valueOf(integralBig.toString());
            if (integral > 0) {
                memberTotalChangeDto.setChangeIntegral(integral);
                memberTotalChangeDto.setTypeIntegral(1);
                memberTotalChangeDto.setOrderId(orderId);
                memberTotalChangeDto.setOrderNo(order.getOrderNo());
            this.saveOrUpdate(order);
            //更新用户积分和消费统计
            MemberTotalChangeDto memberTotalChangeDto = new MemberTotalChangeDto();
            memberTotalChangeDto.setUserId(order.getUserId());
            // 如果存在积分兑换比例，则计算积分
            if (redisService.hasKey(SecurityConstant.PAY_MONEY_INTEGRAL)) {
                Integer moneyValue = redisService.getCacheObject(SecurityConstant.PAY_MONEY_INTEGRAL);
                BigDecimal moneyValueBig = BigDecimal.valueOf(moneyValue);
                BigDecimal integralBig = moneyValueBig.multiply(order.getOnlinePayMoney()).setScale(0, BigDecimal.ROUND_HALF_UP);
                Integer integral = Integer.valueOf(integralBig.toString());
                if (integral > 0) {
                    memberTotalChangeDto.setChangeIntegral(integral);
                    memberTotalChangeDto.setTypeIntegral(1);
                    memberTotalChangeDto.setOrderId(orderId);
                    memberTotalChangeDto.setOrderNo(order.getOrderNo());
                }
            }
            //更新消费时间
            memberTotalChangeDto.setConsumeTime(nowTime);
            remoteMemberService.changeMemberTotal(memberTotalChangeDto);
            return merVerifyOrderVo;
        }else{
            //扣减剩余次数
            OrderGoods orderGoods = orderGoodsService.getOne(new LambdaQueryWrapper<OrderGoods>().eq(OrderGoods::getOrderId, order.getOrderId()));
            ConsumerGoods consumerGoods = consumerGoodsService.getOne(new LambdaQueryWrapper<ConsumerGoods>().eq(ConsumerGoods::getOrderId, order.getOrderId()).eq(ConsumerGoods::getOrderGoodsId, orderGoods.getOrderGoodsId()));
            consumerGoods.setUsedNum(consumerGoods.getUsedNum() + 1);
            consumerGoods.setUseTime(new Date());
            if(consumerGoods.getUsedNum() == consumerGoods.getServiceNum()){
                consumerGoods.setCompleteTime(new Date());
            }
            consumerGoodsService.updateById(consumerGoods);
            //生成返回
            MerVerifyOrderVo merVerifyOrderVo = new MerVerifyOrderVo();
            merVerifyOrderVo.setOrderId(orderId);
            merVerifyOrderVo.setOrderNo(order.getOrderNo());
            merVerifyOrderVo.setOrderStatus(order.getOrderStatus());
            merVerifyOrderVo.setOrderFrom(order.getOrderFrom());
            merVerifyOrderVo.setOrderGoodsMoney(order.getOrderMoney());
            merVerifyOrderVo.setCouponDiscount(order.getCouponMoney());
            merVerifyOrderVo.setReceivableDeposit(order.getReceivableDeposit());
            merVerifyOrderVo.setPayMoney(order.getPayMoney());
            merVerifyOrderVo.setOrderRemark(order.getOrderRemark());
            merVerifyOrderVo.setAppUserOrderGoodsPageVoList(new ArrayList<AppUserOrderGoodsPageVo>() {{
                add(new AppUserOrderGoodsPageVo() {{
                    setOrderGoodsId(orderGoods.getOrderGoodsId());
                    setGoodsName(orderGoods.getGoodsName());
                    setGoodsType(orderGoods.getGoodsType());
                    setBuyNum(orderGoods.getBuyNum());
                }});
            }});
            merVerifyOrderVo.setCreateTime(order.getCreateTime());
            merVerifyOrderVo.setPayTime(order.getPayTime());
            merVerifyOrderVo.setUseTime(order.getUseTime());
            merVerifyOrderVo.setPayType(order.getPayType());
            merVerifyOrderVo.setRealReceiveMoney(order.getChangeReceivableMoney());
            //根据支付方式返回应收金额和已收金额
            if (order.getPayType() == 1) {
                merVerifyOrderVo.setReceivableMoney(order.getOrderMoney().subtract(order.getPayMoney()));
                merVerifyOrderVo.setReceiveMoney(order.getPayMoney());
            } else {
                merVerifyOrderVo.setReceivableMoney(order.getOrderMoney().subtract(order.getCouponMoney()).subtract(order.getReceivableDeposit()));
                if (order.getOfflinePayMoney() != null) {
                    merVerifyOrderVo.setReceiveMoney(order.getOfflinePayMoney());
                } else {
                    merVerifyOrderVo.setReceiveMoney(BigDecimal.ZERO);
                }
            }
            merVerifyOrderVo.setUnReceiveMoney(BigDecimal.ZERO);
            merVerifyOrderVo.setUserId(order.getUserId());
            merVerifyOrderVo.setUserName(member.getRealName());
            merVerifyOrderVo.setUserMobile(member.getMobile());
            merVerifyOrderVo.setCloseFlag(order.getCloseFlag());
            return merVerifyOrderVo;
        }
        //更新消费时间
        memberTotalChangeDto.setConsumeTime(nowTime);
        remoteMemberService.changeMemberTotal(memberTotalChangeDto);
        return merVerifyOrderVo;

    }
    
    
    
    /**
@@ -2775,7 +3188,13 @@
                consumerGoodsService.sendGoodsGift(giftSendDtoList);
                //抽奖奖品中的平台商品需要生成订单数据
                if (memberGiftRecord.getPrizeFrom() == 2) {
                    addOrder(memberGiftRecord.getShopId(), memberGiftRecord.getUserId(), goods, memberGiftRecord.getGoodsNumber(), memberGiftRecord.getGiftId());
                    Order one = this.getOne(new QueryWrapper<Order>().eq("activity_id", memberGiftRecord.getGiftId()).eq("order_from", 4));
                    if(null == one){
                        addOrder(memberGiftRecord.getShopId(), memberGiftRecord.getUserId(), goods, memberGiftRecord.getGoodsNumber(), memberGiftRecord.getGiftId(), 3);
                    }else{
                        one.setOrderStatus(3);
                        this.updateById(one);
                    }
                }
                break;
            case 3:
@@ -2813,23 +3232,23 @@
    
    
    /**
     * 核销抽奖的平台商品生成订单
     * 抽奖的平台商品生成订单--待审核
     *
     * @param shopId
     * @param userId
     * @param goods
     * @param goodsNum
     */
    public void addOrder(Long shopId, Long userId, Goods goods, Integer goodsNum, String giftId) {
    public void addOrder(Long shopId, Long userId, Goods goods, Integer goodsNum, String giftId, Integer status) {
        Order order = new Order();
        order.setOrderId(IdUtils.simpleUUID());
        order.setDelFlag(0);
        order.setOrderStatus(3);
        order.setOrderStatus(status);
        order.setOrderNo(CodeFactoryUtil.getShopOrderNo());
        order.setOrderFrom(4);
        order.setShopId(shopId);
        order.setUserId(userId);
        order.setOrderMoney(BigDecimal.ZERO);
        order.setOrderMoney(goods.getSalesPrice());
        order.setCouponMoney(BigDecimal.ZERO);
        order.setDiscountMoney(BigDecimal.ZERO);
        order.setReceivableMoney(BigDecimal.ZERO);
@@ -2888,6 +3307,17 @@
                if (merMemberNoClearOrderVo.getUnPaidMoney().compareTo(zeroBig) < 0) {
                    merMemberNoClearOrderVo.setUnPaidMoney(zeroBig);
                }
                String orderId = merMemberNoClearOrderVo.getOrderId();
                List<OrderGoods> list = orderGoodsService.list(new LambdaQueryWrapper<OrderGoods>().eq(OrderGoods::getOrderId, orderId));
                List<AppGoodsInfoVo> goodsInfoVos = new ArrayList<>();
                for (OrderGoods orderGoods : list) {
                    AppGoodsInfoVo info = new AppGoodsInfoVo();
                    info.setGoodsName(orderGoods.getGoodsName());
                    info.setSalesNum(orderGoods.getBuyNum());
                    info.setGoodsType(orderGoods.getGoodsType());
                    goodsInfoVos.add(info);
                }
                merMemberNoClearOrderVo.setGoodsList(goodsInfoVos);
            }
        }
        return merMemberNoClearOrderVoList;
@@ -3255,7 +3685,7 @@
            Long userId;
            Member member;
            Integer orderFrom;
            String orderFromDesc;
            String orderFromDesc = "";
            BigDecimal zeroBig = new BigDecimal("0.00");
            StringJoiner userIdSj = new StringJoiner(",");
            // 遍历订单列表
@@ -3269,8 +3699,16 @@
                        orderFromDesc = "商城订单";
                    } else if (orderFrom == 2) {
                        orderFromDesc = "平台秒杀活动(" + merOrderPageVo.getActivityName() + ")";
                    } else {
                    } else if(orderFrom == 3) {
                        orderFromDesc = "线下创建";
                    }else if(orderFrom == 4) {
                        orderFromDesc = "抽奖";
                    }else if(orderFrom == 5) {
                        orderFromDesc = "美团";
                    }else if(orderFrom == 6) {
                        orderFromDesc = "抖音";
                    }else if(orderFrom == 7) {
                        orderFromDesc = "快手";
                    }
                } else {
                    orderFromDesc = "商城订单";
@@ -3556,6 +3994,8 @@
        MgtOrderTotal mgtOrderTotalFirst = orderMapper.totalOrderFirst(mgtShopOrderPageDto);
        MgtOrderTotal mgtOrderTotalSecond = orderMapper.totalOrderSecond(mgtShopOrderPageDto);
        MgtOrderTotal mgtOrderTotalThird = orderMapper.totalOrderThird(mgtShopOrderPageDto);
        MgtOrderTotal mgtOrderTotalFour = orderMapper.totalOrderFour(mgtShopOrderPageDto);

        mgtOrderTotal.setOrderTotal(mgtOrderTotalFirst.getOrderTotal());
        mgtOrderTotal.setOrderMoneyTotal(mgtOrderTotalFirst.getOrderMoneyTotal());
        mgtOrderTotal.setShopOrderTotal(mgtOrderTotalSecond.getShopOrderTotal());
@@ -3631,7 +4071,7 @@
            Map<Long, MgtSimpleShopVo> shopMap = null;
            Map<Long, MgtSimpleMemberVo> userMap = null;
            if (shopIdSet != null && !shopIdSet.isEmpty()) {
                String shopJoinedString = String.join(",", shopIdSet.stream().map(Object::toString).collect(Collectors.toList()));
                String shopJoinedString = String.join(",", shopIdSet.stream().filter(Objects::nonNull).map(Object::toString).collect(Collectors.toList()));
                MgtBaseBathDto mgtBaseBathDto = new MgtBaseBathDto();
                mgtBaseBathDto.setIds(shopJoinedString);
                List<MgtSimpleShopVo> simpleShopVoList = remoteShopService.listShopSimpleVoByIds(mgtBaseBathDto).getData();
@@ -3952,7 +4392,7 @@
     */
    private List<MgtMapBigTotalVo> bigListRemoveNull(List<MgtMapBigTotalVo> MgtMapIntTotalVos) {
        for (int i = 0; i < MgtMapIntTotalVos.size(); i++) {
            if (StringUtils.isBlank(MgtMapIntTotalVos.get(i).getMapKey())) {
            if(MgtMapIntTotalVos.get(i).getMapKey().isEmpty()){
                MgtMapIntTotalVos.remove(i);
            }
        }
@@ -4541,8 +4981,33 @@
        //获取来源销售排名
        List<MgtMapBigTotalVo> orderFromList = orderMapper.listPlTotalOrderTotalOrderFrom(mgtBasePlatformDto);
        if (orderFromList != null && orderFromList.size() > 0) {

            MgtMapBigTotalVo duoyin = new MgtMapBigTotalVo();
            duoyin.setMapKey("抖音");
            duoyin.setMapValue(totalOrderTotalVo.getDouyinAmount());

            MgtMapBigTotalVo kauishou = new MgtMapBigTotalVo();
            kauishou.setMapKey("快手");
            kauishou.setMapValue(totalOrderTotalVo.getKuaishouAmount());

            MgtMapBigTotalVo meituan = new MgtMapBigTotalVo();
            meituan.setMapKey("美团");
            meituan.setMapValue(totalOrderTotalVo.getMeituanAmount());
            orderFromList.add(duoyin);
            orderFromList.add(kauishou);
            orderFromList.add(meituan);
            orderFromList = bigListRemoveNull(orderFromList);
            mgtTotalOrderTotalVo.setOrderFromRankList(orderFromList);


            //排行
            List<MgtMapBigTotalVo> sortedList = orderFromList.stream()
                    // 按 mapValue 降序排序，处理 null 值（若 mapValue 可能为 null）
                    .sorted(Comparator.comparing(
                            MgtMapBigTotalVo::getMapValue,
                            Comparator.nullsLast(BigDecimal::compareTo).reversed()
                    ))
                    .collect(Collectors.toList());
            mgtTotalOrderTotalVo.setOrderFromRankList(sortedList);
        }
        //订单分布
        //日期全部时固定为5天
@@ -5575,11 +6040,12 @@
    @Override
    @Transactional
//    @GlobalTransactional(rollbackFor = Exception.class) todo 放开分布式事务注解
    public void autoCancelOrder(String orderId) {
    public void autoCancelOrder(String orderId, Integer cancelType) {
        //更新订单信息
        Order order = this.getById(orderId);
        order.setOrderStatus(0);
        order.setCancelTime(new Date());
        order.setCancelType(cancelType);
        this.saveOrUpdate(order);
        //活动订单回退库存
        if (order.getOrderFrom() == 2) {
@@ -5791,11 +6257,12 @@
    @Override
    @Transactional
//    @GlobalTransactional(rollbackFor = Exception.class) todo 放开分布式事务注解
    public void refundOrder(String orderId) {
    public void refundOrder(String orderId, Integer cancelType) {
        // 更新订单信息
        Order order = this.getById(orderId);
        order.setOrderStatus(0);
        order.setCancelTime(new Date());
        order.setCancelType(cancelType);
        this.saveOrUpdate(order);
        OrderRefund orderRefund = new OrderRefund();
        String refundId = IdUtils.simpleUUID();
@@ -6534,64 +7001,39 @@
        }
    }

//    @GlobalTransactional(rollbackFor = Exception.class) todo 放开分布式事务注解
    private void autoTimeCancelOrder(Order order) {
        String orderId = order.getOrderId();
        order.setOrderStatus(0);
        order.setCancelTime(new Date());
        this.saveOrUpdate(order);
        //活动订单回退库存
        if (order.getOrderFrom() == 2) {
            List<OrderGoods> orderGoodsList = orderGoodsService.listByOrderId(orderId);
            if (orderGoodsList != null && !orderGoodsList.isEmpty()) {
                for (OrderGoods orderGoods : orderGoodsList) {
                    //redis库存控制极简版
                    String goodsLock = "goods_lock_" + order.getActivityId() + "_" + orderGoods.getGoodsId();
                    RLock redissonLock = redissonClient.getLock(goodsLock);
                    try {
                        redissonLock.lock(30, TimeUnit.SECONDS);
                        Integer surpNum = redisService.getCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + order.getActivityId() + "-" + orderGoods.getGoodsId());
                        if(null == surpNum){
                            surpNum = 0;
                        }
                        redisService.setCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + order.getActivityId() + "-" + orderGoods.getGoodsId(), surpNum + orderGoods.getBuyNum());
                    } finally {
                        redissonLock.unlock();
                    }
                    //改变活动库存
                    AGStockChangeDto agStockChangeDto = new AGStockChangeDto();
                    agStockChangeDto.setActivityId(order.getActivityId());
                    agStockChangeDto.setGoodsId(orderGoods.getGoodsId());
                    agStockChangeDto.setChangeType(1);
                    agStockChangeDto.setChangeNum(orderGoods.getBuyNum());
                    agStockChangeDto.setShopId(order.getShopId());
                    agStockChangeDto.setUserId(order.getUserId());
                    remoteActivityService.changeActivityStock(agStockChangeDto);
                    //删除活动记录
                    ActivityRecord activityRecord = new ActivityRecord();
                    activityRecord.setActivityId(order.getActivityId());
                    activityRecord.setGoodsId(orderGoods.getGoodsId());
                    activityRecord.setUserId(order.getUserId());
                    activityRecord.setOrderTime(order.getCreateTime());
                    remoteActivityService.delActivityRecord(activityRecord);
                }
            }
        } else {
            if (order.getCouponMoney().compareTo(BigDecimal.ZERO) > 0) {
                //回退优惠券
                List<OrderGoods> orderGoodsList = orderGoodsService.listByOrderId(orderId);
                if (orderGoodsList != null && !orderGoodsList.isEmpty()) {
                    StringJoiner memberCouponSJ = new StringJoiner(",");
                    for (OrderGoods orderGoods : orderGoodsList) {
                        memberCouponSJ.add(orderGoods.getCouponId());
                    }
                    if (memberCouponSJ != null) {
                        remoteCouponService.backMemberCoupon(memberCouponSJ.toString());

                    }
                }
            }
    /**
     * 后台取消订单
     * 订单状态变为已取消 不退款
     * @param dto
     */
    @Override
    public R cancelOrderBySys(CancelOrderDTO dto) {
        Order order = this.getById(dto.getOrderId());
        // 订单状态-1.删除 0.已取消 1.待支付 2.待核销 3.已完成
        if(null == order || order.getDelFlag() == -1){
            return R.fail("订单不存在");
        }

        if (order.getOrderStatus() == 0) {
            return R.fail(AppErrorConstant.CANCEL_CANCEL_ORDER);
        } else if (order.getOrderStatus() == 1) {
            //删除待支付超时取消延时任务
            redisService.deleteObject(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + order.getOrderId());
            remoteConfigService.deleteDelayTask(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode()+"-"+order.getOrderId());
            order.setOrderStatus(0);
            order.setCancelTime(new Date());
            order.setCancelType(1);
            this.saveOrUpdate(order);
        } else if (order.getOrderStatus() == 2) {
            // 2.待核销
            order.setOrderStatus(0);
            order.setCancelTime(new Date());
            order.setCancelType(1);
            this.saveOrUpdate(order);
        } else {
            return R.fail(AppErrorConstant.CANCEL_ERROR_ORDER);
        }
        return R.ok();
    }

    /**
@@ -6732,38 +7174,6 @@
        }
        return new ArrayList<>();
    }
    /**
     * 后台取消订单
     * 订单状态变为已取消 不退款
     * @param dto
     */
    @Override
    public R cancelOrderBySys(CancelOrderDTO dto) {
        Order order = this.getById(dto.getOrderId());
        // 订单状态-1.删除 0.已取消 1.待支付 2.待核销 3.已完成
        if(null == order || order.getDelFlag() == -1){
            return R.fail("订单不存在");
        }

        if (order.getOrderStatus() == 0) {
            return R.fail(AppErrorConstant.CANCEL_CANCEL_ORDER);
        } else if (order.getOrderStatus() == 1) {
            //删除待支付超时取消延时任务
            redisService.deleteObject(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + order.getOrderId());
            remoteConfigService.deleteDelayTask(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode()+"-"+order.getOrderId());
            order.setOrderStatus(0);
            order.setCancelTime(new Date());
            this.saveOrUpdate(order);
        } else if (order.getOrderStatus() == 2) {
            // 2.待核销
            order.setOrderStatus(0);
            order.setCancelTime(new Date());
            this.saveOrUpdate(order);
        } else {
            return R.fail(AppErrorConstant.CANCEL_ERROR_ORDER);
        }
        return R.ok();
    }

    @Override
    public R refundOrderBySys(CancelOrderDTO dto) {
@@ -6778,15 +7188,76 @@
            //删除待支付超时取消延时任务
            redisService.deleteObject(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + order.getOrderId());
            remoteConfigService.deleteDelayTask(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode()+"-"+ order.getOrderId());
            this.autoCancelOrder( order.getOrderId());
            this.autoCancelOrder( order.getOrderId(), 1);
        } else if (order.getOrderStatus() == 2) {
            // 2.待核销 -> 订单退款
            this.refundOrder( order.getOrderId());
            this.refundOrder( order.getOrderId(), 1);
        } else {
            return R.fail("已核销订单不能退款");
        }
        return R.ok();

    }

//    @GlobalTransactional(rollbackFor = Exception.class) todo 放开分布式事务注解
    private void autoTimeCancelOrder(Order order) {
        String orderId = order.getOrderId();
        order.setOrderStatus(0);
        order.setCancelTime(new Date());
        order.setCancelType(1);
        this.saveOrUpdate(order);
        //活动订单回退库存
        if (order.getOrderFrom() == 2) {
            List<OrderGoods> orderGoodsList = orderGoodsService.listByOrderId(orderId);
            if (orderGoodsList != null && !orderGoodsList.isEmpty()) {
                for (OrderGoods orderGoods : orderGoodsList) {
                    //redis库存控制极简版
                    String goodsLock = "goods_lock_" + order.getActivityId() + "_" + orderGoods.getGoodsId();
                    RLock redissonLock = redissonClient.getLock(goodsLock);
                    try {
                        redissonLock.lock(30, TimeUnit.SECONDS);
                        Integer surpNum = redisService.getCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + order.getActivityId() + "-" + orderGoods.getGoodsId());
                        if(null == surpNum){
                            surpNum = 0;
                        }
                        redisService.setCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + order.getActivityId() + "-" + orderGoods.getGoodsId(), surpNum + orderGoods.getBuyNum());
                    } finally {
                        redissonLock.unlock();
                    }
                    //改变活动库存
                    AGStockChangeDto agStockChangeDto = new AGStockChangeDto();
                    agStockChangeDto.setActivityId(order.getActivityId());
                    agStockChangeDto.setGoodsId(orderGoods.getGoodsId());
                    agStockChangeDto.setChangeType(1);
                    agStockChangeDto.setChangeNum(orderGoods.getBuyNum());
                    agStockChangeDto.setShopId(order.getShopId());
                    agStockChangeDto.setUserId(order.getUserId());
                    remoteActivityService.changeActivityStock(agStockChangeDto);
                    //删除活动记录
                    ActivityRecord activityRecord = new ActivityRecord();
                    activityRecord.setActivityId(order.getActivityId());
                    activityRecord.setGoodsId(orderGoods.getGoodsId());
                    activityRecord.setUserId(order.getUserId());
                    activityRecord.setOrderTime(order.getCreateTime());
                    remoteActivityService.delActivityRecord(activityRecord);
                }
            }
        } else {
            if (order.getCouponMoney().compareTo(BigDecimal.ZERO) > 0) {
                //回退优惠券
                List<OrderGoods> orderGoodsList = orderGoodsService.listByOrderId(orderId);
                if (orderGoodsList != null && !orderGoodsList.isEmpty()) {
                    StringJoiner memberCouponSJ = new StringJoiner(",");
                    for (OrderGoods orderGoods : orderGoodsList) {
                        memberCouponSJ.add(orderGoods.getCouponId());
                    }
                    if (memberCouponSJ != null) {
                        remoteCouponService.backMemberCoupon(memberCouponSJ.toString());

                    }
                }
            }
        }
    }

    @Override
@@ -6889,6 +7360,11 @@
        }
        mgtBasePlatformDto.setShopIdList(shopIdList);
        // 从数据库中获取第三方订单统计
        DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        mgtBasePlatformDto.setStartTime(LocalDate.parse(mgtBasePlatformDto.getStartDate(), dateFormatter)
                .atStartOfDay());
        mgtBasePlatformDto.setEndTime(LocalDate.parse(mgtBasePlatformDto.getEndDate(), dateFormatter)
                .atTime(LocalTime.MAX));
         vo = orderMapper.getPlTotalThirdOrderStatics(mgtBasePlatformDto);
        return vo;
    }