bug

jiangqs

2023-09-06 1ca4c6c6c7861c07980ad0dcd8d5df4b0219bfdc

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

@@ -1,6 +1,5 @@
package com.ruoyi.order.service.impl.order;


import com.google.common.collect.Lists;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
@@ -12,7 +11,6 @@
import com.github.binarywang.wxpay.config.WxPayConfig;
import com.github.binarywang.wxpay.exception.WxPayException;
import com.github.binarywang.wxpay.service.WxPayService;
import com.google.common.base.Joiner;
import com.google.gson.Gson;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.exception.ServiceException;
@@ -54,7 +52,7 @@
import com.ruoyi.system.api.domain.poji.member.MemberCoupon;
import com.ruoyi.system.api.domain.poji.member.MemberGiftRecord;
import com.ruoyi.system.api.domain.poji.shop.Shop;
import com.ruoyi.system.api.domain.poji.shop.ShopProportionVo;
import com.ruoyi.system.api.domain.vo.ShopProportionVo;
import com.ruoyi.system.api.domain.poji.sys.SysUser;
import com.ruoyi.system.api.domain.vo.*;
import com.ruoyi.system.api.service.*;
@@ -147,6 +145,8 @@

    @Resource
    private OrderRefundService orderRefundService;



    /**
     * @description: buyGoods
@@ -318,8 +318,6 @@
                } else {
                    entity.setUseFlag(0);
                }


            }
            // 过滤商品优惠券列表
            List<AppMemberCouponVo> appGoodsMemberCouponVoList;
@@ -559,6 +557,7 @@
        // 将用户优惠券列表转换为Map，方便后续查找
        Map<String, AppMemberCouponVo> appMemberCouponVoMap = appMemberCouponVoList.stream().collect(Collectors.toMap(AppMemberCouponVo::getMemberCouponId, Function.identity()));
        AppMemberCouponVo appMemberCouponVo;
        AppShopGoodsGetDto appShopGoodsGetDto;
        Integer couponType;
        BigDecimal moneyThreshold;
        BigDecimal discountMoney = new BigDecimal("0.00");
@@ -605,7 +604,7 @@
            goodsPrice = goods.getSalesPrice();
            serviceNum = goods.getServiceNum();
            // 获取商户定制价格
            AppShopGoodsGetDto appShopGoodsGetDto = new AppShopGoodsGetDto();
            appShopGoodsGetDto = new AppShopGoodsGetDto();
            appShopGoodsGetDto.setGoodsId(goods.getGoodsId());
            appShopGoodsGetDto.setShopId(appPlaceOrderDto.getShopId());
            ShopGoods shopGoods = remoteGoodsService.getShopGoods(appShopGoodsGetDto).getData();
@@ -748,9 +747,6 @@
        order.setOrderRemark(appPlaceOrderDto.getOrderRemark());
        order.setGoodsNum(goodsNum);
        order.setCreateTime(new Date());
        if(appPlaceOrderDto.getNewMemberFlag()!=null&&appPlaceOrderDto.getNewMemberFlag()==1){
            order.setNewMemberFlag(1);
        }
        // 保存订单
        this.save(order);
        appPlaceOrderVo.setOrderId(orderId);
@@ -778,7 +774,7 @@
            // 小程序微信下单支付
            createWxPayInfo(appPlaceOrderVo, userId, order.getShopId(), goodsName, outTradeNo,
                    orderId, order.getPayMoney(), appPlaceOrderDto.getOpenid(),
                    appPlaceOrderDto.getSpbillCreateIp(), goodsNameList,1);
                    appPlaceOrderDto.getSpbillCreateIp());
            //生成自动取消订单延时任务
            String payStr = appPlaceOrderVo.getAppId()+"-"+appPlaceOrderVo.getTimeStamp()+"-"+appPlaceOrderVo.getNonceStr()+"-"+appPlaceOrderVo.getPackageStr()+"-"+appPlaceOrderVo.getSignType()+"-"+appPlaceOrderVo.getPaySign();
            redisService.setCacheObject(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + orderId, payStr , delayTime.longValue(), TimeUnit.MINUTES);
@@ -815,23 +811,23 @@
     * @param payMoney
     * @param openid
     * @param payerClientIp
     * @param goodsNameList
     */

    private void createWxPayInfo(AppPlaceOrderVo appPlaceOrderVo, Long userId, Long shopId,
                                 String goodsName, String outTradeNo,
                                 String orderId, BigDecimal payMoney,
                                 String openid, String payerClientIp, List<String> goodsNameList,Integer orderFrom){
                                 String openid, String payerClientIp){
        try {
            // 创建支付订单
            R<String> resultMch = remoteShopService.getShopSubMchId(shopId);
            //2023-09-05 需求变更为统一支付到矗众
            /*R<String> resultMch = remoteShopService.getShopSubMchId(shopId);
            String subMchId = resultMch.getData();
            if (StringUtils.isEmpty(subMchId)) {
                throw new ServiceException("获取微信商户号失败");
            }
            }*/
            String mainMchId = WxPayConfiguration.getPlatformTyMacId();
            WxPayConfig config = wxService.getConfig();
            config.setSubMchId(subMchId);

            config.setSubMchId(mainMchId);
            PartnerTransactionsRequest request = new PartnerTransactionsRequest();
            request.setSpAppid(config.getAppId());
            request.setSpMchid(config.getMchId());
@@ -845,11 +841,7 @@
            // 结算信息
            PartnerTransactionsRequest.SettleInfo settleInfo = new PartnerTransactionsRequest.SettleInfo();
            // TODO 分账处理
            if(orderFrom==2){
                settleInfo.setProfitSharing(true);
            }else{
                settleInfo.setProfitSharing(false);
            }
            settleInfo.setProfitSharing(true);
            settleInfo.setSubsidyAmount(BigDecimal.ZERO);
            request.setSettleInfo(settleInfo);

@@ -872,7 +864,6 @@
            PartnerTransactionsRequest.SceneInfo sceneInfo = new PartnerTransactionsRequest.SceneInfo();
            sceneInfo.setPayerClientIp(payerClientIp);
            request.setSceneInfo(sceneInfo);

            TransactionsResult.JsapiResult result = wxService.getEcommerceService().partnerTransactions(TradeTypeEnum.JSAPI, request);

            // 请求参数
@@ -895,9 +886,9 @@
            paymentMessageService.savePaymentMessage("1", orderId, payRequestJson, payResponseJson);

            // 保存支付订单统一下单支付记录
            orderPaymentService.saveOrderPayment(userId, shopId, subMchId, orderId, outTradeNo, payMoney,
            orderPaymentService.saveOrderPayment(userId, shopId, mainMchId, orderId, outTradeNo, payMoney,
                    appPlaceOrderVo.getEndTime(), "Y", openid,
                    Joiner.on(";").join(goodsNameList), result.getPackageValue());
                    goodsName, result.getPackageValue());

        } catch (WxPayException e) {
            throw new ServiceException(e.getMessage());
@@ -928,259 +919,259 @@
        //redis分布式锁库存控制
        String goodsLock = "goods_lock_" + activityId + "_" + goodsId;
        RLock redissonLock = redissonClient.getLock(goodsLock);
        Integer surpNum = 0;
        try {
            redissonLock.lock(30, TimeUnit.SECONDS);
            Integer surpNum = redisService.getCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + activityId + "-" + goodsId);
            surpNum = redisService.getCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + activityId + "-" + goodsId);
            if (surpNum == null || surpNum < buyNum) {
                throw new ServiceException(AppErrorConstant.ACTIVITY_GOODS_NULL);
            } else {
                redisService.setCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + activityId + "-" + goodsId, surpNum - buyNum);
            }
            // 定义购买数量，服务数量，商品数量
            BigDecimal buyNumBig;
            Integer serviceNum;
            Integer goodsNum = 0;
            // 定义商品，商品文件，商品价格，商品总价，商品实际价格，折扣金额，折扣百分比，商品押金，使用优惠券，订单商品金额，优惠券折扣，订单支付押金，订单支付金额
            Goods goods;
            GoodsFile goodsFile;
            BigDecimal goodsPrice;
            BigDecimal goodsTotalPrice;
            BigDecimal goodsRealPrice;
            BigDecimal discountMoney = new BigDecimal("0.00");
            BigDecimal goodsDeposit;
            Integer useCoupon;
            BigDecimal orderGoodsMoney = new BigDecimal("0.00");
            BigDecimal couponDiscount = new BigDecimal("0.00");
            BigDecimal orderPayDeposit = new BigDecimal("0.00");
            BigDecimal orderPayMoney = new BigDecimal("0.00");
            // 创建活动商品对象，并设置活动ID，商品ID，用户ID
            ActivityGoodsGetDto activityGoodsGetDto = new ActivityGoodsGetDto();
            activityGoodsGetDto.setActivityId(activityId);
            activityGoodsGetDto.setGoodsId(goodsId);
            activityGoodsGetDto.setUserId(userId);
            // 获取用户活动商品
            ActivityGoodsGetVo activityGoodsGetVo = remoteActivityService.getUserActivityGoods(activityGoodsGetDto).getData();
            // 检查活动状态
            if (activityGoodsGetVo.getActivityStatus() == 0) {
                throw new ServiceException(AppErrorConstant.ACTIVITY_NO_START);
            }
            if (activityGoodsGetVo.getActivityStatus() == 2) {
                throw new ServiceException(AppErrorConstant.ACTIVITY_END);
            }
            if (activityGoodsGetVo.getAvailableBuyNum() < 1) {
                throw new ServiceException(AppErrorConstant.ACTIVITY_GOODS_NULL);
            }
            if (activityGoodsGetVo.getAvailableBuyNum() < buyNum) {
                throw new ServiceException(AppErrorConstant.ACTIVITY_GOODS_BEYOND);
            }
            // 创建订单ID和订单号
            String orderId = IdUtils.simpleUUID();
            String orderNo = CodeFactoryUtil.getShopOrderNo();
            // 创建订单商品对象和订单商品ID
            OrderGoods orderGoods;
            String orderGoodsId;
            // 创建商品类型集合
            HashSet<String> goodsTypeSet = new HashSet<>();
            HashSet<String> goodsNurseSet = new HashSet<>();
            // 创建商品订单对象，并设置商品ID，商品名称，商品介绍，商品类型
            appSureOrderGoodsVo = new AppSureOrderGoodsVo();
            useCoupon = 0;
            goodsId = appPlaceActivityDto.getGoodsId();
            goods = remoteGoodsService.getGoods(goodsId).getData();
            appSureOrderGoodsVo.setGoodsId(goodsId);
            appSureOrderGoodsVo.setGoodsName(goods.getGoodsName());
            appSureOrderGoodsVo.setGoodsIntroduction(goods.getGoodsIntroduction());
            appSureOrderGoodsVo.setGoodsType(goods.getGoodsType());
            // 获取商品图片
            goodsFile = remoteGoodsService.getGoodsFile(goodsId).getData();
            appSureOrderGoodsVo.setGoodsPicture(goodsFile.getFileUrl());
            // 设置购买数量，商品价格，服务数量
            appSureOrderGoodsVo.setBuyNum(buyNum);
            serviceNum = goods.getServiceNum();
            // 获取活动价格
            goodsPrice = activityGoodsGetVo.getActivityPrice();
            appSureOrderGoodsVo.setGoodsPrice(goodsPrice);
            // 计算商品总价，商品实际价格
            buyNumBig = BigDecimal.valueOf(buyNum);
            goodsTotalPrice = goodsPrice.multiply(buyNumBig);
            goodsRealPrice = goodsTotalPrice;
            // 设置使用优惠券，商品总价，优惠券折扣，商品实际价格
            appSureOrderGoodsVo.setUseCoupon(useCoupon);
            appSureOrderGoodsVo.setGoodsTotalPrice(goodsTotalPrice);
            appSureOrderGoodsVo.setCouponDiscount(discountMoney);
            appSureOrderGoodsVo.setGoodsRealPrice(goodsRealPrice);
            // 获取商品押金
            goodsDeposit = activityGoodsGetVo.getActivitySubscription();
            if (goodsDeposit == null || goodsDeposit.compareTo(BigDecimal.ZERO) == 0) {
                goodsDeposit = new BigDecimal("0.00");
            } else {
                goodsDeposit = goodsDeposit.multiply(buyNumBig);
            }
            appSureOrderGoodsVo.setGoodsDeposit(goodsDeposit);
            // 计算商品数量，订单商品金额，优惠券折扣，订单支付押金，订单支付金额
            goodsNum = goodsNum + buyNum;
            orderGoodsMoney = orderGoodsMoney.add(goodsTotalPrice);
            couponDiscount = couponDiscount.add(discountMoney);
            orderPayDeposit = orderPayDeposit.add(goodsDeposit);
            orderPayMoney = orderPayMoney.add(goodsRealPrice);
            // 创建订单商品，并设置订单商品ID，删除标志，订单ID，商品ID，购买数量，商品价格，商品押金，商品总金额，商品应收金额，周期数量标志，服务数量，商品类型，商品名称，商品图片
            orderGoods = new OrderGoods();
            orderGoodsId = IdUtils.simpleUUID();
            orderGoods.setOrderGoodsId(orderGoodsId);
            orderGoods.setDelFlag(0);
            orderGoods.setOrderId(orderId);
            orderGoods.setGoodsId(goodsId);
            orderGoods.setBuyNum(buyNum);
            orderGoods.setGoodsPrice(goodsPrice);
            orderGoods.setGoodsDeposit(goodsDeposit);
            orderGoods.setGoodsTotalMoney(orderGoodsMoney);
            orderGoods.setGoodsReceivableMoney(goodsRealPrice);
            orderGoods.setCycleNumFlag(goods.getCycleNumFlag());
            orderGoods.setServiceNum(serviceNum);
            orderGoods.setGoodsType(goods.getGoodsType());
            orderGoods.setGoodsTag(goods.getGoodsTags());
            orderGoods.setGoodsName(goods.getGoodsName());
            orderGoods.setGoodsIntroduction(goods.getGoodsIntroduction());
            orderGoods.setGoodsPicture(goodsFile.getFileUrl());
            // 保存订单商品
            orderGoodsService.save(orderGoods);
            // 清空购物车
            AppShoppingCartDelDto appShoppingCartDelDto = new AppShoppingCartDelDto();
            appShoppingCartDelDto.setGoodsId(goodsId);
            appShoppingCartDelDto.setUserId(userId);
            remoteShoppingCartService.deleteShoppingCart(appShoppingCartDelDto);
            // 根据商品类型添加到商品类型集合中
            if (goods.getGoodsType() == 1) {
                goodsTypeSet.add("周期");
            } else if (goods.getGoodsType() == 2) {
                goodsTypeSet.add("服务");
            } else if (goods.getGoodsType() == 3) {
                goodsTypeSet.add("体验");
            } else if (goods.getGoodsType() == 4) {
                goodsTypeSet.add("单品");
            }
            String goodsNurse = goods.getGoodsNurses();
            if (StringUtils.isNotBlank(goodsNurse)) {
                String[] goodsNurseArr = goodsNurse.split(",");
                for (String str : goodsNurseArr) {
                    goodsNurseSet.add(str);
                }
            }
            // 创建订单，并设置订单ID，删除标志，订单状态，订单号，订单来源，店铺ID，用户ID，订单金额，优惠券金额，折扣金额，应收金额，应收押金，变动应收金额，支付类型
            Order order = new Order();
            order.setOrderId(orderId);
            order.setDelFlag(0);
            order.setOrderStatus(1);
            order.setOrderNo(orderNo);
            order.setOrderFrom(2);
            order.setShopId(appPlaceActivityDto.getShopId());
            order.setUserId(userId);
            order.setOrderMoney(orderGoodsMoney);
            order.setCouponMoney(couponDiscount);
            order.setDiscountMoney(couponDiscount);
            order.setReceivableMoney(orderPayMoney);
            order.setReceivableDeposit(orderPayDeposit);
            order.setActivityId(activityId);
            order.setActivityName(activityGoodsGetVo.getActivityName());
            order.setOfflinePayMoney(BigDecimal.ZERO);
            // 根据支付类型设置订单支付金额，在线支付金额，订单支付金额，未支付金额，关闭标志
            if (appPlaceActivityDto.getPayType() == 1) {
                order.setPayMoney(orderPayMoney);
                order.setOnlinePayMoney(orderPayMoney);
                appPlaceOrderVo.setPayMoney(orderPayMoney);
                appPlaceOrderVo.setUnpaidMoney(order.getReceivableMoney().subtract(order.getPayMoney()));
                order.setPayType(1);
                order.setCloseFlag(1);
                order.setChangeReceivableMoney(orderGoodsMoney.subtract(couponDiscount));
            } else if (appPlaceActivityDto.getPayType() == 2) {
                order.setPayMoney(orderPayDeposit);
                order.setOnlinePayMoney(orderPayDeposit);
                appPlaceOrderVo.setPayMoney(orderPayDeposit);
                appPlaceOrderVo.setUnpaidMoney(order.getReceivableMoney().subtract(order.getPayMoney()));
                order.setPayType(2);
                order.setCloseFlag(0);
                order.setChangeReceivableMoney(orderGoodsMoney.subtract(couponDiscount).subtract(orderPayDeposit));
            }
            // 设置订单备注，商品数量，创建时间
            order.setOrderRemark(appPlaceActivityDto.getOrderRemark());
            order.setGoodsNum(goodsNum);
            order.setCreateTime(new Date());
            if(appPlaceActivityDto.getNewMemberFlag()!=null&&appPlaceActivityDto.getNewMemberFlag()==1){
                order.setNewMemberFlag(1);
            }
            // 保存订单
            this.save(order);
            // 更新用户商品类型
            if (goodsTypeSet != null || goodsNurseSet != null) {
                AppMemberGoodsTypeDto appMemberGoodsTypeDto = new AppMemberGoodsTypeDto();
                appMemberGoodsTypeDto.setUserId(userId);
                appMemberGoodsTypeDto.setGoodsTypeSet(goodsTypeSet);
                appMemberGoodsTypeDto.setGoodsNurseSet(goodsNurseSet);
                remoteMemberService.updateMemberGoodsType(appMemberGoodsTypeDto);
            }
            // 设置订单ID和订单号
            appPlaceOrderVo.setOrderId(orderId);
            appPlaceOrderVo.setOrderNo(orderNo);
            //改变活动库存
            AGStockChangeDto agStockChangeDto = new AGStockChangeDto();
            agStockChangeDto.setActivityId(activityId);
            agStockChangeDto.setGoodsId(goodsId);
            agStockChangeDto.setChangeType(2);
            agStockChangeDto.setChangeNum(buyNum);
            agStockChangeDto.setShopId(order.getShopId());
            agStockChangeDto.setUserId(order.getUserId());
            remoteActivityService.changeActivityStock(agStockChangeDto);
            //支付金额大于0走支付 负责直接完成订单
            if(appPlaceOrderVo.getPayMoney().compareTo(BigDecimal.ZERO)>0){
                String outTradeNo = IdUtils.simpleUUID();
                // 保存订单 交易流水
                order.setOutTradeNo(outTradeNo);
                this.saveOrUpdate(order);
                //自动取消订单任务时间获取
                Integer delayTime = 30;
                if (redisService.hasKey(SecurityConstant.AUTO_CANCEL_ORDER_TIME)) {
                    delayTime = redisService.getCacheObject(SecurityConstant.AUTO_CANCEL_ORDER_TIME);
                }
                appPlaceOrderVo.setEndTime(DateUtils.addMinutes(order.getCreateTime(), delayTime));
                // 小程序微信下单支付
                createWxPayInfo(appPlaceOrderVo, userId, order.getShopId(), orderGoods.getGoodsName(), outTradeNo,
                        orderId, order.getPayMoney(), appPlaceActivityDto.getOpenid(),
                        appPlaceActivityDto.getSpbillCreateIp());
                //生成自动取消订单延时任务
                String payStr = appPlaceOrderVo.getAppId()+"-"+appPlaceOrderVo.getTimeStamp()+"-"+appPlaceOrderVo.getNonceStr()+"-"+appPlaceOrderVo.getPackageStr()+"-"+appPlaceOrderVo.getSignType()+"-"+appPlaceOrderVo.getPaySign();
                redisService.setCacheObject(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + orderId, payStr , delayTime.longValue(), TimeUnit.MINUTES);
                DelayTask delayTask = new DelayTask();
                delayTask.setDelFlag(0);
                delayTask.setCreateTime(new Date());
                delayTask.setEndTime(DateUtils.addMinutes(new Date(), delayTime));
                delayTask.setRedisKey(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + orderId);
                remoteConfigService.addDelayTask(delayTask);
                appPlaceOrderVo.setZeroFlag(0);
            }else{
                order.setOrderStatus(2);
                this.saveOrUpdate(order);
                appPlaceOrderVo.setZeroFlag(1);
            }
            //生成活动参加记录
            ActivityRecord activityRecord = new ActivityRecord();
            activityRecord.setDelFlag(0);
            activityRecord.setActivityId(activityId);
            activityRecord.setUserId(userId);
            activityRecord.setOrderTime(order.getCreateTime());
            activityRecord.setOrderMoney(order.getOrderMoney());
            activityRecord.setOrderId(orderId);
            activityRecord.setCreateTime(new Date());
            activityRecord.setBuyNum(orderGoods.getBuyNum());
            activityRecord.setGoodsId(orderGoods.getGoodsId());
            activityRecord.setActivityMoney(activityGoodsGetVo.getActivityPrice());
            remoteActivityService.addActivityRecord(activityRecord);
            //扣除redis库存
            redisService.setCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + activityId + "-" + goodsId, surpNum - buyNum);
        } catch (Exception e){
            log.error("活动订单购买失败:"+e.getMessage());
            throw new ServiceException(e.getMessage());
        } finally {
            redissonLock.unlock();
        }
        // 定义购买数量，服务数量，商品数量
        BigDecimal buyNumBig;
        Integer serviceNum;
        Integer goodsNum = 0;
        // 定义商品，商品文件，商品价格，商品总价，商品实际价格，折扣金额，折扣百分比，商品押金，使用优惠券，订单商品金额，优惠券折扣，订单支付押金，订单支付金额
        Goods goods;
        GoodsFile goodsFile;
        BigDecimal goodsPrice;
        BigDecimal goodsTotalPrice;
        BigDecimal goodsRealPrice;
        BigDecimal discountMoney = new BigDecimal("0.00");
        BigDecimal discountPercent;
        BigDecimal goodsDeposit;
        Integer useCoupon;
        BigDecimal orderGoodsMoney = new BigDecimal("0.00");
        BigDecimal couponDiscount = new BigDecimal("0.00");
        BigDecimal orderPayDeposit = new BigDecimal("0.00");
        BigDecimal orderPayMoney = new BigDecimal("0.00");
        // 创建活动商品对象，并设置活动ID，商品ID，用户ID
        ActivityGoodsGetDto activityGoodsGetDto = new ActivityGoodsGetDto();
        activityGoodsGetDto.setActivityId(activityId);
        activityGoodsGetDto.setGoodsId(goodsId);
        activityGoodsGetDto.setUserId(userId);
        // 获取用户活动商品
        ActivityGoodsGetVo activityGoodsGetVo = remoteActivityService.getUserActivityGoods(activityGoodsGetDto).getData();
        // 检查活动状态
        if (activityGoodsGetVo.getActivityStatus() == 0) {
            throw new ServiceException(AppErrorConstant.ACTIVITY_NO_START);
        }
        if (activityGoodsGetVo.getActivityStatus() == 2) {
            throw new ServiceException(AppErrorConstant.ACTIVITY_END);
        }
        if (activityGoodsGetVo.getAvailableBuyNum() < 1) {
            throw new ServiceException(AppErrorConstant.ACTIVITY_GOODS_NULL);
        }
        if (activityGoodsGetVo.getAvailableBuyNum() < buyNum) {
            throw new ServiceException(AppErrorConstant.ACTIVITY_GOODS_BEYOND);
        }
        // 创建订单ID和订单号
        String orderId = IdUtils.simpleUUID();
        String orderNo = CodeFactoryUtil.getShopOrderNo();
        // 创建订单商品对象和订单商品ID
        OrderGoods orderGoods;
        String orderGoodsId;
        // 创建商品类型集合
        HashSet<String> goodsTypeSet = new HashSet<>();
        HashSet<String> goodsNurseSet = new HashSet<>();
        // 创建商品订单对象，并设置商品ID，商品名称，商品介绍，商品类型
        appSureOrderGoodsVo = new AppSureOrderGoodsVo();
        useCoupon = 0;
        goodsId = appPlaceActivityDto.getGoodsId();
        goods = remoteGoodsService.getGoods(goodsId).getData();
        appSureOrderGoodsVo.setGoodsId(goodsId);
        appSureOrderGoodsVo.setGoodsName(goods.getGoodsName());
        appSureOrderGoodsVo.setGoodsIntroduction(goods.getGoodsIntroduction());
        appSureOrderGoodsVo.setGoodsType(goods.getGoodsType());
        // 获取商品图片
        goodsFile = remoteGoodsService.getGoodsFile(goodsId).getData();
        appSureOrderGoodsVo.setGoodsPicture(goodsFile.getFileUrl());
        // 设置购买数量，商品价格，服务数量
        appSureOrderGoodsVo.setBuyNum(buyNum);
        goodsPrice = goods.getSalesPrice();
        serviceNum = goods.getServiceNum();
        // 获取活动价格
        goodsPrice = activityGoodsGetVo.getActivityPrice();
        appSureOrderGoodsVo.setGoodsPrice(goodsPrice);
        // 计算商品总价，商品实际价格
        buyNumBig = BigDecimal.valueOf(buyNum);
        goodsTotalPrice = goodsPrice.multiply(buyNumBig);
        goodsRealPrice = goodsTotalPrice;
        // 设置使用优惠券，商品总价，优惠券折扣，商品实际价格
        appSureOrderGoodsVo.setUseCoupon(useCoupon);
        appSureOrderGoodsVo.setGoodsTotalPrice(goodsTotalPrice);
        appSureOrderGoodsVo.setCouponDiscount(discountMoney);
        appSureOrderGoodsVo.setGoodsRealPrice(goodsRealPrice);
        // 获取商品押金
        goodsDeposit = activityGoodsGetVo.getActivitySubscription();
        if (goodsDeposit == null || goodsDeposit.compareTo(BigDecimal.ZERO) == 0) {
            goodsDeposit = new BigDecimal("0.00");
        } else {
            goodsDeposit = goodsDeposit.multiply(buyNumBig);
        }
        appSureOrderGoodsVo.setGoodsDeposit(goodsDeposit);
        // 计算商品数量，订单商品金额，优惠券折扣，订单支付押金，订单支付金额
        goodsNum = goodsNum + buyNum;
        orderGoodsMoney = orderGoodsMoney.add(goodsTotalPrice);
        couponDiscount = couponDiscount.add(discountMoney);
        orderPayDeposit = orderPayDeposit.add(goodsDeposit);
        orderPayMoney = orderPayMoney.add(goodsRealPrice);
        // 创建订单商品，并设置订单商品ID，删除标志，订单ID，商品ID，购买数量，商品价格，商品押金，商品总金额，商品应收金额，周期数量标志，服务数量，商品类型，商品名称，商品图片
        orderGoods = new OrderGoods();
        orderGoodsId = IdUtils.simpleUUID();
        orderGoods.setOrderGoodsId(orderGoodsId);
        orderGoods.setDelFlag(0);
        orderGoods.setOrderId(orderId);
        orderGoods.setGoodsId(goodsId);
        orderGoods.setBuyNum(buyNum);
        orderGoods.setGoodsPrice(goodsPrice);
        orderGoods.setGoodsDeposit(goodsDeposit);
        orderGoods.setGoodsTotalMoney(orderGoodsMoney);
        orderGoods.setGoodsReceivableMoney(goodsRealPrice);
        orderGoods.setCycleNumFlag(goods.getCycleNumFlag());
        orderGoods.setServiceNum(serviceNum);
        orderGoods.setGoodsType(goods.getGoodsType());
        orderGoods.setGoodsTag(goods.getGoodsTags());
        orderGoods.setGoodsName(goods.getGoodsName());
        orderGoods.setGoodsIntroduction(goods.getGoodsIntroduction());
        orderGoods.setGoodsPicture(goodsFile.getFileUrl());
        // 保存订单商品
        orderGoodsService.save(orderGoods);
        // 清空购物车
        AppShoppingCartDelDto appShoppingCartDelDto = new AppShoppingCartDelDto();
        appShoppingCartDelDto.setGoodsId(goodsId);
        appShoppingCartDelDto.setUserId(userId);
        remoteShoppingCartService.deleteShoppingCart(appShoppingCartDelDto);
        // 根据商品类型添加到商品类型集合中
        if (goods.getGoodsType() == 1) {
            goodsTypeSet.add("周期");
        } else if (goods.getGoodsType() == 2) {
            goodsTypeSet.add("服务");
        } else if (goods.getGoodsType() == 3) {
            goodsTypeSet.add("体验");
        } else if (goods.getGoodsType() == 4) {
            goodsTypeSet.add("单品");
        }
        String goodsNurse = goods.getGoodsNurses();
        if (StringUtils.isNotBlank(goodsNurse)) {
            String[] goodsNurseArr = goodsNurse.split(",");
            for (String str : goodsNurseArr) {
                goodsNurseSet.add(str);
            }
        }
        // 创建订单，并设置订单ID，删除标志，订单状态，订单号，订单来源，店铺ID，用户ID，订单金额，优惠券金额，折扣金额，应收金额，应收押金，变动应收金额，支付类型
        Order order = new Order();
        order.setOrderId(orderId);
        order.setDelFlag(0);
        order.setOrderStatus(1);
        order.setOrderNo(orderNo);
        order.setOrderFrom(2);
        order.setShopId(appPlaceActivityDto.getShopId());
        order.setUserId(userId);
        order.setOrderMoney(orderGoodsMoney);
        order.setCouponMoney(couponDiscount);
        order.setDiscountMoney(couponDiscount);
        order.setReceivableMoney(orderPayMoney);
        order.setReceivableDeposit(orderPayDeposit);
        order.setActivityId(activityId);
        order.setActivityName(activityGoodsGetVo.getActivityName());
        order.setOfflinePayMoney(BigDecimal.ZERO);
        // 根据支付类型设置订单支付金额，在线支付金额，订单支付金额，未支付金额，关闭标志
        if (appPlaceActivityDto.getPayType() == 1) {
            order.setPayMoney(orderPayMoney);
            order.setOnlinePayMoney(orderPayMoney);
            appPlaceOrderVo.setPayMoney(orderPayMoney);
            appPlaceOrderVo.setUnpaidMoney(order.getReceivableMoney().subtract(order.getPayMoney()));
            order.setPayType(1);
            order.setCloseFlag(1);
            order.setChangeReceivableMoney(orderGoodsMoney.subtract(couponDiscount));
        } else if (appPlaceActivityDto.getPayType() == 2) {
            order.setPayMoney(orderPayDeposit);
            order.setOnlinePayMoney(orderPayDeposit);
            appPlaceOrderVo.setPayMoney(orderPayDeposit);
            appPlaceOrderVo.setUnpaidMoney(order.getReceivableMoney().subtract(order.getPayMoney()));
            order.setPayType(2);
            order.setCloseFlag(0);
            order.setChangeReceivableMoney(orderGoodsMoney.subtract(couponDiscount).subtract(orderPayDeposit));
        }
        // 设置订单备注，商品数量，创建时间
        order.setOrderRemark(appPlaceActivityDto.getOrderRemark());
        order.setGoodsNum(goodsNum);
        order.setCreateTime(new Date());
        if(appPlaceActivityDto.getNewMemberFlag()!=null&&appPlaceActivityDto.getNewMemberFlag()==1){
            order.setNewMemberFlag(1);
        }
        // 保存订单
        this.save(order);
        // 更新用户商品类型
        if (goodsTypeSet != null || goodsNurseSet != null) {
            AppMemberGoodsTypeDto appMemberGoodsTypeDto = new AppMemberGoodsTypeDto();
            appMemberGoodsTypeDto.setUserId(userId);
            appMemberGoodsTypeDto.setGoodsTypeSet(goodsTypeSet);
            appMemberGoodsTypeDto.setGoodsNurseSet(goodsNurseSet);
            remoteMemberService.updateMemberGoodsType(appMemberGoodsTypeDto);
        }
        // 设置订单ID和订单号
        appPlaceOrderVo.setOrderId(orderId);
        appPlaceOrderVo.setOrderNo(orderNo);
        //改变活动库存
        AGStockChangeDto agStockChangeDto = new AGStockChangeDto();
        agStockChangeDto.setActivityId(activityId);
        agStockChangeDto.setGoodsId(goodsId);
        agStockChangeDto.setChangeType(2);
        agStockChangeDto.setChangeNum(buyNum);
        agStockChangeDto.setShopId(order.getShopId());
        agStockChangeDto.setUserId(order.getUserId());
        remoteActivityService.changeActivityStock(agStockChangeDto);
        //支付金额大于0走支付 负责直接完成订单
        if(appPlaceOrderVo.getPayMoney().compareTo(BigDecimal.ZERO)>0){
            List<String> goodsNameList = new ArrayList<>();
            goodsNameList.add(orderGoods.getGoodsName());
            String outTradeNo = IdUtils.simpleUUID();
            // 保存订单 交易流水
            order.setOutTradeNo(outTradeNo);
            this.saveOrUpdate(order);
            //自动取消订单任务时间获取
            Integer delayTime = 30;
            if (redisService.hasKey(SecurityConstant.AUTO_CANCEL_ORDER_TIME)) {
                delayTime = redisService.getCacheObject(SecurityConstant.AUTO_CANCEL_ORDER_TIME);
            }
            appPlaceOrderVo.setEndTime(DateUtils.addMinutes(order.getCreateTime(), delayTime));
            // 小程序微信下单支付
            createWxPayInfo(appPlaceOrderVo, userId, order.getShopId(), orderGoods.getGoodsName(), outTradeNo,
                    orderId, order.getPayMoney(), appPlaceActivityDto.getOpenid(),
                    appPlaceActivityDto.getSpbillCreateIp(), goodsNameList,2);
            //生成自动取消订单延时任务
            String payStr = appPlaceOrderVo.getAppId()+"-"+appPlaceOrderVo.getTimeStamp()+"-"+appPlaceOrderVo.getNonceStr()+"-"+appPlaceOrderVo.getPackageStr()+"-"+appPlaceOrderVo.getSignType()+"-"+appPlaceOrderVo.getPaySign();
            redisService.setCacheObject(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + orderId, payStr , delayTime.longValue(), TimeUnit.MINUTES);
            DelayTask delayTask = new DelayTask();
            delayTask.setDelFlag(0);
            delayTask.setCreateTime(new Date());
            delayTask.setEndTime(DateUtils.addMinutes(new Date(), delayTime));
            delayTask.setRedisKey(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + orderId);
            remoteConfigService.addDelayTask(delayTask);
            appPlaceOrderVo.setZeroFlag(0);
        }else{
            order.setOrderStatus(2);
            this.saveOrUpdate(order);
            appPlaceOrderVo.setZeroFlag(1);
        }
        //生成活动参加记录
        ActivityRecord activityRecord = new ActivityRecord();
        activityRecord.setDelFlag(0);
        activityRecord.setActivityId(activityId);
        activityRecord.setUserId(userId);
        activityRecord.setOrderTime(order.getCreateTime());
        activityRecord.setOrderMoney(order.getOrderMoney());
        activityRecord.setOrderId(orderId);
        activityRecord.setCreateTime(new Date());
        activityRecord.setBuyNum(orderGoods.getBuyNum());
        activityRecord.setGoodsId(orderGoods.getGoodsId());
        activityRecord.setActivityMoney(activityGoodsGetVo.getActivityPrice());
        remoteActivityService.addActivityRecord(activityRecord);
        return appPlaceOrderVo;
    }

