java/HongRuiTang.git

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


			import com.alibaba.fastjson2.JSONObject;
			import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
			import com.baomidou.mybatisplus.core.toolkit.Wrappers;
			@@ -12,7 +11,7 @@
			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.common.collect.Lists;
			import com.google.gson.Gson;
			import com.ruoyi.common.core.domain.R;
			import com.ruoyi.common.core.exception.ServiceException;
			@@ -54,11 +53,11 @@
			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.poji.sys.SysUser;
			import com.ruoyi.system.api.domain.vo.*;
			import com.ruoyi.system.api.service.*;
			import lombok.extern.slf4j.Slf4j;
			import io.seata.spring.annotation.GlobalTransactional;
			import lombok.extern.log4j.Log4j2;
			import org.redisson.api.RLock;
			import org.redisson.api.RedissonClient;
			import org.springframework.stereotype.Service;
			@@ -84,7 +83,7 @@
			* @since 2023-04-25
			*/
			@Service
			@Slf4j
			@Log4j2
			public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {

			@Resource
			@@ -146,6 +145,7 @@

			@Resource
			private OrderRefundService orderRefundService;


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


			}
			// 过滤商品优惠券列表
			List<AppMemberCouponVo> appGoodsMemberCouponVoList;
			@@ -513,9 +511,16 @@
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public AppPlaceOrderVo placeOrder(AppPlaceOrderDto appPlaceOrderDto) {
			// 获取用户ID
			Long userId = appPlaceOrderDto.getUserId();
			Member member = remoteMemberService.getMember(userId).getData();
			appPlaceOrderDto.setUserId(userId);
			if (member != null) {
			appPlaceOrderDto.setOpenid(member.getMiniOpenid());
			appPlaceOrderDto.setShopId(member.getRelationShopId());
			}
			// 创建下单视图对象
			AppPlaceOrderVo appPlaceOrderVo = new AppPlaceOrderVo();
			// 创建商品列表
			@@ -557,6 +562,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");
			@@ -603,7 +609,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();
			@@ -746,8 +752,10 @@
			order.setOrderRemark(appPlaceOrderDto.getOrderRemark());
			order.setGoodsNum(goodsNum);
			order.setCreateTime(new Date());
			if(appPlaceOrderDto.getNewMemberFlag()!=null&&appPlaceOrderDto.getNewMemberFlag()==1){
			order.setNewMemberFlag(1);
			if(member.getBindingFlag()==0){
			order.setUnbindingFlag(1);
			}else{
			order.setUnbindingFlag(0);
			}
			// 保存订单
			this.save(order);
			@@ -776,7 +784,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);
			@@ -813,23 +821,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());
			@@ -843,11 +851,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);

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

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

			// 请求参数
			@@ -893,9 +896,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());
			@@ -912,8 +915,15 @@
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public AppPlaceOrderVo placeActivityOrder(AppPlaceActivityDto appPlaceActivityDto) {
			Long userId = appPlaceActivityDto.getUserId();
			Member member = remoteMemberService.getMember(userId).getData();
			appPlaceActivityDto.setUserId(userId);
			if (member != null && member.getRelationShopId() != null) {
			appPlaceActivityDto.setOpenid(member.getMiniOpenid());
			appPlaceActivityDto.setShopId(member.getRelationShopId());
			}
			// 创建订单对象
			AppPlaceOrderVo appPlaceOrderVo = new AppPlaceOrderVo();
			// 定义商品订单对象
			@@ -925,259 +935,262 @@
			//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(member.getBindingFlag()==0){
			order.setUnbindingFlag(1);
			}else{
			order.setUnbindingFlag(0);
			}
			// 保存订单
			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;
			}

			@@ -1191,7 +1204,10 @@
			*/
			@Override
			public List<AppUserOrderPageVo> pageUserOrder(Page page, AppUserOrderPageDto appUserOrderPageDto) {
			Long userId = appUserOrderPageDto.getUserId();
			Member member = remoteMemberService.getMember(userId).getData();
			List<AppUserOrderPageVo> appUserOrderPageVoList = orderMapper.pageUserOrder(page, appUserOrderPageDto);
			//处理商户名称显示
			if (appUserOrderPageVoList != null && !appUserOrderPageVoList.isEmpty()) {
			Long shopId;
			String activityId;
			@@ -1216,13 +1232,17 @@
			delayTime = redisService.getCacheObject(SecurityConstant.AUTO_CANCEL_ORDER_TIME);
			}
			for (AppUserOrderPageVo appUserOrderPageVo : appUserOrderPageVoList) {
			shop = shopMap.get(appUserOrderPageVo.getShopId());
			appUserOrderPageVo.setShopName(shop.getShopName());
			appUserOrderPageVo.setShopServicePhone(shop.getShopServicePhone());
			if (appUserOrderPageVo.getShopId().equals(appUserOrderPageDto.getShopId())) {
			appUserOrderPageVo.setSameShop(1);
			} else {
			appUserOrderPageVo.setSameShop(0);
			if(member.getBindingFlag()==0&&appUserOrderPageVo.getOrderFrom()==2){
			appUserOrderPageVo.setShopName("全部店铺");
			}else{
			shop = shopMap.get(appUserOrderPageVo.getShopId());
			appUserOrderPageVo.setShopName(shop.getShopName());
			appUserOrderPageVo.setShopServicePhone(shop.getShopServicePhone());
			if (appUserOrderPageVo.getShopId().equals(appUserOrderPageDto.getShopId())) {
			appUserOrderPageVo.setSameShop(1);
			} else {
			appUserOrderPageVo.setSameShop(0);
			}
			}
			appUserOrderPageVo.setVerifyCode("1-" + appUserOrderPageVo.getOrderId());
			appUserOrderPageVo.setEndTime(DateUtils.addMinutes(appUserOrderPageVo.getCreateTime(), delayTime));
			@@ -1264,7 +1284,7 @@
			appUserOrderGetVo.setShopName(shop.getShopName());
			appUserOrderGetVo.setAppUserOrderGoodsPageVoList(appUserOrderGoodsPageVoList);
			appUserOrderGetVo.setVerifyCode("1-" + orderId);
			//生成自动取消订单延时任务
			//获取订单取消时间
			Integer delayTime = 30;
			if (redisService.hasKey(SecurityConstant.AUTO_CANCEL_ORDER_TIME)) {
			delayTime = redisService.getCacheObject(SecurityConstant.AUTO_CANCEL_ORDER_TIME);
			@@ -1285,6 +1305,9 @@
			if (order.getOrderStatus() == 0) {
			throw new ServiceException(AppErrorConstant.CANCEL_CANCEL_ORDER);
			} else if (order.getOrderStatus() == 1) {
			//删除待支付超时取消延时任务
			redisService.deleteObject(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + orderId);
			remoteConfigService.deleteDelayTask(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode()+"-"+orderId);
			this.autoCancelOrder(orderId);
			} else if (order.getOrderStatus() == 2) {
			// 2.待核销 -> 订单退款
			@@ -1303,21 +1326,31 @@
			*/
			@Override
			public AppPlaceOrderVo payOrder(String orderId){
			// 根据订单ID获取订单
			Order order = this.getById(orderId);
			if(order.getOrderStatus()!=1){
			// 如果订单状态不是1（待支付），抛出异常
			if(order.getOrderStatus() != 1){
			throw new ServiceException(AppErrorConstant.CANCEL_CANCEL_ORDER);
			}
			String payStr = redisService.getCacheObject(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode()+ "-"+orderId);
			// 从缓存中获取支付信息
			String payStr = redisService.getCacheObject(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + orderId);
			// 如果支付信息为空，抛出异常
			if(StringUtils.isBlank(payStr)){
			throw new ServiceException(AppErrorConstant.CANCEL_CANCEL_ORDER);
			}
			// 默认延迟时间为30分钟
			Integer delayTime = 30;
			// 如果缓存中存在自动取消订单时间，使用缓存中的值作为延迟时间
			if (redisService.hasKey(SecurityConstant.AUTO_CANCEL_ORDER_TIME)) {
			delayTime = redisService.getCacheObject(SecurityConstant.AUTO_CANCEL_ORDER_TIME);
			}
			// 创建AppPlaceOrderVo对象
			AppPlaceOrderVo appPlaceOrderVo = new AppPlaceOrderVo();
			// 根据未支付订单ID获取订单支付信息
			OrderPayment orderPayment = orderPaymentService.getByUnpaidOrderId(orderId);
			// 将支付信息拆分为数组
			String[] payArr = payStr.split("-");
			// 设置AppPlaceOrderVo对象的属性
			appPlaceOrderVo.setOrderId(order.getOrderId());
			appPlaceOrderVo.setOrderNo(order.getOrderNo());
			appPlaceOrderVo.setPayType(order.getPayType());
			@@ -1332,6 +1365,7 @@
			appPlaceOrderVo.setSignType(payArr[4]);
			appPlaceOrderVo.setPaySign(payArr[5]);
			appPlaceOrderVo.setPrepayId(orderPayment.getPrepayId());
			// 返回AppPlaceOrderVo对象
			return appPlaceOrderVo;
			}

			@@ -1394,11 +1428,107 @@
			if (order.getOrderStatus() != 2) {
			throw new ServiceException(AppErrorConstant.VERIFY_USED);
			}
			if (!order.getShopId().equals(shopId)) {
			throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
			//判断商户是否有分账权限
			Shop shop = remoteShopService.getShop(shopId).getData();
			if(shop.getAccountFlag()!=1){
			throw new ServiceException(AppErrorConstant.SHOP_NO_VERIFY);
			}
			// 根据订单用户ID获取用户信息
			Member member = remoteMemberService.getMember(order.getUserId()).getData();
			// 根据订单ID获取订单商品列表
			List<AppUserOrderGoodsPageVo> appUserOrderGoodsPageVoList = orderGoodsService.listAppVoByOrderId(orderId);
			//判断用户是否绑定
			if(member.getBindingFlag()==1){
			//绑定用户判断核销商户
			if(order.getOrderFrom()==2&&order.getUnbindingFlag()==1){
			if (!member.getRelationShopId().equals(shopId)) {
			throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
			}
			//未绑定时下的活动订单只需要判断店铺是否支持
			String activityId = order.getActivityId();
			MerActivityShopDto merActivityShopDto = new MerActivityShopDto();
			merActivityShopDto.setShopId(shopId);
			merActivityShopDto.setActivityId(activityId);
			Boolean judge = remoteActivityService.judgeActivityShop(merActivityShopDto).getData();
			if(!judge){
			throw new ServiceException(AppErrorConstant.SHOP_NO_ACTIVITY);
			}
			}else{
			//商城订单和绑定后活动订单判断核销商户和订单商户和用户关联商户是否统一
			if (!order.getShopId().equals(shopId)) {
			throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
			}
			if (!member.getRelationShopId().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);
			}
			}
			//未绑定用户的活动订单需判断活动订单是否支持该店铺
			if(order.getOrderFrom()==2){
			String activityId = order.getActivityId();
			MerActivityShopDto merActivityShopDto = new MerActivityShopDto();
			merActivityShopDto.setShopId(shopId);
			merActivityShopDto.setActivityId(activityId);
			Boolean judge = remoteActivityService.judgeActivityShop(merActivityShopDto).getData();
			if(!judge){
			throw new ServiceException(AppErrorConstant.SHOP_NO_ACTIVITY);
			}
			}
			//未绑定用户需判断核销商城订单判断商品单价和优惠券
			/*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());
			@@ -1430,8 +1560,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());
			@@ -1448,6 +1576,7 @@
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public MerVerifyOrderVo sureVerifyOrder(MerVerifyOrderDto merVerifyOrderDto) {
			String orderId = merVerifyOrderDto.getOrderId();
			BigDecimal relReceiveMoney = merVerifyOrderDto.getRelReceiveMoney();
			@@ -1458,11 +1587,97 @@
			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.getOrderFrom()==2&&order.getUnbindingFlag()==1){
			String activityId = order.getActivityId();
			MerActivityShopDto merActivityShopDto = new MerActivityShopDto();
			merActivityShopDto.setShopId(shopId);
			merActivityShopDto.setActivityId(activityId);
			Boolean judge = remoteActivityService.judgeActivityShop(merActivityShopDto).getData();
			if(!judge){
			throw new ServiceException(AppErrorConstant.SHOP_NO_ACTIVITY);
			}
			}else{
			//绑定用户需直接判断商户一致
			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);
			}
			}
			//未绑定用户需判断活动订单是否支持该店铺
			if(order.getOrderFrom()==2){
			String activityId = order.getActivityId();
			MerActivityShopDto merActivityShopDto = new MerActivityShopDto();
			merActivityShopDto.setShopId(shopId);
			merActivityShopDto.setActivityId(activityId);
			Boolean judge = remoteActivityService.judgeActivityShop(merActivityShopDto).getData();
			if(!judge){
			throw new ServiceException(AppErrorConstant.SHOP_NO_ACTIVITY);
			}
			}
			//未绑定用户需判断核销商城订单判断商品单价和优惠券
			/*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());
			@@ -1470,6 +1685,7 @@
			order.setOffPayTime(nowTime);
			order.setPayMoney(order.getPayMoney().add(relPayMoney));
			order.setChangeReceivableMoney(relReceiveMoney);
			//判断订单是否结清
			if (order.getPayMoney().compareTo(order.getChangeReceivableMoney()) >= 0) {
			order.setCloseFlag(1);
			} else {
			@@ -1477,7 +1693,7 @@
			}
			this.saveOrUpdate(order);
			//创建服务商品
			List<AppUserOrderGoodsPageVo> appUserOrderGoodsPageVoList = orderGoodsService.listAppVoByOrderId(orderId);
			//获取商品信息(商品简介,调理问题)
			StringJoiner goodsIdSj = new StringJoiner(",");
			for (AppUserOrderGoodsPageVo appUserOrderGoodsPageVo : appUserOrderGoodsPageVoList) {
			goodsIdSj.add(appUserOrderGoodsPageVo.getGoodsId());
			@@ -1489,9 +1705,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());
			@@ -1555,11 +1773,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);
			@@ -1568,9 +1781,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{
			@@ -1578,17 +1794,32 @@
			}
			}
			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);
			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);
			// 订单金额大于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();
			@@ -1606,40 +1837,52 @@
			return merVerifyOrderVo;
			}

			private void submitProfitSharing(String orderId, String orderNo, Long shopId, BigDecimal orderMoney) {
			/**
			* @description 分账实现
			* @author jqs
			* @date 2023/9/8 11:56
			* @param orderId
			* @param orderNo
			* @param shopId
			* @param orderMoney
			* @param orderFrom
			* @return void
			*/
			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)) {
			if (StringUtils.isEmpty(subMchId)) {
			throw new ServiceException("获取微信商户号失败");
			}
			// 平台特约商户号，用户平台收取服务费 2023-09-05改变分账方式
			String platformTyMacId = WxPayConfiguration.getPlatformTyMacId();
			if (!StringUtils.isEmpty(platformTyMacId)) {
			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 = new BigDecimal(redisService.getCacheObject(SecurityConstant.SHOP_COMMON_PROPORTION).toString());
			}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;
			}
			//平台分成
			proportionPercent = new BigDecimal("100.00").subtract(proportionPercent);
			String description = "订单:" + orderNo + " 平台分账";
			//商户分成
			if(proportionPercent.compareTo(BigDecimal.ZERO)>0){
			ProfitSharingResult result = new ProfitSharingResult();
			result.setOutOrderNo(orderNo);
			@@ -1651,20 +1894,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);
			@@ -1696,6 +1936,7 @@
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public MerVerifyCouponVo sureVerifyCoupon(MerVerifyCouponDto merVerifyCouponDto) {
			MerVerifyCouponGetVo verifyCouponGetVo = remoteCouponService.getVerifyCoupon(merVerifyCouponDto.getMemberCouponId()).getData();
			MemberCoupon memberCoupon = verifyCouponGetVo.getMemberCoupon();
			@@ -1800,6 +2041,7 @@
			merVerifyMemberCouponDto.setShopId(shopId);
			remoteCouponService.sureMemberCoupon(merVerifyMemberCouponDto);
			consumerGoodsService.saveBatchConsumerGoods(consumerGoodsList);
			//绑定未绑定用户
			if (member.getBindingFlag() != 1) {
			AppMemberBindingDto appMemberBindingDto = new AppMemberBindingDto();
			appMemberBindingDto.setBindingFlag(1);
			@@ -1823,6 +2065,7 @@
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public MerVerifyAwardVo sureVerifyPrize(MerVerifyPrizeDto merVerifyPrizeDto) {
			MerVerifyAwardVo merVerifyAwardVo = new MerVerifyAwardVo();
			MemberGiftRecord memberGiftRecord = remoteMemberService.getVerifyPrize(merVerifyPrizeDto.getPrizeId()).getData();
			@@ -1917,6 +2160,7 @@
			merVerifyPrizeFinalDto.setPrizeId(memberGiftRecord.getPrizeId());
			merVerifyPrizeFinalDto.setShopId(shop.getShopId());
			remoteMemberService.verifyPrize(merVerifyPrizeFinalDto);
			//绑定未绑定用户
			if (member.getBindingFlag() != 1) {
			AppMemberBindingDto appMemberBindingDto = new AppMemberBindingDto();
			appMemberBindingDto.setBindingFlag(1);
			@@ -1941,7 +2185,7 @@
			*/
			@Override
			public List<MerMemberNoClearOrderVo> pageMerMemberNoClearOrder(Page page, MerMemberNoClearOrderDto merMemberNoClearOrderDto) {
			List<MerMemberNoClearOrderVo> merMemberNoClearOrderVoList = orderMapper.pageMerMemberNoClearOrder(page, merMemberNoClearOrderDto.getMemberUserId());
			List<MerMemberNoClearOrderVo> merMemberNoClearOrderVoList = orderMapper.pageMerMemberNoClearOrder(page, merMemberNoClearOrderDto);
			if (merMemberNoClearOrderVoList != null && !merMemberNoClearOrderVoList.isEmpty()) {
			BigDecimal zeroBig = new BigDecimal("0.00");
			for (MerMemberNoClearOrderVo merMemberNoClearOrderVo : merMemberNoClearOrderVoList) {
			@@ -1967,6 +2211,7 @@
			order.setOfflinePayMoney(order.getOfflinePayMoney().add(merCloseOrderDto.getPayMoney()));
			order.setOffPayTime(new Date());
			order.setPayMoney(order.getPayMoney().add(merCloseOrderDto.getPayMoney()));
			//支付金额大于实收金额时结清
			if (order.getPayMoney().compareTo(order.getChangeReceivableMoney()) >= 0) {
			order.setCloseFlag(1);
			} else {
			@@ -1989,6 +2234,8 @@
			* @param merNewOrderDto
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public void createNewOrder(MerNewOrderDto merNewOrderDto) {
			Long userId = merNewOrderDto.getBuyUserId();
			Date nowTime = new Date();
			@@ -2063,10 +2310,10 @@
			OrderGoods orderGoods;
			String orderGoodsId;
			GoodsFile goodsFile;
			BigDecimal cycleMoney = new BigDecimal("0.00");
			BigDecimal experienceMoney = new BigDecimal("0.00");
			BigDecimal serviceMoney = new BigDecimal("0.00");
			BigDecimal goodsMoney = new BigDecimal("0.00");
			//BigDecimal cycleMoney = new BigDecimal("0.00");
			//BigDecimal experienceMoney = new BigDecimal("0.00");
			//BigDecimal serviceMoney = new BigDecimal("0.00");
			//BigDecimal goodsMoney = new BigDecimal("0.00");
			List<OrderGoods> orderGoodsList = new ArrayList<>();
			ConsumerGoods consumerGoods;
			String consumerGoodsId;
			@@ -2209,7 +2456,7 @@
			}

			//商户变更计算
			switch (orderGoods.getGoodsType()) {
			/*switch (orderGoods.getGoodsType()) {
			case 1:
			cycleMoney = cycleMoney.add(orderGoods.getGoodsReceivableMoney());
			break;
			@@ -2224,7 +2471,7 @@
			break;
			default:
			break;
			}
			}*/
			}
			//创建订单
			Order order = new Order();
			@@ -2276,6 +2523,7 @@
			appMemberBindingDto.setBindingType(3);
			remoteMemberService.updateMemberBinding(appMemberBindingDto);
			order.setNewMemberFlag(1);
			order.setUnbindingFlag(0);
			}
			//保存订单和服务
			this.save(order);
			@@ -2287,6 +2535,7 @@
			}
			//更新会员消费记录
			MemberTotalChangeDto memberTotalChangeDto = new MemberTotalChangeDto();
			memberTotalChangeDto.setUserId(order.getUserId());
			memberTotalChangeDto.setConsumeTime(nowTime);
			remoteMemberService.changeMemberTotal(memberTotalChangeDto);
			//更新商户统计
			@@ -2438,8 +2687,13 @@
			BigDecimal zeroBig = new BigDecimal("0.00");
			// 遍历MgtMemberOrderPageVoList，获取shopId并添加到set中
			for (MgtMemberOrderPageVo mgtMemberOrderPageVo : mgtMemberOrderPageVoList) {
			shopId = mgtMemberOrderPageVo.getShopId();
			set.add(shopId.toString());
			if(mgtMemberOrderPageVo.getShopId()!=null){
			if(mgtMemberOrderPageVo.getShopId()!=null){
			shopId = mgtMemberOrderPageVo.getShopId();
			set.add(shopId.toString());
			}
			}

			}
			// 将set中的shopId转换为逗号分隔的字符串
			String joinedString = String.join(",", set);
			@@ -2452,10 +2706,15 @@
			.collect(Collectors.toMap(MgtSimpleShopVo::getShopId, Function.identity()));
			// 遍历MgtMemberOrderPageVoList，根据shopId获取对应的MgtSimpleShopVo并将其shopName设置到MgtMemberOrderPageVo中
			for (MgtMemberOrderPageVo mgtMemberOrderPageVo : mgtMemberOrderPageVoList) {
			shopId = mgtMemberOrderPageVo.getShopId();
			mgtMemberOrderPageVo.setShopName(map.get(shopId).getShopName());
			BigDecimal unPaidMoney = mgtMemberOrderPageVo.getReceivableMoney().subtract(mgtMemberOrderPageVo.getPayMoney());
			mgtMemberOrderPageVo.setUnPaidMoney(unPaidMoney == null ? zeroBig : unPaidMoney);
			if(mgtMemberOrderPageVo.getShopId()!=null){
			if(mgtMemberOrderPageVo.getShopId()!=null){
			shopId = mgtMemberOrderPageVo.getShopId();
			mgtMemberOrderPageVo.setShopName(map.get(shopId).getShopName());
			BigDecimal unPaidMoney = mgtMemberOrderPageVo.getReceivableMoney().subtract(mgtMemberOrderPageVo.getPayMoney());
			mgtMemberOrderPageVo.setUnPaidMoney(unPaidMoney == null ? zeroBig : unPaidMoney);
			}
			}

			}
			}
			// 返回MgtMemberOrderPageVoList
			@@ -2502,7 +2761,10 @@
			BigDecimal zeroBig = new BigDecimal("0.00");
			// 遍历列表，获取店铺 ID 和用户 ID
			for (MgtActivityOrderPageVo mgtActivityOrderPageVo : activityOrderPageVoList) {
			shopIdSet.add(mgtActivityOrderPageVo.getShopId());
			if(mgtActivityOrderPageVo.getShopId()!=null){
			shopIdSet.add(mgtActivityOrderPageVo.getShopId());

			}
			userIdSet.add(mgtActivityOrderPageVo.getUserId());
			}
			// 将店铺 ID 和用户 ID 转换为逗号分隔的字符串
			@@ -2521,7 +2783,10 @@
			.collect(Collectors.toMap(MgtSimpleMemberVo::getUserId, Function.identity()));
			// 遍历列表，设置店铺名称、用户名称和未支付金额
			for (MgtActivityOrderPageVo mgtActivityOrderPageVo : activityOrderPageVoList) {
			mgtActivityOrderPageVo.setShopName(shopMap.get(mgtActivityOrderPageVo.getShopId()).getShopName());
			if(mgtActivityOrderPageVo.getShopId()!=null){
			mgtActivityOrderPageVo.setShopName(shopMap.get(mgtActivityOrderPageVo.getShopId()).getShopName());

			}
			if (userMap.get(mgtActivityOrderPageVo.getUserId()) != null) {
			mgtActivityOrderPageVo.setNickName(userMap.get(mgtActivityOrderPageVo.getUserId()).getNickName());
			mgtActivityOrderPageVo.setUserName(userMap.get(mgtActivityOrderPageVo.getUserId()).getRealName());
			@@ -2802,6 +3067,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();
			@@ -2830,48 +3101,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);
			@@ -2953,8 +3224,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());
			@@ -3076,8 +3371,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()) {
			@@ -3100,7 +3395,7 @@
			joinMemberTotalValue[i] = (value != null) ? value : 0;
			}
			totalActivityTotalVo.setJoinMemberTotalKey(joinMemberTotalKey);
			totalActivityTotalVo.setJoinMemberTotalValue(joinMemberTotalValue);
			totalActivityTotalVo.setJoinMemberTotalValue(joinMemberTotalValue);*/
			return totalActivityTotalVo;
			}

			@@ -3312,14 +3607,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<>();
			@@ -3467,32 +3797,53 @@
			*/
			@Override
			public MgtPlTotalActivityTotalVo getPlTotalActivityTotal(MgtBasePlatformDto mgtBasePlatformDto) {
			if(mgtBasePlatformDto.getActivityFrom()!=null&&mgtBasePlatformDto.getActivityFrom() == 2){
			return new MgtPlTotalActivityTotalVo();
			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]);
			//店铺活动返回空
			if(mgtBasePlatformDto.getActivityFrom()!=null&&mgtBasePlatformDto.getActivityFrom()==2){
			return totalActivityTotalVo;
			}
			//获取需要关联的用户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);
			}
			}*/
			List<Long> shopIdList = remoteShopService.listShopIdByPlTotal(mgtBasePlatformDto).getData();
			if (StringUtils.isNotBlank(mgtBasePlatformDto.getShopProvinceCode()) \|\| StringUtils.isNotBlank(mgtBasePlatformDto.getShopCityCode()) \|\| StringUtils.isNotBlank(mgtBasePlatformDto.getShopAreaCode())) {
			if(shopIdList==null\|\|shopIdList.isEmpty()){
			return totalActivityTotalVo;
			}
			}
			if(mgtBasePlatformDto.getShopId()!=null){
			shopIdList = new ArrayList<>();
			shopIdList.add(mgtBasePlatformDto.getShopId());
			}
			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());
			@@ -3592,6 +3943,58 @@
			totalActivityTotalVo.setGoodsTypeTotalList(goodsTypeTotalList);
			totalActivityTotalVo.setGoodsTypeMoneyList(goodsTypeMoneyList);
			}
			HashSet<String> set = new HashSet<>();
			// 遍历MgtMemberOrderPageVoList，获取shopId并添加到set中
			for (Long shopId : mgtBasePlatformDto.getShopIdList()) {
			set.add(shopId.toString());
			}
			// 将set中的shopId转换为逗号分隔的字符串
			String joinedString = String.join(",", set);
			// 通过remoteShopService获取MgtSimpleShopVoList
			MgtBaseBathDto mgtBaseBathDto = new MgtBaseBathDto();
			mgtBaseBathDto.setIds(joinedString);
			List<MgtSimpleShopVo> simpleShopVoList = remoteShopService.listShopSimpleVoByIds(mgtBaseBathDto).getData();
			// 将MgtSimpleShopVoList转换为Map<Long, MgtSimpleShopVo>，以便后续根据shopId获取对应的MgtSimpleShopVo
			Map<Long, MgtSimpleShopVo> shopMap = simpleShopVoList.stream()
			.collect(Collectors.toMap(MgtSimpleShopVo::getShopId, Function.identity()));
			//商户活动次数排名
			List<MgtMapIntTotalVo> shopActivityRank = orderMapper.listPlTotalShopActivityRank(mgtBasePlatformDto);
			if (shopActivityRank != null && shopActivityRank.size() > 0) {
			for(MgtMapIntTotalVo mgtMapIntTotalVo : shopActivityRank){
			if(shopMap.get(Long.valueOf(mgtMapIntTotalVo.getMapKey()))!=null){
			mgtMapIntTotalVo.setMapKey(shopMap.get(Long.valueOf(mgtMapIntTotalVo.getMapKey())).getShopName());
			}
			}
			totalActivityTotalVo.setActivityRankList(shopActivityRank);
			}
			//商户活动销售额排名
			List<MgtMapBigTotalVo> shopActivitySalesRank = orderMapper.listPlTotalShopActivitySalesRank(mgtBasePlatformDto);
			if (shopActivitySalesRank != null && shopActivitySalesRank.size() > 0) {
			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.setShopSalesRankKey(shopSalesRankKey);
			totalActivityTotalVo.setShopSalesRankValue(shopSalesRankValue);
			}
			//活动销售额排名
			List<MgtMapBigTotalVo> activitySalesRank = orderMapper.listPlTotalActivitySalesRank(mgtBasePlatformDto);
			if (activitySalesRank != null && activitySalesRank.size() > 0) {
			activitySalesRank = bigListRemoveNull(activitySalesRank);
			totalActivityTotalVo.setActivitySalesRankList(activitySalesRank);
			}
			MerTotalDto merTotalDto = new MerTotalDto();
			merTotalDto.setAgeType(mgtBasePlatformDto.getAgeType());
			if(mgtBasePlatformDto.getAgeType()!=null){
			List<Long> userIdList = remoteMemberService.listUserIdByAgeType(mgtBasePlatformDto.getAgeType()).getData();
			mgtBasePlatformDto.setUserIdList(userIdList);
			}
			//日期全部时固定为5天
			if(StringUtils.isBlank(mgtBasePlatformDto.getStartDate())){
			mgtBasePlatformDto.setEndDate(DateUtils.getDate());
			@@ -3612,56 +4015,9 @@
			totalActivityTotalVo.setOrderTotalValue(orderTotalValue);
			totalActivityTotalVo.setOrderMoneyValue(orderMoneyValue);
			}
			HashSet<String> set = new HashSet<>();
			// 遍历MgtMemberOrderPageVoList，获取shopId并添加到set中
			for (Long shopId : mgtBasePlatformDto.getShopIdList()) {
			set.add(shopId.toString());
			}
			// 将set中的shopId转换为逗号分隔的字符串
			String joinedString = String.join(",", set);
			// 通过remoteShopService获取MgtSimpleShopVoList
			MgtBaseBathDto mgtBaseBathDto = new MgtBaseBathDto();
			mgtBaseBathDto.setIds(joinedString);
			List<MgtSimpleShopVo> simpleShopVoList = remoteShopService.listShopSimpleVoByIds(mgtBaseBathDto).getData();
			// 将MgtSimpleShopVoList转换为Map<Long, MgtSimpleShopVo>，以便后续根据shopId获取对应的MgtSimpleShopVo
			Map<Long, MgtSimpleShopVo> shopMap = simpleShopVoList.stream()
			.collect(Collectors.toMap(MgtSimpleShopVo::getShopId, Function.identity()));
			//商户活动次数排名
			List<MgtMapBigTotalVo> 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());
			}
			}
			totalActivityTotalVo.setShopSalesRankList(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());
			}
			}
			totalActivityTotalVo.setShopSalesRankList(shopActivitySalesRank);
			}
			//活动销售额排名
			List<MgtMapBigTotalVo> activitySalesRank = orderMapper.listPlTotalActivitySalesRank(mgtBasePlatformDto);
			if (activitySalesRank != null && activitySalesRank.size() > 0) {
			activitySalesRank = bigListRemoveNull(activitySalesRank);
			totalActivityTotalVo.setActivitySalesRankList(activitySalesRank);
			}
			MerTotalDto merTotalDto = new MerTotalDto();
			merTotalDto.setAgeType(mgtBasePlatformDto.getAgeType());
			if(mgtBasePlatformDto.getAgeType()!=null){
			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()) {
			@@ -3704,16 +4060,25 @@
			getMemberTotalValue[i] = (value != null) ? value : 0;
			}
			totalActivityTotalVo.setGetMemberTotalKey(getMemberTotalKey);
			totalActivityTotalVo.setGetMemberTotalValue(getMemberTotalValue);
			totalActivityTotalVo.setGetMemberTotalValue(getMemberTotalValue);*/
			return totalActivityTotalVo;
			}


			@Override
			public MgtPlTotalActivityTotalVo getPlTotalActivityJoinMemberTotal(MgtBasePlatformDto mgtBasePlatformDto) {
			if(mgtBasePlatformDto.getActivityFrom()!=null&&mgtBasePlatformDto.getActivityFrom() == 2){
			return new MgtPlTotalActivityTotalVo();
			//店铺活动返回空
			MgtPlTotalActivityTotalVo totalActivityTotalVo = new MgtPlTotalActivityTotalVo();
			totalActivityTotalVo.setJoinMemberTotalKey(new String[0]);
			totalActivityTotalVo.setJoinMemberTotalValue(new Integer[0]);
			totalActivityTotalVo.setGetMemberTotalKey(new String[0]);
			totalActivityTotalVo.setGetMemberTotalValue(new Integer[0]);
			if(mgtBasePlatformDto.getActivityFrom()!=null&&mgtBasePlatformDto.getActivityFrom()==2){
			return totalActivityTotalVo;
			}
			/*if(mgtBasePlatformDto.getActivityType()!=null&&mgtBasePlatformDto.getActivityType()!=1){
			return new MgtPlTotalActivityTotalVo();
			}*/
			//获取需要关联的用户id集合
			/*if (mgtBasePlatformDto.getDeptId() != null) {
			List<Long> userIdList = new ArrayList<>();
			@@ -3729,18 +4094,34 @@
			mgtBasePlatformDto.setUserIdList(userIdList);
			}
			}*/

			List<Long> shopIdList = remoteShopService.listShopIdByPlTotal(mgtBasePlatformDto).getData();
			log.info("shopIdList1-----"+shopIdList.toString());
			log.debug("shopIdList1-----"+shopIdList.toString());
			if (StringUtils.isNotBlank(mgtBasePlatformDto.getShopProvinceCode()) \|\| StringUtils.isNotBlank(mgtBasePlatformDto.getShopCityCode()) \|\| StringUtils.isNotBlank(mgtBasePlatformDto.getShopAreaCode())) {
			log.info("shopIdList2-----"+shopIdList.toString());
			log.debug("shopIdList2-----"+shopIdList.toString());
			if(shopIdList==null\|\|shopIdList.isEmpty()){
			return totalActivityTotalVo;
			}
			}
			if(mgtBasePlatformDto.getShopId()!=null){
			shopIdList = new ArrayList<>();
			shopIdList.add(mgtBasePlatformDto.getShopId());
			}
			mgtBasePlatformDto.setShopIdList(shopIdList);
			if(mgtBasePlatformDto.getAgeType()!=null){
			List<Long> userIdList = remoteMemberService.listUserIdByAgeType(mgtBasePlatformDto.getAgeType()).getData();
			log.info("userIdList-----"+userIdList.toString());
			log.debug("userIdList-----"+userIdList.toString());
			mgtBasePlatformDto.setUserIdList(userIdList);
			}
			List<Long> shopIdList = remoteShopService.listShopIdByPlTotal(mgtBasePlatformDto).getData();
			mgtBasePlatformDto.setShopIdList(shopIdList);
			MgtPlTotalActivityTotalVo totalActivityTotalVo = new MgtPlTotalActivityTotalVo();
			//日期全部时固定为5天
			if(StringUtils.isBlank(mgtBasePlatformDto.getStartDate())){
			mgtBasePlatformDto.setEndDate(DateUtils.getDate());
			mgtBasePlatformDto.setStartDate(DateUtils.parseDateToStr("yyyy-MM-dd",DateUtils.addDays(new Date(),-4)));
			}
			log.info("mgtBasePlatformDto-----"+mgtBasePlatformDto.toString());
			//参与人数
			List<MgtMapIntTotalVo> joinList = orderMapper.getMgtActivityMemberTotal(mgtBasePlatformDto);
			// 将查询结果转为Map
			@@ -3771,9 +4152,18 @@

			@Override
			public MgtPlTotalActivityTotalVo getPlTotalActivityGetMemberTotal(MgtBasePlatformDto mgtBasePlatformDto) {
			if(mgtBasePlatformDto.getActivityFrom()!=null&&mgtBasePlatformDto.getActivityFrom() == 2){
			return new MgtPlTotalActivityTotalVo();
			//店铺活动返回空
			MgtPlTotalActivityTotalVo totalActivityTotalVo = new MgtPlTotalActivityTotalVo();
			totalActivityTotalVo.setJoinMemberTotalKey(new String[0]);
			totalActivityTotalVo.setJoinMemberTotalValue(new Integer[0]);
			totalActivityTotalVo.setGetMemberTotalKey(new String[0]);
			totalActivityTotalVo.setGetMemberTotalValue(new Integer[0]);
			if(mgtBasePlatformDto.getActivityFrom()!=null&&mgtBasePlatformDto.getActivityFrom()==2){
			return totalActivityTotalVo;
			}
			/*if(mgtBasePlatformDto.getActivityType()!=null&&mgtBasePlatformDto.getActivityType()!=1){
			return new MgtPlTotalActivityTotalVo();
			}*/
			//获取需要关联的用户id集合
			/*if (mgtBasePlatformDto.getDeptId() != null) {
			List<Long> userIdList = new ArrayList<>();
			@@ -3789,13 +4179,21 @@
			mgtBasePlatformDto.setUserIdList(userIdList);
			}
			}*/
			List<Long> shopIdList = remoteShopService.listShopIdByPlTotal(mgtBasePlatformDto).getData();
			if (StringUtils.isNotBlank(mgtBasePlatformDto.getShopProvinceCode()) \|\| StringUtils.isNotBlank(mgtBasePlatformDto.getShopCityCode()) \|\| StringUtils.isNotBlank(mgtBasePlatformDto.getShopAreaCode())) {
			if(shopIdList==null\|\|shopIdList.isEmpty()){
			return totalActivityTotalVo;
			}
			}
			if(mgtBasePlatformDto.getShopId()!=null){
			shopIdList = new ArrayList<>();
			shopIdList.add(mgtBasePlatformDto.getShopId());
			}
			mgtBasePlatformDto.setShopIdList(shopIdList);
			if(mgtBasePlatformDto.getAgeType()!=null){
			List<Long> userIdList = remoteMemberService.listUserIdByAgeType(mgtBasePlatformDto.getAgeType()).getData();
			mgtBasePlatformDto.setUserIdList(userIdList);
			}
			List<Long> shopIdList = remoteShopService.listShopIdByPlTotal(mgtBasePlatformDto).getData();
			mgtBasePlatformDto.setShopIdList(shopIdList);
			MgtPlTotalActivityTotalVo totalActivityTotalVo = new MgtPlTotalActivityTotalVo();
			//日期全部时固定为5天
			if(StringUtils.isBlank(mgtBasePlatformDto.getStartDate())){
			mgtBasePlatformDto.setEndDate(DateUtils.getDate());
			@@ -4424,6 +4822,7 @@
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public void autoCancelOrder(String orderId) {
			//更新订单信息
			Order order = this.getById(orderId);
			@@ -4490,6 +4889,7 @@
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public void payBack(PartnerTransactionsResult transaction) {
			log.info("订单支付回调---"+transaction.toString());
			// Order order = this.getById(orderId);
			@@ -4610,8 +5010,6 @@
			}
			activityTotalChangeDto.setUserId(order.getUserId());
			remoteActivityService.changeActivityTotal(activityTotalChangeDto);


			//活动订单进行分账
			/*ProfitSharingApplyRequest request=new ProfitSharingApplyRequest();
			request.setAppid(this.appId);
			@@ -4621,7 +5019,6 @@
			}
			//修改支付记录生成支付记录
			orderPaymentService.updatePaySuccess(transaction.getOutTradeNo(), transaction.getTransactionId());

			PayRecord payRecord = new PayRecord();
			payRecord.setDelFlag(0);
			payRecord.setOrderId(orderId);
			@@ -4629,6 +5026,9 @@
			payRecord.setPayTime(order.getPayTime());
			payRecord.setPayType(1);
			payRecordService.save(payRecord);
			//删除超时取消延时任务
			redisService.deleteObject(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + orderId);
			remoteConfigService.deleteDelayTask(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode()+"-"+orderId);
			}

			@Override
			@@ -4656,6 +5056,7 @@
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public void refundOrder(String orderId) {
			// 更新订单信息
			Order order = this.getById(orderId);
			@@ -4801,6 +5202,7 @@
			// 更新会员统计信息
			remoteMemberService.changeMemberTotal(memberTotalChangeDto);
			// 如果订单来源于活动，则更新活动统计信息
			//TODO 可考虑改成定时任务统一查询后增加减少服务器压力但会增加延后性
			if (order.getOrderFrom() == 2) {
			ActivityTotalChangeDto activityTotalChangeDto = new ActivityTotalChangeDto();
			activityTotalChangeDto.setActivityId(order.getActivityId());
			@@ -5355,6 +5757,7 @@
			}
			}

			@GlobalTransactional(rollbackFor = Exception.class)
			private void autoTimeCancelOrder(Order order) {
			String orderId = order.getOrderId();
			order.setOrderStatus(0);
			@@ -5434,9 +5837,6 @@
			List<MerOrderPageVo> merOrderPageVoList = orderMapper.pageMerMemberPayOrder(page, merOrderPageDto);
			if (merOrderPageVoList != null && !merOrderPageVoList.isEmpty()) {
			Long userId;
			Member member;
			Integer orderFrom;
			String orderFromDesc;
			BigDecimal zeroBig = new BigDecimal("0.00");
			StringJoiner userIdSj = new StringJoiner(",");
			for (MerOrderPageVo merOrderPageVo : merOrderPageVoList) {
			@@ -5513,4 +5913,17 @@
			public MerMemberSimpleTotalVo getMerMemberSimpleTotalVo(MerBaseDto merBaseDto){
			return orderMapper.getMerMemberSimpleTotalVo(merBaseDto);
			}

			@Override
			public ProfitSharingResult queryBill(String orderId) throws WxPayException {
			OrderPayment orderPayment = orderPaymentService.getByOrderId(orderId);
			ProfitSharing profitSharing = profitSharingService.getByOrderId(orderId);

			ProfitSharingQueryRequest request = new ProfitSharingQueryRequest();
			request.setSubMchid("1650744551");
			request.setTransactionId(orderPayment.getTransactionId());
			request.setOutOrderNo(profitSharing.getShareId());
			ProfitSharingResult profitSharingResult = wxService.getEcommerceService().queryProfitSharing(request);
			return profitSharingResult;
			}
			}