@@ -1397,11 +1388,71 @@
        if (order.getOrderStatus() != 2) {
            throw new ServiceException(AppErrorConstant.VERIFY_USED);
        }
        if (!order.getShopId().equals(shopId)) {
            throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
        }
        // 根据订单用户ID获取用户信息
        Member member = remoteMemberService.getMember(order.getUserId()).getData();
        // 根据订单ID获取订单商品列表
        List<AppUserOrderGoodsPageVo> appUserOrderGoodsPageVoList = orderGoodsService.listAppVoByOrderId(orderId);
        //绑定用户判断核销商户
        if(member.getBindingFlag()==1){
            //绑定用户需直接判断商户
            if (!order.getShopId().equals(shopId)) {
                throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
            }
        }else{
            //商城订单需判断商户
            if(order.getOrderFrom()==1){
                if (!order.getShopId().equals(shopId)) {
                    throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                }
            }
            //未绑定用户需判断核销商城订单判断商品单价和优惠券
            /*StringJoiner goodsIdSJ = new StringJoiner(",");
            for (AppUserOrderGoodsPageVo appUserOrderGoodsPageVo : appUserOrderGoodsPageVoList) {
                goodsIdSJ.add(appUserOrderGoodsPageVo.getGoodsId());
            }
            //获取商品列表
            List<Goods> goodsList = remoteGoodsService.listGoodsByGoodsId(goodsIdSJ.toString()).getData();
            Map<String, Goods> goodsMap = goodsList.stream()
                    .collect(Collectors.toMap(Goods::getGoodsId, Function.identity()));
            Goods goods;
            ShopGoods shopGoods;
            AppShopGoodsGetDto appShopGoodsGetDto;
            for (AppUserOrderGoodsPageVo appUserOrderGoodsPageVo : appUserOrderGoodsPageVoList) {
                appShopGoodsGetDto= new AppShopGoodsGetDto();
                appShopGoodsGetDto.setShopId(shopId);
                appShopGoodsGetDto.setGoodsId(appUserOrderGoodsPageVo.getGoodsId());
                shopGoods = remoteGoodsService.getShopGoods(appShopGoodsGetDto).getData();
                goods = goodsMap.get(appUserOrderGoodsPageVo.getGoodsId());
                //当商户定制价格不为空时判断商品定制价格否则判断商品价格是否一致
                if(shopGoods!=null){
                    if(shopGoods.getSalesPrice().compareTo(appUserOrderGoodsPageVo.getGoodsPrice())!=0){
                        throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                    }
                    if(appUserOrderGoodsPageVo.getCycleNumFlag()==0){
                        if(shopGoods.getServiceNum()!=null){
                            throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                        }
                    }else{
                        if(shopGoods.getServiceNum()!=appUserOrderGoodsPageVo.getServiceNum()){
                            throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                        }
                    }
                }else{
                    if(goods.getSalesPrice().compareTo(appUserOrderGoodsPageVo.getGoodsPrice())!=0){
                        throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                    }
                    if(appUserOrderGoodsPageVo.getCycleNumFlag()==0){
                        if(goods.getServiceNum()!=null){
                            throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                        }
                    }else{
                        if(goods.getServiceNum()!=appUserOrderGoodsPageVo.getServiceNum()){
                            throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                        }
                    }
                }
            }*/
        }
        // 设置返回对象的属性值
        merVerifyOrderVo.setOrderId(orderId);
        merVerifyOrderVo.setOrderNo(order.getOrderNo());
@@ -1433,8 +1484,6 @@
            }
        }
        merVerifyOrderVo.setUnReceiveMoney(merVerifyOrderVo.getRealReceiveMoney().subtract(merVerifyOrderVo.getReceiveMoney()));
        // 根据订单用户ID获取用户信息
        Member member = remoteMemberService.getMember(order.getUserId()).getData();
        merVerifyOrderVo.setUserId(order.getUserId());
        merVerifyOrderVo.setUserName(member.getRealName());
        merVerifyOrderVo.setUserMobile(member.getMobile());
@@ -1462,11 +1511,74 @@
        if (order.getOrderStatus() != 2) {
            throw new ServiceException(AppErrorConstant.VERIFY_USED);
        }

        Member member = remoteMemberService.getMember(order.getUserId()).getData();
        //获取核销商户
        ShopRelUserVo shopRelUserVo = remoteShopService.getShopByUserId(merVerifyOrderDto.getUserId()).getData();
        if (!shopRelUserVo.getShopId().equals(order.getShopId())) {
            throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
        Long shopId = shopRelUserVo.getShopId();
        //获取订单商品列表
        List<AppUserOrderGoodsPageVo> appUserOrderGoodsPageVoList = orderGoodsService.listAppVoByOrderId(orderId);
        //绑定用户判断核销商户
        if(member.getBindingFlag()==1){
            //绑定用户需直接判断商户
            if (!order.getShopId().equals(shopId)) {
                throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
            }
        }else{
            //商城订单需判断商户
            if(order.getOrderFrom()==1){
                if (!order.getShopId().equals(shopId)) {
                    throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                }
            }
            //未绑定用户需判断核销商城订单判断商品单价和优惠券
            /*StringJoiner goodsIdSJ = new StringJoiner(",");
            for (AppUserOrderGoodsPageVo appUserOrderGoodsPageVo : appUserOrderGoodsPageVoList) {
                goodsIdSJ.add(appUserOrderGoodsPageVo.getGoodsId());
            }
            //获取商品列表
            List<Goods> goodsList = remoteGoodsService.listGoodsByGoodsId(goodsIdSJ.toString()).getData();
            Map<String, Goods> goodsMap = goodsList.stream()
                    .collect(Collectors.toMap(Goods::getGoodsId, Function.identity()));
            Goods goods;
            ShopGoods shopGoods;
            AppShopGoodsGetDto appShopGoodsGetDto;
            for (AppUserOrderGoodsPageVo appUserOrderGoodsPageVo : appUserOrderGoodsPageVoList) {
                appShopGoodsGetDto= new AppShopGoodsGetDto();
                appShopGoodsGetDto.setShopId(shopId);
                appShopGoodsGetDto.setGoodsId(appUserOrderGoodsPageVo.getGoodsId());
                shopGoods = remoteGoodsService.getShopGoods(appShopGoodsGetDto).getData();
                goods = goodsMap.get(appUserOrderGoodsPageVo.getGoodsId());
                //当商户定制价格不为空时判断商品定制价格否则判断商品价格是否一致
                if(shopGoods!=null){
                    if(shopGoods.getSalesPrice().compareTo(appUserOrderGoodsPageVo.getGoodsPrice())!=0){
                        throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                    }
                    if(appUserOrderGoodsPageVo.getCycleNumFlag()==0){
                        if(shopGoods.getServiceNum()!=null){
                            throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                        }
                    }else{
                        if(shopGoods.getServiceNum()!=appUserOrderGoodsPageVo.getServiceNum()){
                            throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                        }
                    }
                }else{
                    if(goods.getSalesPrice().compareTo(appUserOrderGoodsPageVo.getGoodsPrice())!=0){
                        throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                    }
                    if(appUserOrderGoodsPageVo.getCycleNumFlag()==0){
                        if(goods.getServiceNum()!=null){
                            throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                        }
                    }else{
                        if(goods.getServiceNum()!=appUserOrderGoodsPageVo.getServiceNum()){
                            throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
                        }
                    }
                }
            }*/
        }
        order.setShopId(shopId);
        order.setOrderStatus(3);
        order.setUseTime(nowTime);
        order.setUseUserId(merVerifyOrderDto.getUserId());
@@ -1474,6 +1586,7 @@
        order.setOffPayTime(nowTime);
        order.setPayMoney(order.getPayMoney().add(relPayMoney));
        order.setChangeReceivableMoney(relReceiveMoney);
        //判断订单是否结清
        if (order.getPayMoney().compareTo(order.getChangeReceivableMoney()) >= 0) {
            order.setCloseFlag(1);
        } else {
@@ -1481,7 +1594,7 @@
        }
        this.saveOrUpdate(order);
        //创建服务商品
        List<AppUserOrderGoodsPageVo> appUserOrderGoodsPageVoList = orderGoodsService.listAppVoByOrderId(orderId);
        //获取商品信息(商品简介,调理问题)
        StringJoiner goodsIdSj = new StringJoiner(",");
        for (AppUserOrderGoodsPageVo appUserOrderGoodsPageVo : appUserOrderGoodsPageVoList) {
            goodsIdSj.add(appUserOrderGoodsPageVo.getGoodsId());
@@ -1493,9 +1606,11 @@
        ConsumerGoods consumerGoods;
        String consumerGoodsId;
        Goods goods;
        //循环生成商品服务
        List<ConsumerGoods> consumerGoodsList = new ArrayList<>();
        for (AppUserOrderGoodsPageVo appUserOrderGoodsPageVo : appUserOrderGoodsPageVoList) {
            Integer buyNum = appUserOrderGoodsPageVo.getBuyNum();
            //判断是否次数未确认商品 是则创建未确认周期商品服务 否则循环创建商品服务
            if (appUserOrderGoodsPageVo.getCycleNumFlag() == 0) {
                consumerGoods = new ConsumerGoods();
                goods = goodsMap.get(appUserOrderGoodsPageVo.getGoodsId());
@@ -1559,11 +1674,6 @@
        merVerifyOrderVo.setOrderGoodsMoney(order.getOrderMoney());
        merVerifyOrderVo.setCouponDiscount(order.getCouponMoney());
        merVerifyOrderVo.setReceivableDeposit(order.getReceivableDeposit());
        if(order.getPayType()==1){
            merVerifyOrderVo.setReceivableMoney(order.getOrderMoney().subtract(order.getPayMoney()));
        }else{
            merVerifyOrderVo.setReceivableMoney(order.getOrderMoney().subtract(order.getCouponMoney()).subtract(order.getReceivableDeposit()));
        }
        merVerifyOrderVo.setPayMoney(order.getPayMoney());
        merVerifyOrderVo.setOrderRemark(order.getOrderRemark());
        merVerifyOrderVo.setAppUserOrderGoodsPageVoList(appUserOrderGoodsPageVoList);
@@ -1572,9 +1682,12 @@
        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{
@@ -1582,17 +1695,24 @@
            }
        }
        merVerifyOrderVo.setUnReceiveMoney(merVerifyOrderVo.getRealReceiveMoney().subtract(merVerifyOrderVo.getReceiveMoney()));
        Member member = remoteMemberService.getMember(order.getUserId()).getData();
        merVerifyOrderVo.setUserId(order.getUserId());
        merVerifyOrderVo.setUserName(member.getRealName());
        merVerifyOrderVo.setUserMobile(member.getMobile());
        merVerifyOrderVo.setCloseFlag(order.getCloseFlag());
        // TODO  活动才分账
        if (order.getOrderFrom() == 2) {
            // 活动才分账
            submitProfitSharing(orderId, order.getOrderNo(), order.getShopId(), order.getOnlinePayMoney());
        //判断用户是否绑定  2023-09-05需求改变核销时绑定用户
        if (member.getBindingFlag() != 1) {
            //绑定商户
            AppMemberBindingDto appMemberBindingDto = new AppMemberBindingDto();
            appMemberBindingDto.setShopId(order.getShopId());
            appMemberBindingDto.setUserId(order.getUserId());
            appMemberBindingDto.setBindingFlag(1);
            appMemberBindingDto.setBindingType(1);
            remoteMemberService.updateMemberBinding(appMemberBindingDto);
        }

        // 订单金额大于0时进行分账
        if (order.getOnlinePayMoney().compareTo(BigDecimal.ZERO)>0) {
            submitProfitSharing(orderId, order.getOrderNo(), order.getShopId(), order.getOnlinePayMoney(),order.getOrderFrom());
        }
        //创建支付记录
        if(merVerifyOrderDto.getRelPayMoney().compareTo(BigDecimal.ZERO)>0){
            PayRecord payRecord = new PayRecord();
@@ -1610,38 +1730,40 @@
        return merVerifyOrderVo;
    }

    private void submitProfitSharing(String orderId, String orderNo, Long shopId, BigDecimal orderMoney) {
    private void submitProfitSharing(String orderId, String orderNo, Long shopId, BigDecimal orderMoney, Integer orderFrom) {
        String sendMessage = "";
        String resultMessage = "";
        try {
            // 核销完成 开始分账（平台收取服务费）
            OrderPayment payment = orderPaymentService.getByOrderId(orderId);
            String transactionId = payment.getTransactionId();

            // 平台特约商户号，用户平台收取服务费
            String platformTyMacId = WxPayConfiguration.getPlatformTyMacId();

            R<String> resultMch = remoteShopService.getShopSubMchId(shopId);
            String subMchId = resultMch.getData();
            if (StringUtils.isEmpty(subMchId)) {
                throw new ServiceException("获取微信商户号失败");
            }
            // 平台特约商户号，用户平台收取服务费 2023-09-05改变分账方式
            String platformTyMacId = WxPayConfiguration.getPlatformTyMacId();
            if (!StringUtils.isEmpty(subMchId)) {
                WxPayConfig config = wxService.getConfig();

                R<ShopProportionVo> resultShopProportion = remoteShopService.getShopProportion(shopId);
                ShopProportionVo shopProportion = resultShopProportion.getData();
                if (null != shopProportion) {
                ShopProportionVo shopProportion = null;
                BigDecimal proportionPercent = null;
                //商户订单获取统一分成 活动订单获取活动分成
                if(orderFrom==1){
                    proportionPercent = redisService.getCacheObject(SecurityConstant.SHOP_COMMON_PROPORTION);
                }else{
                    R<ShopProportionVo> resultShopProportion = remoteShopService.getShopProportion(shopId);
                    shopProportion = resultShopProportion.getData();
                    proportionPercent = shopProportion.getProportionPercent();
                }
                if (null != proportionPercent) {
                    ProfitSharingRequest request = new ProfitSharingRequest();
                    request.setAppid(config.getAppId());
                    request.setSubMchid(subMchId);
                    request.setSubMchid(platformTyMacId);
                    request.setTransactionId(transactionId);
                    request.setOutOrderNo(IdUtils.simpleUUID());
                    List<ProfitSharingRequest.Receiver> receiverList = new ArrayList<>();

                    String description = "订单:" + orderNo + " 平台抽取佣金";
                    //获取商户分成
                    BigDecimal proportionPercent = shopProportion.getProportionPercent();
                    if (null == proportionPercent) {
                        proportionPercent = BigDecimal.ZERO;
                    }
                    String description = "订单:" + orderNo + " 平台分账";
                    //平台分成
                    proportionPercent = new BigDecimal("100.00").subtract(proportionPercent);
                    if(proportionPercent.compareTo(BigDecimal.ZERO)>0){
@@ -1655,20 +1777,17 @@
                            // 分账创建
                            ProfitSharingRequest.Receiver receiver = new ProfitSharingRequest.Receiver();
                            receiver.setType("MERCHANT_ID");
                            receiver.setReceiverAccount(platformTyMacId);
                            receiver.setReceiverAccount(subMchId);
                            receiver.setAmount(amount);
                            receiver.setDescription(description);

                            receiverList.add(receiver);
                            request.setReceivers(receiverList);
                            // 分账完成
                            request.setFinish(true);
                            result = wxService.getEcommerceService().profitSharing(request);
                        }

                        // 创建分账记录
                        profitSharingService.saveProfitSharing(shopId, orderId, orderMoney, result);

                        // 保存请求信息
                        sendMessage = JSONObject.toJSONString(request);
                        resultMessage = JSONObject.toJSONString(result);
@@ -2809,6 +2928,12 @@
            Boolean noService = true;
            Boolean noExperience = true;
            Boolean noGoods = true;
            mgtTotalOrderTotalVo.setCycleTotal(0);
            mgtTotalOrderTotalVo.setCycleMoney(BigDecimal.ZERO);
            mgtTotalOrderTotalVo.setServiceTotal(0);
            mgtTotalOrderTotalVo.setServiceMoney(BigDecimal.ZERO);
            mgtTotalOrderTotalVo.setExperienceTotal(0);
            mgtTotalOrderTotalVo.setExperienceMoney(BigDecimal.ZERO);
            for (int i = 0; i < MgtMapIntTotalVoGoodsType.size(); i++) {
                mgtMapIntTotalVo = new MgtMapIntTotalVo();
                mgtMapBigTotalVo = new MgtMapBigTotalVo();
@@ -2837,48 +2962,48 @@
                    mgtMapBigTotalVo.setMapKey("单品");
                    noGoods = false;
                }
                //补充缺少类型
                if(noCycle){
                    mgtMapIntTotalVo = new MgtMapIntTotalVo();
                    mgtMapIntTotalVo.setMapKey("周期");
                    mgtMapIntTotalVo.setMapValue(0);
                    goodsTypeTotalList.add(mgtMapIntTotalVo);
                    mgtMapBigTotalVo = new MgtMapBigTotalVo();
                    mgtMapBigTotalVo.setMapKey("周期");
                    mgtMapBigTotalVo.setMapValue(BigDecimal.ZERO);
                    goodsTypeMoneyList.add(mgtMapBigTotalVo);
                }
                if(noService){
                    mgtMapIntTotalVo = new MgtMapIntTotalVo();
                    mgtMapIntTotalVo.setMapKey("服务");
                    mgtMapIntTotalVo.setMapValue(0);
                    goodsTypeTotalList.add(mgtMapIntTotalVo);
                    mgtMapBigTotalVo = new MgtMapBigTotalVo();
                    mgtMapBigTotalVo.setMapKey("服务");
                    mgtMapBigTotalVo.setMapValue(BigDecimal.ZERO);
                    goodsTypeMoneyList.add(mgtMapBigTotalVo);
                }
                if(noExperience){
                    mgtMapIntTotalVo = new MgtMapIntTotalVo();
                    mgtMapIntTotalVo.setMapKey("体验");
                    mgtMapIntTotalVo.setMapValue(0);
                    goodsTypeTotalList.add(mgtMapIntTotalVo);
                    mgtMapBigTotalVo = new MgtMapBigTotalVo();
                    mgtMapBigTotalVo.setMapKey("体验");
                    mgtMapBigTotalVo.setMapValue(BigDecimal.ZERO);
                    goodsTypeMoneyList.add(mgtMapBigTotalVo);
                }
                if(noGoods){
                    mgtMapIntTotalVo = new MgtMapIntTotalVo();
                    mgtMapIntTotalVo.setMapKey("单品");
                    mgtMapIntTotalVo.setMapValue(0);
                    goodsTypeTotalList.add(mgtMapIntTotalVo);
                    mgtMapBigTotalVo = new MgtMapBigTotalVo();
                    mgtMapBigTotalVo.setMapKey("单品");
                    mgtMapBigTotalVo.setMapValue(BigDecimal.ZERO);
                    goodsTypeMoneyList.add(mgtMapBigTotalVo);
                }
                goodsTypeTotalList.add(mgtMapIntTotalVo);
                goodsTypeMoneyList.add(mgtMapBigTotalVo);
            }
            //补充缺少类型
            if(noCycle){
                mgtMapIntTotalVo = new MgtMapIntTotalVo();
                mgtMapIntTotalVo.setMapKey("周期");
                mgtMapIntTotalVo.setMapValue(0);
                goodsTypeTotalList.add(mgtMapIntTotalVo);
                mgtMapBigTotalVo = new MgtMapBigTotalVo();
                mgtMapBigTotalVo.setMapKey("周期");
                mgtMapBigTotalVo.setMapValue(BigDecimal.ZERO);
                goodsTypeMoneyList.add(mgtMapBigTotalVo);
            }
            if(noService){
                mgtMapIntTotalVo = new MgtMapIntTotalVo();
                mgtMapIntTotalVo.setMapKey("服务");
                mgtMapIntTotalVo.setMapValue(0);
                goodsTypeTotalList.add(mgtMapIntTotalVo);
                mgtMapBigTotalVo = new MgtMapBigTotalVo();
                mgtMapBigTotalVo.setMapKey("服务");
                mgtMapBigTotalVo.setMapValue(BigDecimal.ZERO);
                goodsTypeMoneyList.add(mgtMapBigTotalVo);
            }
            if(noExperience){
                mgtMapIntTotalVo = new MgtMapIntTotalVo();
                mgtMapIntTotalVo.setMapKey("体验");
                mgtMapIntTotalVo.setMapValue(0);
                goodsTypeTotalList.add(mgtMapIntTotalVo);
                mgtMapBigTotalVo = new MgtMapBigTotalVo();
                mgtMapBigTotalVo.setMapKey("体验");
                mgtMapBigTotalVo.setMapValue(BigDecimal.ZERO);
                goodsTypeMoneyList.add(mgtMapBigTotalVo);
            }
            if(noGoods){
                mgtMapIntTotalVo = new MgtMapIntTotalVo();
                mgtMapIntTotalVo.setMapKey("单品");
                mgtMapIntTotalVo.setMapValue(0);
                goodsTypeTotalList.add(mgtMapIntTotalVo);
                mgtMapBigTotalVo = new MgtMapBigTotalVo();
                mgtMapBigTotalVo.setMapKey("单品");
                mgtMapBigTotalVo.setMapValue(BigDecimal.ZERO);
                goodsTypeMoneyList.add(mgtMapBigTotalVo);
            }
            mgtTotalOrderTotalVo.setGoodsTypeTotalList(goodsTypeTotalList);
@@ -2960,8 +3085,32 @@
     */
    @Override
    public MgtTotalActivityTotalVo getTotalActivityTotal(MgtBaseShopDto mgtBaseShopDto) {
        MgtTotalActivityTotalVo totalActivityTotalVo = new MgtTotalActivityTotalVo();
        totalActivityTotalVo.setOrderTotal(0);
        totalActivityTotalVo.setCycleTotal(0);
        totalActivityTotalVo.setExperienceTotal(0);
        totalActivityTotalVo.setServiceTotal(0);
        totalActivityTotalVo.setOrderMoney(new BigDecimal("0"));
        totalActivityTotalVo.setCycleMoney(new BigDecimal("0"));
        totalActivityTotalVo.setExperienceMoney(new BigDecimal("0"));
        totalActivityTotalVo.setServiceMoney(new BigDecimal("0"));
        totalActivityTotalVo.setOrderJoinPerson(0);
        totalActivityTotalVo.setOrderPerson(0);
        totalActivityTotalVo.setCyclePerson(0);
        totalActivityTotalVo.setExperiencePerson(0);
        totalActivityTotalVo.setServicePerson(0);
        totalActivityTotalVo.setOrderTotalKey(new String[0]);
        totalActivityTotalVo.setOrderTotalValue(new Integer[0]);
        totalActivityTotalVo.setOrderMoneyValue(new BigDecimal[0]);
        totalActivityTotalVo.setGoodsTypeTotalList(Lists.newArrayList());
        totalActivityTotalVo.setGoodsTypeMoneyList(Lists.newArrayList());
        totalActivityTotalVo.setJoinMemberTotalKey(new String[0]);
        totalActivityTotalVo.setJoinMemberTotalValue(new Integer[0]);
        //获取基础统计 总订单数 订单金额 参与人数
        MgtTotalActivityTotalVo totalActivityTotalVo = orderMapper.getTotalActivityTotal(mgtBaseShopDto);
        MgtTotalActivityTotalVo mgtTotalActivityTotalVo = orderMapper.getTotalActivityTotal(mgtBaseShopDto);
        totalActivityTotalVo.setOrderTotal(mgtTotalActivityTotalVo.getOrderTotal());
        totalActivityTotalVo.setOrderMoney(mgtTotalActivityTotalVo.getOrderMoney());
        totalActivityTotalVo.setOrderJoinPerson(mgtTotalActivityTotalVo.getOrderJoinPerson());
        //获客人数
        MgtTotalActivityTotalVo totalActivityMemberTotalVo = orderMapper.getTotalActivityMemberTotal(mgtBaseShopDto);
        totalActivityTotalVo.setOrderPerson(totalActivityMemberTotalVo.getOrderPerson());
@@ -3083,8 +3232,8 @@
            totalActivityTotalVo.setOrderTotalValue(orderTotalValue);
            totalActivityTotalVo.setOrderMoneyValue(orderMoneyValue);
        }
        //参与人数
        List<MgtMapIntTotalVo> joinList = orderMapper.getActivityMemberTotal(mgtBaseShopDto);
        //参与人数  2023-09-06 另开接口
        /*List<MgtMapIntTotalVo> joinList = orderMapper.getActivityMemberTotal(mgtBaseShopDto);
        // 将查询结果转为Map
        Map<String, Integer> mgtMapIntTotalVoMap = new HashMap<>();
        if (joinList != null && !joinList.isEmpty()) {
@@ -3107,7 +3256,7 @@
            joinMemberTotalValue[i] = (value != null) ? value : 0;
        }
        totalActivityTotalVo.setJoinMemberTotalKey(joinMemberTotalKey);
        totalActivityTotalVo.setJoinMemberTotalValue(joinMemberTotalValue);
        totalActivityTotalVo.setJoinMemberTotalValue(joinMemberTotalValue);*/
        return totalActivityTotalVo;
    }

@@ -3319,14 +3468,49 @@
                mgtBasePlatformDto.setUserIdList(userIdList);
            }
        }
        MgtTotalOrderTotalVo mgtTotalOrderTotalVo = new MgtTotalOrderTotalVo();
        mgtTotalOrderTotalVo.setOrderTotal(0);
        mgtTotalOrderTotalVo.setOnlineTotal(0);
        mgtTotalOrderTotalVo.setOfflineTotal(0);
        mgtTotalOrderTotalVo.setActivityTotal(0);
        mgtTotalOrderTotalVo.setCycleTotal(0);
        mgtTotalOrderTotalVo.setExperienceTotal(0);
        mgtTotalOrderTotalVo.setServiceTotal(0);
        mgtTotalOrderTotalVo.setOrderMoney(new BigDecimal("0"));
        mgtTotalOrderTotalVo.setOnlineMoney(new BigDecimal("0"));
        mgtTotalOrderTotalVo.setOfflineMoney(new BigDecimal("0"));
        mgtTotalOrderTotalVo.setActivityMoney(new BigDecimal("0"));
        mgtTotalOrderTotalVo.setCycleMoney(new BigDecimal("0"));
        mgtTotalOrderTotalVo.setExperienceMoney(new BigDecimal("0"));
        mgtTotalOrderTotalVo.setServiceMoney(new BigDecimal("0"));
        mgtTotalOrderTotalVo.setOrderTotalKey(new String[0]);
        mgtTotalOrderTotalVo.setOrderTotalValue(new Integer[0]);
        mgtTotalOrderTotalVo.setOrderMoneyValue(new BigDecimal[0]);
        mgtTotalOrderTotalVo.setGoodsTypeTotalList(Lists.newArrayList());
        mgtTotalOrderTotalVo.setGoodsTypeMoneyList(Lists.newArrayList());
        mgtTotalOrderTotalVo.setGoodsRankList(Lists.newArrayList());
        mgtTotalOrderTotalVo.setOrderFromRankList(Lists.newArrayList());
        List<Long> shopIdList = remoteShopService.listShopIdByPlTotal(mgtBasePlatformDto).getData();
        if (mgtBasePlatformDto.getUserId() != null || StringUtils.isNotBlank(mgtBasePlatformDto.getShopProvinceCode()) || StringUtils.isNotBlank(mgtBasePlatformDto.getShopCityCode()) || StringUtils.isNotBlank(mgtBasePlatformDto.getShopAreaCode())) {
            if(shopIdList==null||shopIdList.isEmpty()){
                return mgtTotalOrderTotalVo;
            }
        }
        if(mgtBasePlatformDto.getShopId()!=null){
            shopIdList = new ArrayList<>();
            shopIdList.add(mgtBasePlatformDto.getShopId());
        }
        mgtBasePlatformDto.setShopIdList(shopIdList);
        //获取基础统计
        MgtTotalOrderTotalVo mgtTotalOrderTotalVo = orderMapper.getPlTotalOrderTotalOrderFrom(mgtBasePlatformDto);
        MgtTotalOrderTotalVo totalOrderTotalVo = orderMapper.getPlTotalOrderTotalOrderFrom(mgtBasePlatformDto);
        mgtTotalOrderTotalVo.setOrderTotal(totalOrderTotalVo.getOrderTotal());
        mgtTotalOrderTotalVo.setOnlineTotal(totalOrderTotalVo.getOnlineTotal());
        mgtTotalOrderTotalVo.setOfflineTotal(totalOrderTotalVo.getOfflineTotal());
        mgtTotalOrderTotalVo.setActivityTotal(0);
        mgtTotalOrderTotalVo.setOrderMoney(totalOrderTotalVo.getOrderMoney());
        mgtTotalOrderTotalVo.setOnlineMoney(totalOrderTotalVo.getOnlineMoney());
        mgtTotalOrderTotalVo.setOfflineMoney(totalOrderTotalVo.getOfflineMoney());
        mgtTotalOrderTotalVo.setActivityMoney(totalOrderTotalVo.getActivityMoney());
        //获取商品分类销售数据
        List<MgtMapTotalPlusVo> MgtMapIntTotalVoGoodsType = orderMapper.listPlTotalOrderTotalGoodsType(mgtBasePlatformDto);
        List<MgtMapIntTotalVo> goodsTypeTotalList = new ArrayList<>();
@@ -3477,21 +3661,33 @@
        if(mgtBasePlatformDto.getActivityFrom()!=null&&mgtBasePlatformDto.getActivityFrom() == 2){
            return new MgtPlTotalActivityTotalVo();
        }
        //获取需要关联的用户id集合
        /*if (mgtBasePlatformDto.getDeptId() != null) {
            List<Long> userIdList = new ArrayList<>();
            if (mgtBasePlatformDto.getUserId() != null) {
                userIdList.add(mgtBasePlatformDto.getUserId());
            } else {
                MgtUserIdByDept mgtUserIdByDept = new MgtUserIdByDept();
                mgtUserIdByDept.setDeptId(mgtBasePlatformDto.getUserId());
                mgtUserIdByDept = remoteConfigService.getUserIdByDept(mgtUserIdByDept).getData();
                userIdList = mgtUserIdByDept.getUserIdList();
            }
            if (!userIdList.isEmpty()) {
                mgtBasePlatformDto.setUserIdList(userIdList);
            }
        }*/
        MgtPlTotalActivityTotalVo totalActivityTotalVo = new MgtPlTotalActivityTotalVo();
        totalActivityTotalVo.setOrderTotal(0);
        totalActivityTotalVo.setCycleTotal(0);
        totalActivityTotalVo.setExperienceTotal(0);
        totalActivityTotalVo.setServiceTotal(0);
        totalActivityTotalVo.setOrderMoney(new BigDecimal("0"));
        totalActivityTotalVo.setCycleMoney(new BigDecimal("0"));
        totalActivityTotalVo.setExperienceMoney(new BigDecimal("0"));
        totalActivityTotalVo.setServiceMoney(new BigDecimal("0"));
        totalActivityTotalVo.setOrderJoinPerson(0);
        totalActivityTotalVo.setOrderPerson(0);
        totalActivityTotalVo.setCyclePerson(0);
        totalActivityTotalVo.setExperiencePerson(0);
        totalActivityTotalVo.setServicePerson(0);
        totalActivityTotalVo.setOrderTotalKey(new String[0]);
        totalActivityTotalVo.setOrderTotalValue(new Integer[0]);
        totalActivityTotalVo.setOrderMoneyValue(new BigDecimal[0]);
        totalActivityTotalVo.setGoodsTypeTotalList(Lists.newArrayList());
        totalActivityTotalVo.setGoodsTypeMoneyList(Lists.newArrayList());
        totalActivityTotalVo.setActivityRankList(Lists.newArrayList());
        totalActivityTotalVo.setShopSalesRankKey(new String[0]);
        totalActivityTotalVo.setShopSalesRankValue(new BigDecimal[0]);
        totalActivityTotalVo.setActivitySalesRankList(Lists.newArrayList());
        totalActivityTotalVo.setJoinMemberTotalKey(new String[0]);
        totalActivityTotalVo.setJoinMemberTotalValue(new Integer[0]);
        totalActivityTotalVo.setGetMemberTotalKey(new String[0]);
        totalActivityTotalVo.setGetMemberTotalValue(new Integer[0]);
        List<Long> shopIdList = remoteShopService.listShopIdByPlTotal(mgtBasePlatformDto).getData();
        if(mgtBasePlatformDto.getShopId()!=null){
            shopIdList = new ArrayList<>();
@@ -3499,7 +3695,10 @@
        }
        mgtBasePlatformDto.setShopIdList(shopIdList);
        //获取基础统计
        MgtPlTotalActivityTotalVo totalActivityTotalVo = orderMapper.getPlTotalActivityTotal(mgtBasePlatformDto);
        MgtPlTotalActivityTotalVo mgtTotalActivityTotalVo = orderMapper.getPlTotalActivityTotal(mgtBasePlatformDto);
        totalActivityTotalVo.setOrderTotal(mgtTotalActivityTotalVo.getOrderTotal());
        totalActivityTotalVo.setOrderMoney(mgtTotalActivityTotalVo.getOrderMoney());
        totalActivityTotalVo.setOrderJoinPerson(mgtTotalActivityTotalVo.getOrderJoinPerson());
        //获客人数
        MgtPlTotalActivityTotalVo totalActivityMemberTotalVo = orderMapper.getPlTotalActivityMemberTotal(mgtBasePlatformDto);
        totalActivityTotalVo.setOrderPerson(totalActivityMemberTotalVo.getOrderPerson());
@@ -3634,26 +3833,30 @@
        Map<Long, MgtSimpleShopVo> shopMap = simpleShopVoList.stream()
                .collect(Collectors.toMap(MgtSimpleShopVo::getShopId, Function.identity()));
        //商户活动次数排名
        List<MgtMapBigTotalVo> shopActivityRank = orderMapper.listPlTotalShopActivityRank(mgtBasePlatformDto);
        List<MgtMapIntTotalVo> shopActivityRank = orderMapper.listPlTotalShopActivityRank(mgtBasePlatformDto);
        if (shopActivityRank != null && shopActivityRank.size() > 0) {
            shopActivityRank = bigListRemoveNull(shopActivityRank);
            for(MgtMapBigTotalVo mgtMapBigTotalVo : shopActivityRank){
                if(shopMap.get(mgtMapBigTotalVo.getMapKey())!=null){
                    mgtMapBigTotalVo.setMapKey(shopMap.get(mgtMapBigTotalVo.getMapKey()).getShopName());
            for(MgtMapIntTotalVo mgtMapIntTotalVo : shopActivityRank){
                if(shopMap.get(Long.valueOf(mgtMapIntTotalVo.getMapKey()))!=null){
                    mgtMapIntTotalVo.setMapKey(shopMap.get(Long.valueOf(mgtMapIntTotalVo.getMapKey())).getShopName());
                }
            }
            totalActivityTotalVo.setShopSalesRankList(shopActivityRank);
            totalActivityTotalVo.setActivityRankList(shopActivityRank);
        }
        //商户活动销售额排名
        List<MgtMapBigTotalVo> shopActivitySalesRank = orderMapper.listPlTotalShopActivitySalesRank(mgtBasePlatformDto);
        if (shopActivitySalesRank != null && shopActivitySalesRank.size() > 0) {
            shopActivitySalesRank = bigListRemoveNull(shopActivitySalesRank);
            for(MgtMapBigTotalVo mgtMapBigTotalVo : shopActivitySalesRank){
                if(shopMap.get(mgtMapBigTotalVo.getMapKey())!=null){
                    mgtMapBigTotalVo.setMapKey(shopMap.get(mgtMapBigTotalVo.getMapKey()).getShopName());
            String[] shopSalesRankKey = new String[shopActivitySalesRank.size()];
            BigDecimal[] shopSalesRankValue = new BigDecimal[shopActivitySalesRank.size()];
            MgtMapBigTotalVo mgtMapBigTotalVo;
            for(int i=0;i<shopActivitySalesRank.size();i++){
                mgtMapBigTotalVo = shopActivitySalesRank.get(i);
                if(shopMap.get(Long.valueOf(mgtMapBigTotalVo.getMapKey()))!=null){
                    shopSalesRankKey[i] = shopMap.get(Long.valueOf(mgtMapBigTotalVo.getMapKey())).getShopName();
                }
                shopSalesRankValue[i] = mgtMapBigTotalVo.getMapValue();
            }
            totalActivityTotalVo.setShopSalesRankList(shopActivitySalesRank);
            totalActivityTotalVo.setShopSalesRankKey(shopSalesRankKey);
            totalActivityTotalVo.setShopSalesRankValue(shopSalesRankValue);
        }
        //活动销售额排名
        List<MgtMapBigTotalVo> activitySalesRank = orderMapper.listPlTotalActivitySalesRank(mgtBasePlatformDto);
@@ -3667,8 +3870,8 @@
            List<Long> userIdList = remoteMemberService.listUserIdByAgeType(mgtBasePlatformDto.getAgeType()).getData();
            mgtBasePlatformDto.setUserIdList(userIdList);
        }
        //参与人数
        List<MgtMapIntTotalVo> joinList = orderMapper.getMgtActivityMemberTotal(mgtBasePlatformDto);
        //参与人数  2023-09-06 另开接口
        /*List<MgtMapIntTotalVo> joinList = orderMapper.getMgtActivityMemberTotal(mgtBasePlatformDto);
        // 将查询结果转为Map
        Map<String, Integer> mgtMapIntTotalVoMap = new HashMap<>();
        if (joinList != null && !joinList.isEmpty()) {
@@ -3711,7 +3914,7 @@
            getMemberTotalValue[i] = (value != null) ? value : 0;
        }
        totalActivityTotalVo.setGetMemberTotalKey(getMemberTotalKey);
        totalActivityTotalVo.setGetMemberTotalValue(getMemberTotalValue);
        totalActivityTotalVo.setGetMemberTotalValue(getMemberTotalValue);*/
        return totalActivityTotalVo;
    }

@@ -3741,6 +3944,10 @@
            mgtBasePlatformDto.setUserIdList(userIdList);
        }
        List<Long> shopIdList = remoteShopService.listShopIdByPlTotal(mgtBasePlatformDto).getData();
        if(mgtBasePlatformDto.getShopId()!=null){
            shopIdList = new ArrayList<>();
            shopIdList.add(mgtBasePlatformDto.getShopId());
        }
        mgtBasePlatformDto.setShopIdList(shopIdList);
        MgtPlTotalActivityTotalVo totalActivityTotalVo = new MgtPlTotalActivityTotalVo();
        //日期全部时固定为5天
@@ -3801,6 +4008,10 @@
            mgtBasePlatformDto.setUserIdList(userIdList);
        }
        List<Long> shopIdList = remoteShopService.listShopIdByPlTotal(mgtBasePlatformDto).getData();
        if(mgtBasePlatformDto.getShopId()!=null){
            shopIdList = new ArrayList<>();
            shopIdList.add(mgtBasePlatformDto.getShopId());
        }
        mgtBasePlatformDto.setShopIdList(shopIdList);
        MgtPlTotalActivityTotalVo totalActivityTotalVo = new MgtPlTotalActivityTotalVo();
        //日期全部时固定为5天
@@ -5365,6 +5576,7 @@
        }
    }

    @GlobalTransactional(rollbackFor = Exception.class)
    private void autoTimeCancelOrder(Order order) {
        String orderId = order.getOrderId();
        order.setOrderStatus(0);