java/HongRuiTang.git

			@@ -1,28 +1,35 @@
			package com.ruoyi.order.service.impl.order;


			import com.alibaba.fastjson.JSONArray;
			import com.alibaba.fastjson2.JSON;
			import com.alibaba.fastjson2.JSONObject;
			import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import com.baomidou.mybatisplus.core.toolkit.Wrappers;
			import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
			import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
			import com.github.binarywang.wxpay.bean.ecommerce.PartnerTransactionsRequest;
			import com.github.binarywang.wxpay.bean.ecommerce.PartnerTransactionsResult;
			import com.github.binarywang.wxpay.bean.ecommerce.RefundNotifyResult;
			import com.github.binarywang.wxpay.bean.ecommerce.TransactionsResult;
			import com.github.binarywang.wxpay.bean.ecommerce.*;
			import com.github.binarywang.wxpay.bean.ecommerce.enums.TradeTypeEnum;
			import com.github.binarywang.wxpay.bean.profitsharingV3.ProfitSharingNotifyResult;
			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.constant.CacheConstants;
			import com.ruoyi.common.core.constant.Constants;
			import com.ruoyi.common.core.domain.R;
			import com.ruoyi.common.core.enums.UserStatus;
			import com.ruoyi.common.core.exception.ServiceException;
			import com.ruoyi.common.core.text.Convert;
			import com.ruoyi.common.core.utils.DateUtils;
			import com.ruoyi.common.core.utils.StringUtils;
			import com.ruoyi.common.core.utils.ip.IpUtils;
			import com.ruoyi.common.core.utils.uuid.IdUtils;
			import com.ruoyi.common.redis.service.RedisService;
			import com.ruoyi.common.security.utils.CodeFactoryUtil;
			import com.ruoyi.common.security.utils.SecurityUtils;
			import com.ruoyi.order.config.WxPayConfiguration;
			import com.ruoyi.order.domain.dto.*;
			import com.ruoyi.order.domain.pojo.account.OrderPayment;
			import com.ruoyi.order.domain.pojo.account.OrderRefund;
			@@ -40,10 +47,12 @@
			import com.ruoyi.order.service.account.PaymentMessageService;
			import com.ruoyi.order.service.account.ProfitSharingService;
			import com.ruoyi.order.service.order.*;
			import com.ruoyi.order.util.HuiFuTianXiaUtil;
			import com.ruoyi.system.api.constant.AppErrorConstant;
			import com.ruoyi.system.api.constant.DelayTaskEnum;
			import com.ruoyi.system.api.constant.SecurityConstant;
			import com.ruoyi.system.api.domain.dto.*;
			import com.ruoyi.system.api.domain.poji.activity.Activity;
			import com.ruoyi.system.api.domain.poji.activity.ActivityRecord;
			import com.ruoyi.system.api.domain.poji.config.DelayTask;
			import com.ruoyi.system.api.domain.poji.goods.Goods;
			@@ -56,15 +65,23 @@
			import com.ruoyi.system.api.domain.poji.shop.Shop;
			import com.ruoyi.system.api.domain.poji.sys.SysUser;
			import com.ruoyi.system.api.domain.vo.*;
			import com.ruoyi.system.api.model.QwH5LoginVo;
			import com.ruoyi.system.api.model.QwUserDetailDto;
			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.beans.factory.annotation.Autowired;
			import org.springframework.beans.factory.annotation.Value;
			import org.springframework.stereotype.Service;
			import org.springframework.transaction.annotation.Transactional;

			import javax.annotation.Resource;
			import java.math.BigDecimal;
			import java.math.RoundingMode;
			import java.text.NumberFormat;
			import java.text.SimpleDateFormat;
			import java.time.LocalDate;
			import java.time.format.DateTimeFormatter;
			import java.util.*;
			@@ -81,7 +98,7 @@
			* @since 2023-04-25
			*/
			@Service
			@Slf4j
			@Log4j2
			public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {

			@Resource
			@@ -144,6 +161,11 @@
			@Resource
			private OrderRefundService orderRefundService;

			@Value("${wx.pay.callbackPath}")
			private String callbackPath;



			/**
			* @description: buyGoods
			* @param: appSureOrderDto
			@@ -154,6 +176,10 @@
			@Override
			public AppSureOrderVo buyGoods(AppSureOrderDto appSureOrderDto) {
			Long userId = appSureOrderDto.getUserId();
			Shop shop = remoteShopService.getShop(appSureOrderDto.getShopId()).getData();
			if(shop!=null&&shop.getShopStatus()!=1){
			throw new ServiceException(AppErrorConstant.SHOP_CLOSED);
			}
			// 初始化订单对象
			AppSureOrderVo appSureOrderVo = new AppSureOrderVo();
			// 初始化订单商品列表
			@@ -178,7 +204,7 @@
			String goodsId;
			Integer buyNum;
			BigDecimal buyNumBig;
			String memberCouponId;
			Long memberCouponId;
			Goods goods;
			BigDecimal goodsPrice;
			BigDecimal goodsTotalPrice;
			@@ -208,7 +234,7 @@
			BigDecimal orderPayDeposit = new BigDecimal("0.00");
			BigDecimal orderPayMoney = new BigDecimal("0.00");
			// 遍历购买商品列表
			HashSet<String> userCouponIdSet = new HashSet<>();
			HashSet<Long> userCouponIdSet = new HashSet<>();
			for (AppBuyGoodsDto appBuyGoodsDto : appBuyGoodsDtoList) {
			appSureOrderGoodsVo = new AppSureOrderGoodsVo();
			discountMoney = BigDecimal.ZERO;
			@@ -245,8 +271,11 @@
			goodsTotalPrice = goodsPrice.multiply(buyNumBig);
			goodsRealPrice = goodsTotalPrice;
			// 处理优惠券
			if (StringUtils.isNotBlank(memberCouponId)) {
			appMemberCouponVo = appMemberCouponVoMap.get(memberCouponId);
			if (null != memberCouponId) {
			appMemberCouponVo = appMemberCouponVoMap.get(memberCouponId.toString());
			System.err.println(JSON.toJSONString(appMemberCouponVoMap));
			System.err.println(memberCouponId);
			System.err.println(JSON.toJSONString(appMemberCouponVo));
			if (StringUtils.isBlank(appMemberCouponVo.getRelGoodsIds()) \|\| appMemberCouponVo.getRelGoodsIds().contains(goodsId)) {
			couponType = appMemberCouponVo.getCouponType();
			if (couponType == 1 && appMemberCouponVo.getMoneyThreshold() != null && appMemberCouponVo.getDiscountMoney() != null) {
			@@ -256,7 +285,7 @@
			goodsRealPrice = goodsTotalPrice.subtract(discountMoney);
			useCoupon = 1;
			userCouponIdSet.add(memberCouponId);
			appSureOrderGoodsVo.setMemberCouponId(memberCouponId);
			appSureOrderGoodsVo.setMemberCouponId(memberCouponId.toString());
			}
			} else if (couponType == 2 && appMemberCouponVo.getDiscountPercent() != null) {
			discountPercent = appMemberCouponVo.getDiscountPercent();
			@@ -264,7 +293,7 @@
			discountMoney = goodsTotalPrice.subtract(goodsRealPrice);
			useCoupon = 1;
			userCouponIdSet.add(memberCouponId);
			appSureOrderGoodsVo.setMemberCouponId(memberCouponId);
			appSureOrderGoodsVo.setMemberCouponId(memberCouponId.toString());
			} else if (couponType == 3 && appMemberCouponVo.getDiscountMoney() != null) {
			discountMoney = appMemberCouponVo.getDiscountMoney();
			if (goodsTotalPrice.compareTo(discountMoney) > 0) {
			@@ -274,7 +303,7 @@
			}
			useCoupon = 1;
			userCouponIdSet.add(memberCouponId);
			appSureOrderGoodsVo.setMemberCouponId(memberCouponId);
			appSureOrderGoodsVo.setMemberCouponId(memberCouponId.toString());
			}
			}
			}
			@@ -310,8 +339,6 @@
			} else {
			entity.setUseFlag(0);
			}


			}
			// 过滤商品优惠券列表
			List<AppMemberCouponVo> appGoodsMemberCouponVoList;
			@@ -340,58 +367,6 @@
			sureOrderGoodsVo.setAppMemberCouponVoList(appGoodsMemberCouponVoList);
			}
			}
			/*if (appMemberCouponVoList != null && !appMemberCouponVoList.isEmpty()) {
			// 获取商品关联优惠券
			appGoodsMemberCouponVoList = new ArrayList<>();
			for(AppSureOrderGoodsVo sureOrderGoodsVo : appSureOrderGoodsVoList){
			for (AppMemberCouponVo entity : appMemberCouponVoList) {
			if (StringUtils.isBlank(entity.getRelGoodsIds())) {
			if (entity.getCouponType() == 1 && entity.getMoneyThreshold() != null && entity.getDiscountMoney() != null) {
			moneyThreshold = entity.getMoneyThreshold();
			if (sureOrderGoodsVo.getGoodsTotalPrice().compareTo(moneyThreshold) >= 0) {
			if(userCouponIdSet==null\|\|!userCouponIdSet.contains(entity.getMemberCouponId())){
			appGoodsMemberCouponVoList.add(entity);
			}else{
			if(sureOrderGoodsVo.getMemberCouponId()!=null&&sureOrderGoodsVo.getMemberCouponId().equals(entity.getMemberCouponId())){
			appGoodsMemberCouponVoList.add(entity);
			}
			}
			}
			}else{
			if(userCouponIdSet==null\|\|!userCouponIdSet.contains(entity.getMemberCouponId())){
			appGoodsMemberCouponVoList.add(entity);
			}else{
			if(sureOrderGoodsVo.getMemberCouponId()!=null&&sureOrderGoodsVo.getMemberCouponId().equals(entity.getMemberCouponId())){
			appGoodsMemberCouponVoList.add(entity);
			}
			}
			}
			} else if (entity.getRelGoodsIds().contains(sureOrderGoodsVo.getGoodsId())) {
			if (entity.getCouponType() == 1 && entity.getMoneyThreshold() != null && entity.getDiscountMoney() != null) {
			moneyThreshold = entity.getMoneyThreshold();
			if (sureOrderGoodsVo.getGoodsTotalPrice().compareTo(moneyThreshold) >= 0) {
			if(userCouponIdSet==null\|\|!userCouponIdSet.contains(entity.getMemberCouponId())){
			appGoodsMemberCouponVoList.add(entity);
			}else{
			if(sureOrderGoodsVo.getMemberCouponId()!=null&&sureOrderGoodsVo.getMemberCouponId().equals(entity.getMemberCouponId())){
			appGoodsMemberCouponVoList.add(entity);
			}
			}
			}
			}else{
			if(userCouponIdSet==null\|\|!userCouponIdSet.contains(entity.getMemberCouponId())){
			appGoodsMemberCouponVoList.add(entity);
			}else{
			if(sureOrderGoodsVo.getMemberCouponId()!=null&&sureOrderGoodsVo.getMemberCouponId().equals(entity.getMemberCouponId())){
			appGoodsMemberCouponVoList.add(entity);
			}
			}
			}
			}
			}
			sureOrderGoodsVo.setAppMemberCouponVoList(appGoodsMemberCouponVoList);
			}
			}*/
			// 设置订单相关金额
			appSureOrderVo.setOrderGoodsMoney(orderGoodsMoney);
			appSureOrderVo.setCouponDiscount(couponDiscount);
			@@ -412,6 +387,10 @@
			@Override
			public AppPanicBuyVo panicBuyGoods(AppPanicBuyDto appPanicBuyDto) {
			Long userId = appPanicBuyDto.getUserId();
			Shop shop = remoteShopService.getShop(appPanicBuyDto.getShopId()).getData();
			if(shop!=null&&shop.getShopStatus()!=1){
			throw new ServiceException(AppErrorConstant.SHOP_CLOSED);
			}
			AppPanicBuyVo appPanicBuyVo = new AppPanicBuyVo();
			String activityId = appPanicBuyDto.getActivityId();
			String goodsId = appPanicBuyDto.getGoodsId();
			@@ -502,9 +481,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();
			// 创建商品列表
			@@ -532,7 +518,7 @@
			BigDecimal buyNumBig;
			Integer serviceNum;
			Integer goodsNum = 0;
			String memberCouponId;
			Long memberCouponId;
			Goods goods = null;
			GoodsFile goodsFile;
			BigDecimal goodsPrice;
			@@ -546,6 +532,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");
			@@ -558,6 +545,7 @@
			BigDecimal orderPayMoney = new BigDecimal("0.00");
			// 创建订单ID和订单号
			String orderId = IdUtils.simpleUUID();

			String orderNo = CodeFactoryUtil.getShopOrderNo();
			OrderGoods orderGoods;
			String orderGoodsId;
			@@ -591,7 +579,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();
			@@ -607,7 +595,10 @@
			goodsRealPrice = goodsTotalPrice;
			// 如果使用了优惠券，计算优惠后的价格
			if (memberCouponId != null) {
			appMemberCouponVo = appMemberCouponVoMap.get(memberCouponId);
			appMemberCouponVo = appMemberCouponVoMap.get(memberCouponId.toString());
			if(null == appMemberCouponVo){
			throw new ServiceException("优惠券已使用");
			}
			// 如果优惠券适用于该商品
			if (StringUtils.isBlank(appMemberCouponVo.getRelGoodsIds()) \|\| appMemberCouponVo.getRelGoodsIds().contains(goodsId)) {
			couponType = appMemberCouponVo.getCouponType();
			@@ -634,7 +625,7 @@
			discountMoney = goodsTotalPrice;
			}
			}
			memberCouponSJ.add(memberCouponId);
			memberCouponSJ.add(memberCouponId + "");
			}
			appSureOrderGoodsVo.setUseCoupon(useCoupon);
			appSureOrderGoodsVo.setGoodsTotalPrice(goodsTotalPrice);
			@@ -734,47 +725,66 @@
			order.setOrderRemark(appPlaceOrderDto.getOrderRemark());
			order.setGoodsNum(goodsNum);
			order.setCreateTime(new Date());
			if(member.getBindingFlag()==0){
			order.setUnbindingFlag(1);
			}else{
			order.setUnbindingFlag(0);
			}
			// 保存订单
			this.save(order);
			// 更新用户商品类型
			appPlaceOrderVo.setOrderId(orderId);
			appPlaceOrderVo.setOrderNo(orderNo);
			//减去优惠券
			if (StringUtils.isNotBlank(memberCouponSJ.toString())) {
			remoteCouponService.useMemberCoupon(memberCouponSJ.toString());
			}
			//判断是否需要支付不需要直接待核销
			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));
			//商品数据
			String goodsName = "";
			if (null != goodsNameList) {
			goodsName = String.join(",", goodsNameList);
			}
			// // 小程序微信下单支付
			// createWxPayInfo(appPlaceOrderVo, userId, order.getShopId(), goodsName, outTradeNo,
			// orderId, order.getPayMoney(), appPlaceOrderDto.getOpenid(),
			// appPlaceOrderDto.getSpbillCreateIp());

			// 小程序微信下单支付 TODO 更换支付渠道（汇付天下）
			createWxPayInfo1(appPlaceOrderVo, userId, order.getShopId(), goodsName, outTradeNo,
			orderId, order.getPayMoney(), appPlaceOrderDto.getOpenid(),
			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);
			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);
			}
			// 更新用户商品类型统计
			if (goodsTypeSet != null && goodsTypeSet.size() > 0) {
			AppMemberGoodsTypeDto appMemberGoodsTypeDto = new AppMemberGoodsTypeDto();
			appMemberGoodsTypeDto.setUserId(userId);
			appMemberGoodsTypeDto.setGoodsTypeSet(goodsTypeSet);
			remoteMemberService.updateMemberGoodsType(appMemberGoodsTypeDto);
			}
			appPlaceOrderVo.setOrderId(orderId);
			appPlaceOrderVo.setOrderNo(orderNo);

			String goodsName = "";
			if (null != goodsNameList) {
			goodsName = String.join(",", goodsNameList);
			}

			// 小程序微信下单支付
			/*createWxPayInfo(appPlaceOrderVo, userId, order.getShopId(), goodsName, orderNo,
			orderId, order.getPayMoney(), appPlaceOrderDto.getOpenid(),
			appPlaceOrderDto.getSpbillCreateIp(), goodsNameList);*/


			//减去优惠券
			if (StringUtils.isNotBlank(memberCouponSJ.toString())) {
			remoteCouponService.useMemberCoupon(memberCouponSJ.toString());
			}
			//生成自动取消订单延时任务
			Integer delayTime = 30;
			if (redisService.hasKey(SecurityConstant.AUTO_CANCEL_ORDER_TIME)) {
			delayTime = redisService.getCacheObject(SecurityConstant.AUTO_CANCEL_ORDER_TIME);
			}
			redisService.setCacheObject(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + orderId, orderId, 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.setEndTime(DateUtils.addMinutes(order.getCreateTime(), delayTime));

			return appPlaceOrderVo;
			}

			@@ -784,27 +794,28 @@
			* @param userId
			* @param shopId
			* @param goodsName
			* @param orderNo
			* @param outTradeNo
			* @param orderId
			* @param payMoney
			* @param openid
			* @param payerClientIp
			* @param goodsNameList
			*/
			public void createWxPayInfo(AppPlaceOrderVo appPlaceOrderVo, Long userId, Long shopId,
			String goodsName, String orderNo,

			private void createWxPayInfo(AppPlaceOrderVo appPlaceOrderVo, Long userId, Long shopId,
			String goodsName, String outTradeNo,
			String orderId, BigDecimal payMoney,
			String openid, String payerClientIp, List<String> goodsNameList){
			String openid, String payerClientIp){
			try {
			// 创建支付订单
			//R<String> resultMch = remoteShopService.getShopSubMchId(shopId);
			String subMchId = "1650744551";
			//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());
			@@ -813,10 +824,11 @@
			String description = goodsName + "-商品购买";

			request.setDescription(description);
			request.setOutTradeNo(orderNo);
			request.setOutTradeNo(outTradeNo);
			request.setNotifyUrl(config.getNotifyUrl());
			// 结算信息
			PartnerTransactionsRequest.SettleInfo settleInfo = new PartnerTransactionsRequest.SettleInfo();
			// TODO 分账处理
			settleInfo.setProfitSharing(true);
			settleInfo.setSubsidyAmount(BigDecimal.ZERO);
			request.setSettleInfo(settleInfo);
			@@ -827,7 +839,10 @@
			amount.setTotal(totalFee);
			amount.setCurrency("CNY");
			request.setAmount(amount);

			Date endTime = appPlaceOrderVo.getEndTime();
			SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
			String rfc3339Format = formatter.format(endTime);
			request.setTimeExpire(rfc3339Format);
			// 支付者
			PartnerTransactionsRequest.Payer payer = new PartnerTransactionsRequest.Payer();
			payer.setSpOpenid(openid);
			@@ -837,7 +852,6 @@
			PartnerTransactionsRequest.SceneInfo sceneInfo = new PartnerTransactionsRequest.SceneInfo();
			sceneInfo.setPayerClientIp(payerClientIp);
			request.setSceneInfo(sceneInfo);

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

			// 请求参数
			@@ -860,13 +874,113 @@
			paymentMessageService.savePaymentMessage("1", orderId, payRequestJson, payResponseJson);

			// 保存支付订单统一下单支付记录
			orderPaymentService.saveOrderPayment(userId, shopId, subMchId, orderId, 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());
			}
			}




			/**
			* 小程序支付下单API
			* @param appPlaceOrderVo
			* @param userId
			* @param shopId
			* @param goodsName
			* @param outTradeNo
			* @param orderId
			* @param payMoney
			* @param openid
			* @param payerClientIp
			*/

			private void createWxPayInfo1(AppPlaceOrderVo appPlaceOrderVo, Long userId, Long shopId,
			String goodsName, String outTradeNo,
			String orderId, BigDecimal payMoney,
			String openid, String payerClientIp){
			try {
			WxPayConfig config = wxService.getConfig();
			PartnerTransactionsRequest request = new PartnerTransactionsRequest();
			request.setSpAppid(config.getAppId());
			request.setSpMchid(config.getMchId());
			request.setSubMchid(config.getSubMchId());
			// 商品描述 body
			String description = goodsName + "-商品购买";

			request.setDescription(description);
			request.setOutTradeNo(outTradeNo);
			request.setNotifyUrl(callbackPath + "/order/app/notify/wechatPaymentCallback");

			R<com.alibaba.fastjson.JSONObject> r = HuiFuTianXiaUtil.weixinPayment(outTradeNo, description, payMoney.doubleValue(), openid, request.getNotifyUrl());
			if(r.getCode() != 200){
			throw new ServiceException(r.getMsg());
			}else{
			new Thread(new Runnable() {
			@Override
			public void run() {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
			int time = 0;
			for (int i = 0; i < 13; i++) {
			try {
			time += (5000 * i);
			Thread.sleep(time);
			} catch (InterruptedException e) {
			e.printStackTrace();
			}
			R<WeixinPaymentNotifyVo> voR = HuiFuTianXiaUtil.queryPayment(outTradeNo, sdf.format(new Date()));
			if(voR.getCode() == 200){
			WeixinPaymentNotifyVo data = voR.getData();
			//P：处理中；S：成功；F：失败；I: 初始（初始状态很罕见，请联系汇付技术人员处理）；
			String transStat = data.getTransStat();
			if("S".equals(transStat)){
			PartnerTransactionsResult transaction = new PartnerTransactionsResult();
			transaction.setOutTradeNo(data.getReqSeqId());
			payBack(transaction, data.getFeeFlag() == 1 ? BigDecimal.ZERO : new BigDecimal(data.getFeeAmount()));
			return;
			}
			if("P".equals(transStat) \|\| "F".equals(transStat)){
			continue;
			}
			log.error("支付失败，流水号：{}, 状态码：{}", outTradeNo, transStat);
			return;
			}else{
			log.error("支付查询失败！流水号：{}，结果：{}", outTradeNo, voR.getMsg());
			}
			}
			}
			}).start();
			}
			com.alibaba.fastjson.JSONObject data = r.getData();
			String mainMchId = WxPayConfiguration.getPlatformTyMacId();
			// 支付相关信息返回
			appPlaceOrderVo.setAppId(data.getString("appId"));
			appPlaceOrderVo.setMchId(config.getMchId());
			appPlaceOrderVo.setTimeStamp(data.getString("timeStamp"));
			appPlaceOrderVo.setNonceStr(data.getString("nonceStr"));
			appPlaceOrderVo.setPackageStr(data.getString("package"));
			appPlaceOrderVo.setSignType(data.getString("signType"));
			appPlaceOrderVo.setPaySign(data.getString("paySign"));

			// 保存支付订单统一下单日志
			paymentMessageService.savePaymentMessage("1", orderId, JSON.toJSONString(request), data.toJSONString());

			// 保存支付订单统一下单支付记录
			orderPaymentService.saveOrderPayment(userId, shopId, mainMchId, orderId, outTradeNo, payMoney,
			appPlaceOrderVo.getEndTime(), "Y", openid,
			goodsName, appPlaceOrderVo.getPackageStr());
			}catch (Exception e){
			e.printStackTrace();
			}

			}





			/**
			@@ -878,8 +992,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();
			// 定义商品订单对象
			@@ -888,273 +1009,270 @@
			String activityId = appPlaceActivityDto.getActivityId();
			String goodsId = appPlaceActivityDto.getGoodsId();
			Integer buyNum = appPlaceActivityDto.getBuyNum();
			//redis库存控制极简版
			//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());

			// 小程序微信下单支付 TODO 更换支付渠道（汇付天下）
			createWxPayInfo1(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());
			// 保存订单
			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);
			// 调用支付
			/*PrepayRequest request = new PrepayRequest();
			Amount amount = new Amount();
			amount.setTotal(Integer.parseInt(order.getPayMoney().multiply(new BigDecimal(100)).toString()));
			request.setAmount(amount);
			request.setAppid(this.appId);
			request.setMchid(this.mchId);
			request.setDescription(order.getGoodsInfo());
			request.setNotifyUrl(this.notifyUrl);
			request.setOutTradeNo(order.getOrderId());
			Payer payer = new Payer();
			// TODO 获取openID
			payer.setOpenid("oLTPCuN5a-nBD4rAL_fa********");

			request.setPayer(payer);*/

			//设置订单允许分账秒杀活动才允许分账
			/*if(order.getOrderFrom()==2){
			SettleInfo settleInfo=new SettleInfo();
			settleInfo.setProfitSharing(true);
			request.setSettleInfo(settleInfo);
			}*/


			//返回前端唤醒支付结果信息
			/*PrepayWithRequestPaymentResponse res = this.getJsApIResponse(request);

			appPlaceOrderVo.setAppId(this.appId);
			appPlaceOrderVo.setTimeStamp(res.getTimeStamp());
			appPlaceOrderVo.setNonceStr(res.getNonceStr());
			appPlaceOrderVo.setPackageStr(res.getPackageVal());
			appPlaceOrderVo.setTradeType(res.getSignType());
			appPlaceOrderVo.setPaySign(res.getPaySign());
			*/
			//生成活动参加记录
			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);
			//生成自动取消订单延时任务
			Integer delayTime = 30;
			if (redisService.hasKey(SecurityConstant.AUTO_CANCEL_ORDER_TIME)) {
			delayTime = redisService.getCacheObject(SecurityConstant.AUTO_CANCEL_ORDER_TIME);
			}
			redisService.setCacheObject(DelayTaskEnum.ORDER_AUTOMATIC_CANCEL.getCode() + "-" + orderId, orderId, 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.setEndTime(DateUtils.addMinutes(order.getCreateTime(), delayTime));
			return appPlaceOrderVo;
			}

			@@ -1168,32 +1286,141 @@
			*/
			@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;
			Shop shop;
			HashSet<Long> set = new HashSet<Long>();
			String activityId;
			HashSet<Long> shopSet = new HashSet<Long>();
			HashSet<String> activitySet = new HashSet<String>();
			// 遍历订单列表，获取店铺ID和活动ID
			for (AppUserOrderPageVo appUserOrderPageVo : appUserOrderPageVoList) {
			shopId = appUserOrderPageVo.getShopId();
			set.add(shopId);
			shopSet.add(shopId);
			if(appUserOrderPageVo.getOrderFrom()==2){
			activityId = appUserOrderPageVo.getActivityId();
			activitySet.add(activityId);
			}
			}
			Map<Long, Shop> shopMap = new HashMap<>();
			set.forEach(shopIdLong -> {
			Shop shopTemp = remoteShopService.getShop(shopIdLong).getData();
			shopMap.put(shopIdLong, shopTemp);
			});
			String shopJoinedString = String.join(",", shopSet.stream().map(Object::toString).collect(Collectors.toList()));
			MgtBaseBathDto mgtBaseBathDto = new MgtBaseBathDto();
			mgtBaseBathDto.setIds(shopJoinedString);
			List<MgtSimpleShopVo> simpleShopVoList = remoteShopService.listShopSimpleVoByIds(mgtBaseBathDto).getData();
			Map<Long, MgtSimpleShopVo> shopMap = simpleShopVoList.stream()
			.collect(Collectors.toMap(MgtSimpleShopVo::getShopId, Function.identity()));
			MgtSimpleShopVo simpleShopVo;
			Integer delayTime = 30;
			if (redisService.hasKey(SecurityConstant.AUTO_CANCEL_ORDER_TIME)) {
			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){
			//查询秒杀活动的参与店铺
			R<Activity> activity = remoteActivityService.getActivity(appUserOrderPageVo.getActivityId());
			if(activity.getCode() != 200){
			throw new RuntimeException(activity.getMsg());
			}
			Activity data = activity.getData();
			if(data.getAreaFlag() == 1){
			appUserOrderPageVo.setShopNumber(0);
			appUserOrderPageVo.setShopName("全部店铺");
			}
			if(data.getAreaFlag() == 2 && data.getShopFlag() == 1){
			String designatedArea = data.getDesignatedArea();
			String[] split = designatedArea.split(",");
			List<String> list = Arrays.asList(split);
			R<List<Shop>> listR = remoteShopService.listShopByCityCode(list);
			if(listR.getCode() != 200){
			throw new RuntimeException(listR.getMsg());
			}
			List<Shop> data1 = listR.getData();
			appUserOrderPageVo.setShopNumber(1);
			appUserOrderPageVo.setShopName(JSON.toJSONString(data1));
			}
			if(data.getShopFlag() == 2){
			String applicableShop = data.getApplicableShop();
			String[] split = applicableShop.split(",");
			List<String> list = Arrays.asList(split);
			R<List<Shop>> listR = remoteShopService.listShopByIds(list);
			if(listR.getCode() != 200){
			throw new RuntimeException(listR.getMsg());
			}
			List<Shop> data1 = listR.getData();
			appUserOrderPageVo.setShopNumber(1);
			appUserOrderPageVo.setShopName(JSON.toJSONString(data1));
			}
			}else if(member.getBindingFlag()==1&&appUserOrderPageVo.getOrderFrom()==2){
			Long relationShopId = member.getRelationShopId();
			R<Shop> shop = remoteShopService.getShop(relationShopId);
			if(shop.getCode() != 200){
			throw new RuntimeException(shop.getMsg());
			}
			Shop data1 = shop.getData();
			//查询秒杀活动的参与店铺
			R<Activity> activity = remoteActivityService.getActivity(appUserOrderPageVo.getActivityId());
			if(activity.getCode() != 200){
			throw new RuntimeException(activity.getMsg());
			}
			Activity data = activity.getData();
			if(data.getAreaFlag() == 1){
			appUserOrderPageVo.setShopNumber(2);
			appUserOrderPageVo.setShopName(data1.getShopName());
			appUserOrderPageVo.setShopServicePhone(data1.getShopServicePhone());
			}
			if(data.getAreaFlag() == 2 && data.getShopFlag() == 1){
			String designatedArea = data.getDesignatedArea();
			String[] split = designatedArea.split(",");
			List<String> list = Arrays.asList(split);
			R<List<Shop>> listR = remoteShopService.listShopByCityCode(list);
			if(listR.getCode() != 200){
			throw new RuntimeException(listR.getMsg());
			}
			List<Shop> data2 = listR.getData();
			List<Long> collect = data2.stream().map(Shop::getShopId).collect(Collectors.toList());
			if(collect.contains(relationShopId)){
			appUserOrderPageVo.setShopNumber(2);
			appUserOrderPageVo.setShopName(data1.getShopName());
			appUserOrderPageVo.setShopServicePhone(data1.getShopServicePhone());
			}else{
			appUserOrderPageVo.setShopNumber(1);
			appUserOrderPageVo.setShopName(JSON.toJSONString(data2));
			}
			}
			if(data.getShopFlag() == 2){
			String applicableShop = data.getApplicableShop();
			String[] split = applicableShop.split(",");
			List<String> list = Arrays.asList(split);
			R<List<Shop>> listR = remoteShopService.listShopByIds(list);
			if(listR.getCode() != 200){
			throw new RuntimeException(listR.getMsg());
			}
			List<Shop> data2 = listR.getData();
			List<Long> collect = data2.stream().map(Shop::getShopId).collect(Collectors.toList());
			if(collect.contains(relationShopId)){
			appUserOrderPageVo.setShopNumber(2);
			appUserOrderPageVo.setShopName(data1.getShopName());
			appUserOrderPageVo.setShopServicePhone(data1.getShopServicePhone());
			}else{
			appUserOrderPageVo.setShopNumber(1);
			appUserOrderPageVo.setShopName(JSON.toJSONString(data2));
			}
			}



			}else{
			simpleShopVo = shopMap.get(appUserOrderPageVo.getShopId());
			appUserOrderPageVo.setShopName(simpleShopVo.getShopName());
			appUserOrderPageVo.setShopServicePhone(simpleShopVo.getShopServicePhone());
			appUserOrderPageVo.setShopNumber(2);
			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));
			@@ -1235,7 +1462,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);
			@@ -1256,6 +1483,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.待核销 -> 订单退款
			@@ -1263,6 +1493,58 @@
			} else {
			throw new ServiceException(AppErrorConstant.CANCEL_ERROR_ORDER);
			}
			}

			/**
			* @description 支付订单
			* @author jqs
			* @date 2023/8/27 15:26
			* @param orderId
			* @return AppPlaceOrderVo
			*/
			@Override
			public AppPlaceOrderVo payOrder(String orderId){
			// 根据订单ID获取订单
			Order order = this.getById(orderId);
			// 如果订单状态不是1（待支付），抛出异常
			if(order.getOrderStatus() != 1){
			throw new ServiceException(AppErrorConstant.CANCEL_CANCEL_ORDER);
			}
			// 从缓存中获取支付信息
			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());
			appPlaceOrderVo.setPayMoney(order.getPayMoney());
			appPlaceOrderVo.setUnpaidMoney(order.getReceivableMoney().subtract(order.getPayMoney()));
			appPlaceOrderVo.setEndTime(DateUtils.addMinutes(order.getCreateTime(), delayTime));
			appPlaceOrderVo.setAppId(payArr[0]);
			appPlaceOrderVo.setMchId(orderPayment.getSubMchId());
			appPlaceOrderVo.setTimeStamp(payArr[1]);
			appPlaceOrderVo.setNonceStr(payArr[2]);
			appPlaceOrderVo.setPackageStr(payArr[3]);
			appPlaceOrderVo.setSignType(payArr[4]);
			appPlaceOrderVo.setPaySign(payArr[5]);
			appPlaceOrderVo.setPrepayId(orderPayment.getPrepayId());
			// 返回AppPlaceOrderVo对象
			return appPlaceOrderVo;
			}

			/**
			@@ -1293,7 +1575,64 @@
			*/
			@Override
			public MerHomeShopTotalVo getMerHomeTotal(MerHomeShopTotalVo merHomeShopTotalVo) {
			Long shopId = merHomeShopTotalVo.getShopId();
			// 查询用户信息
			QwUserDetailDto qwUserDetail = new QwUserDetailDto();
			Long userId = SecurityUtils.getUserId();
			qwUserDetail.setUserid(userId.toString());
			// 查询用户信息
			R<QwH5LoginVo> userResult = remoteShopService.qwH5Login(qwUserDetail);
			if(userResult==null){
			throw new ServiceException(AppErrorConstant.USER_NO_SHOP);
			}
			if (R.FAIL == userResult.getCode())
			{
			throw new ServiceException(userResult.getMsg());
			}
			if (401 == userResult.getCode())
			{
			throw new ServiceException("商户已被冻结,请联系管理员",401);
			}
			QwH5LoginVo userInfo = userResult.getData();
			SysUser user = userInfo.getSysUser();
			String username = user.getUserName();
			// IP黑名单校验
			String blackStr = Convert.toStr(redisService.getCacheObject(CacheConstants.SYS_LOGIN_BLACKIPLIST));
			if (IpUtils.isMatchedIp(blackStr, IpUtils.getIpAddr()))
			{
			throw new ServiceException("很遗憾，访问IP已被列入系统黑名单");
			}
			if (UserStatus.DELETED.getCode().equals(user.getDelFlag()))
			{
			throw new ServiceException("对不起，您的账号：" + username + " 已被删除");
			}
			if (UserStatus.DISABLE.getCode().equals(user.getStatus()))
			{
			throw new ServiceException("对不起，您的账号：" + username + " 已停用");
			}
			// 查询用户商户
			R<ShopRelUserVo> shopResult = remoteShopService.getShopByUserId(user.getUserId());
			if (R.FAIL == userResult.getCode()) {
			throw new ServiceException(userResult.getMsg());
			}
			ShopRelUserVo shopInfo = shopResult.getData();
			if(null == shopInfo){
			throw new ServiceException("未查询到商户信息");
			}
			Long shopId = shopInfo.getShopId();
			Shop shop = remoteShopService.getShop(shopId).getData();
			if(-1 == shop.getShopStatus()){
			throw new ServiceException("对应商户已删除，请联系管理员");
			}
			if(0 == shop.getShopStatus()){
			throw new ServiceException("对应商户已冻结，请联系管理员");
			}
			if(2 == shop.getShopStatus()){
			throw new ServiceException("对应商户已终止合作，请联系管理员");
			}


			shopId = merHomeShopTotalVo.getShopId();

			//获取今日到店
			Integer todayShop = userServiceRecordService.countShopServicePerson(shopId);
			//获取待处理订单和营业额
			@@ -1324,11 +1663,92 @@
			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.getOrderFrom()==2&&!member.getRelationShopId().equals(shopId)) {
			throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
			}
			if(order.getOrderFrom() == 1){
			//商城订单和绑定后活动订单判断核销商户和订单商户和用户关联商户是否统一
			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());
			@@ -1360,8 +1780,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());
			@@ -1378,6 +1796,7 @@
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public MerVerifyOrderVo sureVerifyOrder(MerVerifyOrderDto merVerifyOrderDto) {
			String orderId = merVerifyOrderDto.getOrderId();
			BigDecimal relReceiveMoney = merVerifyOrderDto.getRelReceiveMoney();
			@@ -1388,11 +1807,49 @@
			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();
			log.info("当前核销员工【" + shopRelUserVo.getUserName() + "】门店ID：" + shopId);
			//获取订单商品列表
			List<AppUserOrderGoodsPageVo> appUserOrderGoodsPageVoList = orderGoodsService.listAppVoByOrderId(orderId);
			//绑定用户判断核销商户
			if(member.getBindingFlag()==1){
			//未绑定的活动订单只需要判断店铺是否支持
			if(order.getOrderFrom()==2 && !member.getRelationShopId().equals(shopId)){
			throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
			}
			if(order.getOrderFrom()==2 && member.getRelationShopId().equals(shopId)){
			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.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);
			}
			}
			}
			order.setShopId(shopId);
			order.setOrderStatus(3);
			order.setUseTime(nowTime);
			order.setUseUserId(merVerifyOrderDto.getUserId());
			@@ -1400,6 +1857,7 @@
			order.setOffPayTime(nowTime);
			order.setPayMoney(order.getPayMoney().add(relPayMoney));
			order.setChangeReceivableMoney(relReceiveMoney);
			//判断订单是否结清
			if (order.getPayMoney().compareTo(order.getChangeReceivableMoney()) >= 0) {
			order.setCloseFlag(1);
			} else {
			@@ -1407,7 +1865,7 @@
			}
			this.saveOrUpdate(order);
			//创建服务商品
			List<AppUserOrderGoodsPageVo> appUserOrderGoodsPageVoList = orderGoodsService.listAppVoByOrderId(orderId);
			//获取商品信息(商品简介,调理问题)
			StringJoiner goodsIdSj = new StringJoiner(",");
			for (AppUserOrderGoodsPageVo appUserOrderGoodsPageVo : appUserOrderGoodsPageVoList) {
			goodsIdSj.add(appUserOrderGoodsPageVo.getGoodsId());
			@@ -1419,9 +1877,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());
			@@ -1485,11 +1945,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);
			@@ -1498,9 +1953,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{
			@@ -1508,16 +1966,38 @@
			}
			}
			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());
			//
			if (order.getOrderFrom() == 2) {
			// profitsSharingService.applyProfitSharing();
			//判断用户是否绑定 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时进行分账
			OrderPayment orderPayment = orderPaymentService.getOne(new QueryWrapper<OrderPayment>()
			.eq("order_id", order.getOrderId()).eq("pay_status", 2)
			.eq("del_flag", 0));
			BigDecimal bigDecimal = orderPayment.getPayMoney().subtract(orderPayment.getFeeAmount()).setScale(2, BigDecimal.ROUND_HALF_EVEN);
			if (bigDecimal.compareTo(BigDecimal.ZERO)>0) {
			// TODO: 2023/10/17 更换分账渠道（汇付天下）
			// submitProfitSharing(orderId, order.getOrderNo(), order.getShopId(), order.getOnlinePayMoney(),order.getOrderFrom());
			submitProfitSharing1(orderId, order.getOrderNo(), order.getShopId(), bigDecimal, order.getOrderFrom());
			}
			//创建支付记录
			if(merVerifyOrderDto.getRelPayMoney().compareTo(BigDecimal.ZERO)>0){
			PayRecord payRecord = new PayRecord();
			@@ -1528,70 +2008,100 @@
			payRecord.setPayType(merVerifyOrderDto.getPayType());
			payRecordService.save(payRecord);
			}
			//submitProfitSharing(orderId, order.getOrderNo(), order.getShopId(), order.getOrderMoney());

			//更新用户积分和消费统计
			MemberTotalChangeDto memberTotalChangeDto = new MemberTotalChangeDto();
			memberTotalChangeDto.setUserId(order.getUserId());
			// 如果存在积分兑换比例，则计算积分
			if (redisService.hasKey(SecurityConstant.PAY_MONEY_INTEGRAL)) {
			Integer moneyValue = redisService.getCacheObject(SecurityConstant.PAY_MONEY_INTEGRAL);
			BigDecimal moneyValueBig = BigDecimal.valueOf(moneyValue);
			BigDecimal integralBig = moneyValueBig.multiply(order.getOnlinePayMoney()).setScale(0,BigDecimal.ROUND_HALF_UP);
			Integer integral = Integer.valueOf(integralBig.toString());
			if(integral>0){
			memberTotalChangeDto.setChangeIntegral(integral);
			memberTotalChangeDto.setTypeIntegral(1);
			memberTotalChangeDto.setOrderId(orderId);
			memberTotalChangeDto.setOrderNo(order.getOrderNo());
			}
			}
			//更新消费时间
			memberTotalChangeDto.setConsumeTime(nowTime);
			remoteMemberService.changeMemberTotal(memberTotalChangeDto);
			return merVerifyOrderVo;
			}

			/*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)) {


			R<ShopProportionVo> resultShopProportion = remoteShopService.getShopProportion(shopId);
			ShopProportionVo shopProportion = resultShopProportion.getData();
			if (null != shopProportion) {
			if (StringUtils.isEmpty(subMchId)) {
			throw new ServiceException("获取微信商户号失败");
			}
			// 平台特约商户号，用户平台收取服务费 2023-09-05改变分账方式
			String platformTyMacId = WxPayConfiguration.getPlatformTyMacId();
			if (!StringUtils.isEmpty(platformTyMacId)) {
			WxPayConfig config = wxService.getConfig();
			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.setSubMchid(subMchId);
			request.setAppid(config.getAppId());
			request.setSubMchid(platformTyMacId);
			request.setTransactionId(transactionId);
			request.setOutOrderNo(orderNo);
			List<Receiver> receiverList = new ArrayList<>();

			String description = "订单:" + orderNo + " 平台抽取佣金";
			BigDecimal proportionPercent = shopProportion.getProportionPercent();
			if (null == proportionPercent) {
			proportionPercent = BigDecimal.ZERO;
			request.setOutOrderNo(IdUtils.simpleUUID());
			List<ProfitSharingRequest.Receiver> receiverList = new ArrayList<>();
			String description = "订单:" + orderNo + " 平台分账";
			//商户分成
			if(proportionPercent.compareTo(BigDecimal.ZERO)>0){
			ProfitSharingResult result = new ProfitSharingResult();
			result.setOutOrderNo(orderNo);
			result.setStatus("FINISHED");
			// 计算分成金额
			int amount = orderMoney.multiply(proportionPercent).setScale(0, RoundingMode.UP).intValue();
			log.info("订单分账：{} 分账金额: {}", orderNo, amount);
			if (amount > 0) {
			// 分账创建
			ProfitSharingRequest.Receiver receiver = new ProfitSharingRequest.Receiver();
			receiver.setType("MERCHANT_ID");
			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);
			}

			ProfitSharingResult result = new ProfitSharingResult();
			result.setOutOrderNo(orderNo);
			result.setStatus("FINISHED");

			// 计算分成金额
			int amount = orderMoney.multiply(proportionPercent).setScale(0, RoundingMode.UP).intValue();
			log.info("订单分账：{} 分账金额: {}", orderNo, amount);
			if (amount > 0) {
			// 分账创建
			Receiver receiver = new Receiver();
			receiver.setType("MERCHANT_ID");
			receiver.setReceiverAccount(platformTyMacId);
			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);
			} else {
			resultMessage = String.format("订单分账：%s 获取商户分成失败", orderNo);
			log.info(resultMessage);
			@@ -1603,12 +2113,137 @@
			} catch (WxPayException e) {
			resultMessage = String.format("订单分账：%s 分账失败：%s", orderNo, e.getMessage());
			log.info(resultMessage);
			e.printStackTrace();
			throw new ServiceException(resultMessage);
			}

			// 保存分账信息
			paymentMessageService.savePaymentMessage("4", orderId, sendMessage, resultMessage);
			}*/
			}




			/**
			* @description 分账实现
			* @author jqs
			* @date 2023/9/8 11:56
			* @param orderId
			* @param orderNo
			* @param shopId
			* @param orderMoney
			* @param orderFrom
			* @return void
			*/
			private void submitProfitSharing1(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 outTradeNo = payment.getOutTradeNo();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
			String org_req_date = sdf.format(payment.getCreateTime());
			R<ShopAuthenticationHftxVo> resultMch = remoteShopService.getShopHFTXSubMchId(shopId);
			ShopAuthenticationHftxVo vo = resultMch.getData();
			if (StringUtils.isEmpty(vo.getHuifuId())) {
			throw new ServiceException("获取商户号失败");
			}
			// 平台特约商户号，用户平台收取服务费 2023-09-05改变分账方式
			String platformTyMacId = WxPayConfiguration.getPlatformTyMacId();
			if (!StringUtils.isEmpty(platformTyMacId)) {
			WxPayConfig config = wxService.getConfig();
			ShopProportionVo shopProportion = null;
			BigDecimal proportionPercent = null;
			//商户订单获取统一分成活动订单获取活动分成
			if(orderFrom==1){
			if(null == vo.getShareRatio()){
			proportionPercent = new BigDecimal(redisService.getCacheObject(SecurityConstant.SHOP_COMMON_PROPORTION).toString());
			}else{
			proportionPercent = new BigDecimal(vo.getShareRatio());
			}
			}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(platformTyMacId);
			request.setTransactionId(transactionId);
			request.setOutOrderNo(IdUtils.simpleUUID());
			List<ProfitSharingRequest.Receiver> receiverList = new ArrayList<>();
			String description = "订单:" + orderNo + " 平台分账";
			//商户分成
			if(proportionPercent.compareTo(BigDecimal.ZERO)>0){
			PaymentDelaytransHFTXVo result = new PaymentDelaytransHFTXVo();
			// 计算分成金额
			int amount = orderMoney.multiply(new BigDecimal(100)).setScale(0, RoundingMode.HALF_EVEN).intValue();
			BigDecimal multiply = orderMoney.multiply(proportionPercent.divide(new BigDecimal(100))).setScale(2, RoundingMode.HALF_EVEN);
			log.info("订单分账：{} 分账金额: {}", orderNo, amount);
			if (amount > 0) {
			// 分账创建
			ProfitSharingRequest.Receiver receiver = new ProfitSharingRequest.Receiver();
			receiver.setType("MERCHANT_ID");
			receiver.setReceiverAccount(vo.getHuifuId());
			receiver.setAmount(amount);
			receiver.setDescription(description);
			receiverList.add(receiver);
			request.setReceivers(receiverList);
			// 分账完成
			request.setFinish(true);

			//分账对象
			JSONArray acctInfos = new JSONArray();
			if(multiply.compareTo(BigDecimal.ZERO) > 0){
			JSONObject jsonObject = new JSONObject();
			jsonObject.put("div_amt", String.format("%.2f", multiply.doubleValue()));
			jsonObject.put("huifu_id", vo.getHuifuId());
			acctInfos.add(jsonObject);
			}
			//平台商户
			BigDecimal pt_amount = orderMoney.subtract(multiply).setScale(2, RoundingMode.HALF_EVEN);
			if(pt_amount.compareTo(BigDecimal.ZERO) > 0){
			JSONObject jsonObject1 = new JSONObject();
			jsonObject1.put("div_amt", String.format("%.2f", pt_amount.doubleValue()));
			jsonObject1.put("huifu_id", "6666000141216769");
			acctInfos.add(jsonObject1);
			}

			R<PaymentDelaytransHFTXVo> hftxVoR = HuiFuTianXiaUtil.paymentDelaytrans(request.getOutOrderNo(), org_req_date, outTradeNo, acctInfos);
			if(hftxVoR.getCode() != 200){
			throw new ServiceException(hftxVoR.getMsg());
			}
			result = hftxVoR.getData();
			// 创建分账记录
			profitSharingService.saveProfitSharing1(shopId, orderId, orderMoney, vo.getHuifuId(), multiply.doubleValue(), result);
			}
			// 保存请求信息
			sendMessage = JSONObject.toJSONString(request);
			resultMessage = JSONObject.toJSONString(result);
			}
			} else {
			resultMessage = String.format("订单分账：%s 获取商户分成失败", orderNo);
			log.info(resultMessage);
			}
			} else {
			resultMessage = String.format("订单分账：%s 获取微信商户号失败", orderNo);
			log.info(resultMessage);
			}
			} catch (Exception e) {
			e.printStackTrace();
			resultMessage = String.format("订单分账：%s 分账失败：%s", orderNo, e.getMessage());
			log.info(resultMessage);
			throw new ServiceException(resultMessage);
			}

			// 保存分账信息
			paymentMessageService.savePaymentMessage("4", orderId, sendMessage, resultMessage);
			}




			/**
			* @param merVerifyCouponDto
			@@ -1619,8 +2254,13 @@
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public MerVerifyCouponVo sureVerifyCoupon(MerVerifyCouponDto merVerifyCouponDto) {
			MerVerifyCouponGetVo verifyCouponGetVo = remoteCouponService.getVerifyCoupon(merVerifyCouponDto.getMemberCouponId()).getData();
			R<MerVerifyCouponGetVo> verifyCoupon = remoteCouponService.getVerifyCoupon(merVerifyCouponDto.getMemberCouponId());
			if(verifyCoupon.getCode() != 200){
			throw new ServiceException(verifyCoupon.getMsg());
			}
			MerVerifyCouponGetVo verifyCouponGetVo = verifyCoupon.getData();
			MemberCoupon memberCoupon = verifyCouponGetVo.getMemberCoupon();
			ShopRelUserVo shopRelUserVo = remoteShopService.getShopByUserId(merVerifyCouponDto.getUserId()).getData();
			Long userId = verifyCouponGetVo.getUserId();
			@@ -1629,7 +2269,7 @@
			// 调用remoteMemberService的getMember方法获取Member对象
			Member member = remoteMemberService.getMember(userId).getData();
			//如果是商户优惠券，验证商户一致
			if (memberCoupon.getCouponFrom() == 2 && !memberCoupon.getShopId().equals(shopId)) {
			if (memberCoupon.getCouponFrom() == 2) {
			if(!memberCoupon.getShopId().equals(member.getRelationShopId())){
			throw new ServiceException(AppErrorConstant.BLINDING_VERIFY_SHOP_ERROR);
			}
			@@ -1642,6 +2282,7 @@
			/*if(!memberCoupon.getShopId().equals(member.getRelationShopId())){
			throw new ServiceException(AppErrorConstant.BLINDING_VERIFY_SHOP_ERROR);
			}*/
			//判断绑定商户是否和核销商户一致
			if(!member.getRelationShopId().equals(shopId)){
			throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
			}
			@@ -1651,30 +2292,37 @@
			MerVerifyCouponVo merVerifyCouponVo = new MerVerifyCouponVo();
			// 调用remoteCouponService的getVerifyCoupon方法获取MerVerifyCouponGetVo对象
			List<Goods> goodsList = verifyCouponGetVo.getGoodsList();
			String relGoodsIds = memberCoupon.getRelGoodsIds();
			String[] relGoodsIdArr = relGoodsIds.split(",");
			if(relGoodsIdArr.length!=goodsList.size()){
			throw new ServiceException(AppErrorConstant.GOODS_DOWN);
			}
			merVerifyCouponVo.setUserName(member.getRealName());
			merVerifyCouponVo.setUserMobile(member.getMobile());
			merVerifyCouponVo.setCouponFrom(verifyCouponGetVo.getCouponFrom());
			merVerifyCouponVo.setCouponName(memberCoupon.getCouponName());
			merVerifyCouponVo.setCreateTime(memberCoupon.getReceiveTime());
			// 将goodsList转换为MerCouponGoodsListVo列表，并设置相应属性
			List<MerCouponGoodsListVo> merCouponGoodsList = goodsList.stream()
			.map(goods -> {
			MerCouponGoodsListVo merCouponGoods = new MerCouponGoodsListVo();
			merCouponGoods.setGoodsId(goods.getGoodsId());
			merCouponGoods.setGoodsName(goods.getGoodsName());
			if (goods.getGoodsType() == 1) {
			merCouponGoods.setGoodsType("周期");
			} else if (goods.getGoodsType() == 2) {
			merCouponGoods.setGoodsType("服务");
			} else if (goods.getGoodsType() == 3) {
			merCouponGoods.setGoodsType("体验");
			} else if (goods.getGoodsType() == 4) {
			merCouponGoods.setGoodsType("单品");
			}
			// 设置其他属性
			return merCouponGoods;
			})
			.collect(Collectors.toList());
			List<MerCouponGoodsListVo> merCouponGoodsList = new ArrayList<>();
			MerCouponGoodsListVo merCouponGoods;
			for(Goods goods : goodsList){
			if(goods.getGoodsStatus()!=1){
			throw new ServiceException(AppErrorConstant.GOODS_DOWN);
			}
			merCouponGoods = new MerCouponGoodsListVo();
			merCouponGoods.setGoodsId(goods.getGoodsId());
			merCouponGoods.setGoodsName(goods.getGoodsName());
			if (goods.getGoodsType() == 1) {
			merCouponGoods.setGoodsType("周期");
			} else if (goods.getGoodsType() == 2) {
			merCouponGoods.setGoodsType("服务");
			} else if (goods.getGoodsType() == 3) {
			merCouponGoods.setGoodsType("体验");
			} else if (goods.getGoodsType() == 4) {
			merCouponGoods.setGoodsType("单品");
			}
			merCouponGoodsList.add(merCouponGoods);
			}
			// 设置merVerifyCouponVo的goodsList属性为merCouponGoodsList
			merVerifyCouponVo.setGoodsList(merCouponGoodsList);
			//生成服务
			@@ -1722,6 +2370,7 @@
			merVerifyMemberCouponDto.setShopId(shopId);
			remoteCouponService.sureMemberCoupon(merVerifyMemberCouponDto);
			consumerGoodsService.saveBatchConsumerGoods(consumerGoodsList);
			//绑定未绑定用户
			if (member.getBindingFlag() != 1) {
			AppMemberBindingDto appMemberBindingDto = new AppMemberBindingDto();
			appMemberBindingDto.setBindingFlag(1);
			@@ -1745,6 +2394,7 @@
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public MerVerifyAwardVo sureVerifyPrize(MerVerifyPrizeDto merVerifyPrizeDto) {
			MerVerifyAwardVo merVerifyAwardVo = new MerVerifyAwardVo();
			MemberGiftRecord memberGiftRecord = remoteMemberService.getVerifyPrize(merVerifyPrizeDto.getPrizeId()).getData();
			@@ -1839,6 +2489,7 @@
			merVerifyPrizeFinalDto.setPrizeId(memberGiftRecord.getPrizeId());
			merVerifyPrizeFinalDto.setShopId(shop.getShopId());
			remoteMemberService.verifyPrize(merVerifyPrizeFinalDto);
			//绑定未绑定用户
			if (member.getBindingFlag() != 1) {
			AppMemberBindingDto appMemberBindingDto = new AppMemberBindingDto();
			appMemberBindingDto.setBindingFlag(1);
			@@ -1863,7 +2514,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) {
			@@ -1889,6 +2540,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 {
			@@ -1911,6 +2563,8 @@
			* @param merNewOrderDto
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public void createNewOrder(MerNewOrderDto merNewOrderDto) {
			Long userId = merNewOrderDto.getBuyUserId();
			Date nowTime = new Date();
			@@ -1924,6 +2578,9 @@
			SysUser sysUser;
			if (member != null) {
			sysUser = remoteUserService.getSysUser(member.getUserId()).getData();
			if(member.getBindingFlag()==1&&!member.getRelationShopId().equals(merNewOrderDto.getShopId())){
			throw new ServiceException(AppErrorConstant.USER_BINDING_ERROR);
			}
			} else {
			//创建新用户
			String memberId = IdUtils.simpleUUID();
			@@ -1957,7 +2614,7 @@
			BigDecimal buyNumBig;
			Integer serviceNum;
			Integer goodsNum = 0;
			String memberCouponId;
			Long memberCouponId;
			Goods goods;
			BigDecimal goodsPrice;
			BigDecimal goodsTotalPrice;
			@@ -1985,10 +2642,6 @@
			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");
			List<OrderGoods> orderGoodsList = new ArrayList<>();
			ConsumerGoods consumerGoods;
			String consumerGoodsId;
			@@ -2017,8 +2670,12 @@
			goodsRealPrice = goodsTotalPrice;
			//优惠券计算
			if (memberCouponId != null) {
			appMemberCouponVo = appMemberCouponVoMap.get(memberCouponId);
			log.info("使用优惠券：{}", memberCouponId);
			appMemberCouponVo = appMemberCouponVoMap.get(memberCouponId.toString());
			log.info("匹配的优惠券：{}", JSON.toJSONString(appMemberCouponVo));
			if (null != appMemberCouponVo && (StringUtils.isBlank(appMemberCouponVo.getRelGoodsIds()) \|\| appMemberCouponVo.getRelGoodsIds().contains(goodsId))) {
			log.info("可以使用优惠券：{}", JSON.toJSONString(appMemberCouponVo));
			couponType = appMemberCouponVo.getCouponType();
			couponType = appMemberCouponVo.getCouponType();
			if (couponType == 1 && appMemberCouponVo.getMoneyThreshold() != null && appMemberCouponVo.getDiscountMoney() != null) {
			moneyThreshold = appMemberCouponVo.getMoneyThreshold();
			@@ -2038,7 +2695,7 @@
			goodsRealPrice = BigDecimal.ZERO;
			discountMoney = goodsTotalPrice.subtract(goodsRealPrice);
			}
			memberCouponSJ.add(memberCouponId);
			memberCouponSJ.add(memberCouponId + ",");
			}
			}
			goodsDeposit = goods.getSubscription();
			@@ -2129,24 +2786,6 @@
			consumerGoodsList.add(consumerGoods);
			}
			}

			//商户变更计算
			switch (orderGoods.getGoodsType()) {
			case 1:
			cycleMoney = cycleMoney.add(orderGoods.getGoodsReceivableMoney());
			break;
			case 2:
			serviceMoney = serviceMoney.add(orderGoods.getGoodsReceivableMoney());
			break;
			case 3:
			experienceMoney = experienceMoney.add(orderGoods.getGoodsReceivableMoney());
			break;
			case 4:
			goodsMoney = goodsMoney.add(orderGoods.getGoodsReceivableMoney());
			break;
			default:
			break;
			}
			}
			//创建订单
			Order order = new Order();
			@@ -2186,14 +2825,6 @@
			} else {
			order.setCloseFlag(0);
			}
			//保存订单和服务
			this.save(order);
			orderGoodsService.saveBatch(orderGoodsList);
			consumerGoodsService.saveBatchConsumerGoods(consumerGoodsList);
			//减去优惠券
			if (StringUtils.isNotBlank(memberCouponSJ.toString())) {
			remoteCouponService.useMemberCoupon(memberCouponSJ.toString());
			}
			//用户未绑定则绑定商户
			Member member = remoteMemberService.getMember(userId).getData();
			if (member != null && member.getBindingFlag() != 1) {
			@@ -2205,16 +2836,23 @@
			appMemberBindingDto.setBindingFlag(1);
			appMemberBindingDto.setBindingType(3);
			remoteMemberService.updateMemberBinding(appMemberBindingDto);
			order.setNewMemberFlag(1);
			order.setUnbindingFlag(0);
			}
			//更新商户统计
			/*ShopTotalChangeDto shopTotalChangeDto = new ShopTotalChangeDto();
			shopTotalChangeDto.setShopId(order.getShopId());
			shopTotalChangeDto.setOrderType(1);
			shopTotalChangeDto.setCycleMoney(cycleMoney);
			shopTotalChangeDto.setServiceMoney(serviceMoney);
			shopTotalChangeDto.setExperienceMoney(experienceMoney);
			shopTotalChangeDto.setGoodsMoney(goodsMoney);
			remoteShopService.changeShopTotal(shopTotalChangeDto);*/
			//保存订单和服务
			this.save(order);
			orderGoodsService.saveBatch(orderGoodsList);
			consumerGoodsService.saveBatchConsumerGoods(consumerGoodsList);
			//减去优惠券
			if (StringUtils.isNotBlank(memberCouponSJ.toString())) {
			log.info("修改优惠券使用状态：{}", JSON.toJSONString(memberCouponSJ));
			remoteCouponService.useMemberCoupon(memberCouponSJ.toString());
			}
			//更新会员消费记录
			MemberTotalChangeDto memberTotalChangeDto = new MemberTotalChangeDto();
			memberTotalChangeDto.setUserId(order.getUserId());
			memberTotalChangeDto.setConsumeTime(nowTime);
			remoteMemberService.changeMemberTotal(memberTotalChangeDto);
			//创建支付记录
			PayRecord payRecord = new PayRecord();
			payRecord.setDelFlag(0);
			@@ -2266,7 +2904,7 @@
			if (orderFrom == 1) {
			orderFromDesc = "商城订单";
			} else if (orderFrom == 2) {
			orderFromDesc = "店铺砍价活动(" + merOrderPageVo.getActivityName() + ")";
			orderFromDesc = "平台秒杀活动(" + merOrderPageVo.getActivityName() + ")";
			} else {
			orderFromDesc = "线下创建";
			}
			@@ -2286,7 +2924,7 @@
			// 根据用户ID列表获取用户信息
			MgtBaseBathDto mgtBaseBathDto = new MgtBaseBathDto();
			mgtBaseBathDto.setIds(userIdSj.toString());
			List<MgtSimpleMemberVo> simpleMemberVoList = remoteMemberService.listSimpleVoByIds(mgtBaseBathDto).getData();
			List<MgtSimpleMemberVo> simpleMemberVoList = remoteMemberService.listSimpleVoByIds(userIdSj.toString()).getData();
			Map<Long, MgtSimpleMemberVo> userMap = simpleMemberVoList.stream()
			.collect(Collectors.toMap(MgtSimpleMemberVo::getUserId, Function.identity()));
			// 遍历订单列表，设置用户信息
			@@ -2355,8 +2993,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);
			@@ -2369,10 +3012,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
			@@ -2409,6 +3057,24 @@
			mgtShopOrderPageDto.setUserIds(mgtUserIdByKeywordVo.getUserIds());
			}
			}
			//数据权限
			List<Long> userId = remoteUserService.getScopeOfAuthorityUserId();
			BoardMemberTotalDto boardMemberTotalDto = new BoardMemberTotalDto();
			boardMemberTotalDto.setUserIds(userId);
			List<Shop> shops = remoteShopService.getShopBySysUserIds(boardMemberTotalDto);
			if (!shops.isEmpty()) {
			List<Long> collect = shops.stream().map(Shop::getShopId).collect(Collectors.toList());
			String join = collect.stream().map(Object::toString).collect(Collectors.joining(","));
			String shopIds = mgtShopOrderPageDto.getShopIds();
			if(StringUtils.isNotEmpty(shopIds)){
			shopIds = shopIds + "," + join;
			}else{
			shopIds = join;
			}
			mgtShopOrderPageDto.setShopIds(shopIds);
			}


			// 从数据库中获取活动订单列表
			List<MgtActivityOrderPageVo> activityOrderPageVoList = orderMapper.pageMgtActivityOrder(page, mgtShopOrderPageDto);
			// 如果列表不为空
			@@ -2419,7 +3085,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 转换为逗号分隔的字符串
			@@ -2433,12 +3102,16 @@
			.collect(Collectors.toMap(MgtSimpleShopVo::getShopId, Function.identity()));
			mgtBaseBathDto = new MgtBaseBathDto();
			mgtBaseBathDto.setIds(userJoinedString);
			List<MgtSimpleMemberVo> simpleMemberVoList = remoteMemberService.listSimpleVoByIds(mgtBaseBathDto).getData();
			List<MgtSimpleMemberVo> simpleMemberVoList = remoteMemberService.listSimpleVoByIds(userJoinedString).getData();
			Map<Long, MgtSimpleMemberVo> userMap = simpleMemberVoList.stream()
			.collect(Collectors.toMap(MgtSimpleMemberVo::getUserId, Function.identity()));
			// 遍历列表，设置店铺名称、用户名称和未支付金额
			for (MgtActivityOrderPageVo mgtActivityOrderPageVo : activityOrderPageVoList) {
			mgtActivityOrderPageVo.setShopName(shopMap.get(mgtActivityOrderPageVo.getShopId()).getShopName());
			if(mgtActivityOrderPageVo.getShopId()!=null){
			MgtSimpleShopVo mgtSimpleShopVo = shopMap.get(mgtActivityOrderPageVo.getShopId());
			mgtActivityOrderPageVo.setShopName(null == mgtSimpleShopVo ? "" : mgtSimpleShopVo.getShopName());

			}
			if (userMap.get(mgtActivityOrderPageVo.getUserId()) != null) {
			mgtActivityOrderPageVo.setNickName(userMap.get(mgtActivityOrderPageVo.getUserId()).getNickName());
			mgtActivityOrderPageVo.setUserName(userMap.get(mgtActivityOrderPageVo.getUserId()).getRealName());
			@@ -2480,6 +3153,22 @@
			if (StringUtils.isNotBlank(mgtUserIdByKeywordVo.getUserIds())) {
			mgtShopOrderPageDto.setUserIds(mgtUserIdByKeywordVo.getUserIds());
			}
			}
			//数据权限
			List<Long> userId = remoteUserService.getScopeOfAuthorityUserId();
			BoardMemberTotalDto boardMemberTotalDto = new BoardMemberTotalDto();
			boardMemberTotalDto.setUserIds(userId);
			List<Shop> shops = remoteShopService.getShopBySysUserIds(boardMemberTotalDto);
			if (!shops.isEmpty()) {
			List<Long> collect = shops.stream().map(Shop::getShopId).collect(Collectors.toList());
			String join = collect.stream().map(Object::toString).collect(Collectors.joining(","));
			String shopIds = mgtShopOrderPageDto.getShopIds();
			if(StringUtils.isNotEmpty(shopIds)){
			shopIds = shopIds + "," + join;
			}else{
			shopIds = join;
			}
			mgtShopOrderPageDto.setShopIds(shopIds);
			}
			MgtOrderTotal mgtOrderTotal = new MgtOrderTotal();
			MgtOrderTotal mgtOrderTotalFirst = orderMapper.totalOrderFirst(mgtShopOrderPageDto);
			@@ -2528,6 +3217,22 @@
			mgtShopOrderPageDto.setUserIds(mgtUserIdByKeywordVo.getUserIds());
			}
			}
			//数据权限
			List<Long> userId = remoteUserService.getScopeOfAuthorityUserId();
			BoardMemberTotalDto boardMemberTotalDto = new BoardMemberTotalDto();
			boardMemberTotalDto.setUserIds(userId);
			List<Shop> shops = remoteShopService.getShopBySysUserIds(boardMemberTotalDto);
			if (!shops.isEmpty()) {
			List<Long> collect = shops.stream().map(Shop::getShopId).collect(Collectors.toList());
			String join = collect.stream().map(Object::toString).collect(Collectors.joining(","));
			String shopIds = mgtShopOrderPageDto.getShopIds();
			if(StringUtils.isNotEmpty(shopIds)){
			shopIds = shopIds + "," + join;
			}else{
			shopIds = join;
			}
			mgtShopOrderPageDto.setShopIds(shopIds);
			}
			List<MgtShopOrderPageVo> shopOrderPageVoList = orderMapper.pageMgtShopOrder(page, mgtShopOrderPageDto);
			// 如果列表不为空
			if (!shopOrderPageVoList.isEmpty()) {
			@@ -2555,14 +3260,16 @@
			String userJoinedString = String.join(",", userIdSet.stream().map(Object::toString).collect(Collectors.toList()));
			MgtBaseBathDto mgtBaseBathDto = new MgtBaseBathDto();
			mgtBaseBathDto.setIds(userJoinedString);
			List<MgtSimpleMemberVo> simpleMemberVoList = remoteMemberService.listSimpleVoByIds(mgtBaseBathDto).getData();
			List<MgtSimpleMemberVo> simpleMemberVoList = remoteMemberService.listSimpleVoByIds(userJoinedString).getData();
			userMap = simpleMemberVoList.stream()
			.collect(Collectors.toMap(MgtSimpleMemberVo::getUserId, Function.identity()));
			}
			// 遍历列表，设置店铺名称、用户名称和未支付金额
			for (MgtShopOrderPageVo mgtShopOrderPageVo : shopOrderPageVoList) {
			if (shopMap != null && !shopMap.isEmpty()) {
			mgtShopOrderPageVo.setShopName(shopMap.get(mgtShopOrderPageVo.getShopId()).getShopName());
			if(shopMap.get(mgtShopOrderPageVo.getShopId())!=null){
			mgtShopOrderPageVo.setShopName(shopMap.get(mgtShopOrderPageVo.getShopId()).getShopName());
			}
			}
			if (userMap != null && !userMap.isEmpty()) {
			if (userMap.get(mgtShopOrderPageVo.getUserId()) != null) {
			@@ -2604,8 +3311,6 @@
			Order order = this.getById(orderId);
			// 获取会员信息
			Member member = remoteMemberService.getMember(order.getUserId()).getData();
			// 获取商店信息
			Shop shop = remoteShopService.getShop(order.getShopId()).getData();
			// 获取订单商品详细信息
			List<MgtOrderGoodsDetailVo> orderGoodsDetailVoList = orderGoodsService.listMgtVoByOrderId(orderId);
			// 设置MgtOrderDetailVo属性
			@@ -2635,6 +3340,7 @@
			}
			// 设置订单编号
			mgtOrderDetailVo.setOrderNo(order.getOrderNo());
			mgtOrderDetailVo.setOutTradeNo(order.getOutTradeNo());
			// 设置订单来源
			switch (order.getOrderFrom()) {
			case 1:
			@@ -2665,10 +3371,12 @@
			mgtOrderDetailVo.setCancelTime(order.getCancelTime());
			mgtOrderDetailVo.setOrderRemark(order.getOrderRemark());
			mgtOrderDetailVo.setShopId(order.getShopId());
			if (shop != null) {
			if (3 == order.getOrderStatus()) {
			// 获取商店信息
			Shop shop = remoteShopService.getShop(order.getShopId()).getData();
			mgtOrderDetailVo.setShopName(shop.getShopName());
			} else {
			mgtOrderDetailVo.setShopName("商户已被删除");
			mgtOrderDetailVo.setShopName("");
			}
			mgtOrderDetailVo.setVerifyTime(order.getUseTime());
			//获取支付记录
			@@ -2685,9 +3393,13 @@
			* @date 2023/6/18 17:20
			*/
			@Override
			public MgtBulletinBoardVo boardOrderTotal() {
			MgtBulletinBoardVo mgtBulletinBoardVo = orderMapper.boardOrderTotal();
			Integer activityUserTotal = orderMapper.activityUserTotal();
			public MgtBulletinBoardVo boardOrderTotal(List<Long> userIds) {
			BoardMemberTotalDto boardMemberTotalDto = new BoardMemberTotalDto();
			boardMemberTotalDto.setUserIds(userIds);
			List<Shop> shopList = remoteShopService.getShopBySysUserIds(boardMemberTotalDto);
			List<Long> collect = shopList.stream().map(Shop::getShopId).collect(Collectors.toList());
			MgtBulletinBoardVo mgtBulletinBoardVo = orderMapper.boardOrderTotal(collect);
			Integer activityUserTotal = orderMapper.activityUserTotal(collect);
			mgtBulletinBoardVo.setActivityUserTotal(activityUserTotal);
			return mgtBulletinBoardVo;
			}
			@@ -2701,55 +3413,98 @@
			*/
			@Override
			public MgtTotalOrderTotalVo getTotalOrderTotal(MgtBaseShopDto mgtBaseShopDto) {
			//订单数量订单金额
			MgtTotalOrderTotalVo mgtTotalOrderTotalVo = orderMapper.getTotalOrderTotalOrderFrom(mgtBaseShopDto);
			//MgtTotalOrderTotalVo mgtTotalOrderTotalVoGoodsType = orderMapper.getTotalOrderTotalGoodsType(mgtBaseShopDto);
			List<MgtMapTotalPlusVo> MgtMapIntTotalVos = orderMapper.listTotalOrderTotal(mgtBaseShopDto);
			if (MgtMapIntTotalVos != null && MgtMapIntTotalVos.size() > 0) {
			String[] orderTotalKey = new String[MgtMapIntTotalVos.size()];
			Integer[] orderTotalValue = new Integer[MgtMapIntTotalVos.size()];
			BigDecimal[] orderMoneyValue = new BigDecimal[MgtMapIntTotalVos.size()];
			for (int i = 0; i < MgtMapIntTotalVos.size(); i++) {
			orderTotalKey[i] = MgtMapIntTotalVos.get(i).getMapKey();
			orderTotalValue[i] = MgtMapIntTotalVos.get(i).getMapValueFirst();
			orderMoneyValue[i] = MgtMapIntTotalVos.get(i).getMapValueSecond();
			}
			mgtTotalOrderTotalVo.setOrderTotalKey(orderTotalKey);
			mgtTotalOrderTotalVo.setOrderTotalValue(orderTotalValue);
			mgtTotalOrderTotalVo.setOrderMoneyValue(orderMoneyValue);
			}

			//获取商品分类销售数据
			List<MgtMapTotalPlusVo> MgtMapIntTotalVoGoodsType = orderMapper.listTotalOrderTotalGoodsType(mgtBaseShopDto);
			List<MgtMapIntTotalVo> goodsTypeTotalList = new ArrayList<>();
			List<MgtMapBigTotalVo> goodsTypeMoneyList = new ArrayList<>();
			if (MgtMapIntTotalVoGoodsType != null && MgtMapIntTotalVoGoodsType.size() > 0) {
			MgtMapIntTotalVo MgtMapIntTotalVo;
			MgtMapIntTotalVo mgtMapIntTotalVo;
			MgtMapBigTotalVo mgtMapBigTotalVo;
			// 遍历不同商品类型的会员数列表，设置商品类型数组和对应的会员数数组
			Boolean noCycle = true;
			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();
			mgtMapIntTotalVo = new MgtMapIntTotalVo();
			mgtMapBigTotalVo = new MgtMapBigTotalVo();
			MgtMapIntTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtMapIntTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtMapBigTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond());
			if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("1")) {
			MgtMapIntTotalVo.setMapKey("周期");
			mgtMapIntTotalVo.setMapKey("周期");
			mgtMapBigTotalVo.setMapKey("周期");
			mgtTotalOrderTotalVo.setCycleTotal(mgtTotalOrderTotalVo.getCycleTotal() + MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtTotalOrderTotalVo.setCycleMoney(mgtTotalOrderTotalVo.getCycleMoney().add(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond()));
			noCycle= false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("2")) {
			MgtMapIntTotalVo.setMapKey("服务");
			mgtMapIntTotalVo.setMapKey("服务");
			mgtMapBigTotalVo.setMapKey("服务");
			mgtTotalOrderTotalVo.setServiceTotal(mgtTotalOrderTotalVo.getServiceTotal() + MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtTotalOrderTotalVo.setServiceMoney(mgtTotalOrderTotalVo.getServiceMoney().add(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond()));
			noService= false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("3")) {
			MgtMapIntTotalVo.setMapKey("体验");
			mgtMapIntTotalVo.setMapKey("体验");
			mgtMapBigTotalVo.setMapKey("体验");
			mgtTotalOrderTotalVo.setExperienceTotal(mgtTotalOrderTotalVo.getExperienceTotal() + MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtTotalOrderTotalVo.setExperienceMoney(mgtTotalOrderTotalVo.getExperienceMoney().add(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond()));
			noExperience = false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("4")) {
			MgtMapIntTotalVo.setMapKey("单品");
			mgtMapIntTotalVo.setMapKey("单品");
			mgtMapBigTotalVo.setMapKey("单品");
			noGoods = false;
			}
			goodsTypeTotalList.add(MgtMapIntTotalVo);
			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);
			@@ -2766,6 +3521,26 @@
			if (orderFromList != null && orderFromList.size() > 0) {
			orderFromList = bigListRemoveNull(orderFromList);
			mgtTotalOrderTotalVo.setOrderFromRankList(orderFromList);
			}
			//订单分布
			//日期全部时固定为5天
			if(StringUtils.isBlank(mgtBaseShopDto.getStartDate())){
			mgtBaseShopDto.setEndDate(DateUtils.getDate());
			mgtBaseShopDto.setStartDate(DateUtils.parseDateToStr("yyyy-MM-dd",DateUtils.addDays(new Date(),-4)));
			}
			List<MgtMapTotalPlusVo> MgtMapIntTotalVos = orderMapper.listTotalOrderTotal(mgtBaseShopDto);
			if (MgtMapIntTotalVos != null && MgtMapIntTotalVos.size() > 0) {
			String[] orderTotalKey = new String[MgtMapIntTotalVos.size()];
			Integer[] orderTotalValue = new Integer[MgtMapIntTotalVos.size()];
			BigDecimal[] orderMoneyValue = new BigDecimal[MgtMapIntTotalVos.size()];
			for (int i = 0; i < MgtMapIntTotalVos.size(); i++) {
			orderTotalKey[i] = MgtMapIntTotalVos.get(i).getMapKey();
			orderTotalValue[i] = MgtMapIntTotalVos.get(i).getMapValueFirst();
			orderMoneyValue[i] = MgtMapIntTotalVos.get(i).getMapValueSecond();
			}
			mgtTotalOrderTotalVo.setOrderTotalKey(orderTotalKey);
			mgtTotalOrderTotalVo.setOrderTotalValue(orderTotalValue);
			mgtTotalOrderTotalVo.setOrderMoneyValue(orderMoneyValue);
			}
			return mgtTotalOrderTotalVo;
			}
			@@ -2811,8 +3586,38 @@
			*/
			@Override
			public MgtTotalActivityTotalVo getTotalActivityTotal(MgtBaseShopDto mgtBaseShopDto) {
			//获取基础统计
			MgtTotalActivityTotalVo totalActivityTotalVo = orderMapper.getTotalActivityTotal(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 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());
			totalActivityTotalVo.setCyclePerson(totalActivityMemberTotalVo.getCyclePerson());
			totalActivityTotalVo.setServicePerson(totalActivityMemberTotalVo.getServicePerson());
			totalActivityTotalVo.setExperiencePerson(totalActivityMemberTotalVo.getExperiencePerson());
			//获取商品分类销售数据
			List<MgtMapTotalPlusVo> MgtMapIntTotalVoGoodsType = orderMapper.listTotalActivityTotalGoodsType(mgtBaseShopDto);
			if (MgtMapIntTotalVoGoodsType != null && MgtMapIntTotalVoGoodsType.size() > 0) {
			@@ -2825,40 +3630,95 @@
			totalActivityTotalVo.setExperienceTotal(0);
			totalActivityTotalVo.setExperienceMoney(BigDecimal.ZERO);
			// 遍历不同商品类型的会员数列表，设置商品类型数组和对应的会员数数组
			MgtMapIntTotalVo MgtMapIntTotalVo;
			MgtMapIntTotalVo mgtMapIntTotalVo;
			MgtMapBigTotalVo mgtMapBigTotalVo;
			// 遍历不同商品类型的会员数列表，设置商品类型数组和对应的会员数数组
			Boolean noCycle = true;
			Boolean noService = true;
			Boolean noExperience = true;
			Boolean noGoods = true;
			for (int i = 0; i < MgtMapIntTotalVoGoodsType.size(); i++) {
			MgtMapIntTotalVo = new MgtMapIntTotalVo();
			mgtMapIntTotalVo = new MgtMapIntTotalVo();
			mgtMapBigTotalVo = new MgtMapBigTotalVo();
			MgtMapIntTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtMapIntTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtMapBigTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond());
			if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("1")) {
			MgtMapIntTotalVo.setMapKey("周期");
			mgtMapIntTotalVo.setMapKey("周期");
			mgtMapBigTotalVo.setMapKey("周期");
			totalActivityTotalVo.setCycleTotal(totalActivityTotalVo.getCycleTotal() + MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			totalActivityTotalVo.setCycleMoney(totalActivityTotalVo.getCycleMoney().add(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond()));
			noCycle= false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("2")) {
			MgtMapIntTotalVo.setMapKey("服务");
			mgtMapIntTotalVo.setMapKey("服务");
			mgtMapBigTotalVo.setMapKey("服务");
			totalActivityTotalVo.setServiceTotal(totalActivityTotalVo.getServiceTotal() + MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			totalActivityTotalVo.setServiceMoney(totalActivityTotalVo.getServiceMoney().add(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond()));
			noService= false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("3")) {
			MgtMapIntTotalVo.setMapKey("体验");
			mgtMapIntTotalVo.setMapKey("体验");
			mgtMapBigTotalVo.setMapKey("体验");
			totalActivityTotalVo.setExperienceTotal(totalActivityTotalVo.getExperienceTotal() + MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			totalActivityTotalVo.setExperienceMoney(totalActivityTotalVo.getExperienceMoney().add(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond()));
			noExperience = false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("4")) {
			MgtMapIntTotalVo.setMapKey("单品");
			mgtMapIntTotalVo.setMapKey("单品");
			mgtMapBigTotalVo.setMapKey("单品");
			noGoods = false;
			}
			goodsTypeTotalList.add(MgtMapIntTotalVo);
			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);
			}
			totalActivityTotalVo.setGoodsTypeTotalList(goodsTypeTotalList);
			totalActivityTotalVo.setGoodsTypeMoneyList(goodsTypeMoneyList);
			}

			//获取订单分布
			//日期全部时固定为5天
			if(StringUtils.isBlank(mgtBaseShopDto.getStartDate())){
			mgtBaseShopDto.setEndDate(DateUtils.getDate());
			mgtBaseShopDto.setStartDate(DateUtils.parseDateToStr("yyyy-MM-dd",DateUtils.addDays(new Date(),-4)));
			}
			List<MgtMapTotalPlusVo> MgtMapIntTotalVos = orderMapper.listTotalActivityTotal(mgtBaseShopDto);
			if (MgtMapIntTotalVos != null && MgtMapIntTotalVos.size() > 0) {
			String[] orderTotalKey = new String[MgtMapIntTotalVos.size()];
			@@ -2873,6 +3733,71 @@
			totalActivityTotalVo.setOrderTotalValue(orderTotalValue);
			totalActivityTotalVo.setOrderMoneyValue(orderMoneyValue);
			}
			//参与人数 2023-09-06 另开接口
			/*List<MgtMapIntTotalVo> joinList = orderMapper.getActivityMemberTotal(mgtBaseShopDto);
			// 将查询结果转为Map
			Map<String, Integer> mgtMapIntTotalVoMap = new HashMap<>();
			if (joinList != null && !joinList.isEmpty()) {
			mgtMapIntTotalVoMap = joinList.stream()
			.collect(Collectors.toMap(MgtMapIntTotalVo::getMapKey, MgtMapIntTotalVo::getMapValue));
			}
			// 获取日期范围
			List<String> dateList = getDateRange(mgtBaseShopDto.getStartDate(), mgtBaseShopDto.getEndDate());
			int size = dateList.size();
			// 创建日期和成员总数的数组
			String[] joinMemberTotalKey = new String[size];
			Integer[] joinMemberTotalValue = new Integer[size];
			// 遍历日期列表，设置日期和成员总数的数组
			String str;
			Integer value;
			for (int i = 0; i < size; i++) {
			str = dateList.get(i);
			joinMemberTotalKey[i] = str;
			value = mgtMapIntTotalVoMap.get(str);
			joinMemberTotalValue[i] = (value != null) ? value : 0;
			}
			totalActivityTotalVo.setJoinMemberTotalKey(joinMemberTotalKey);
			totalActivityTotalVo.setJoinMemberTotalValue(joinMemberTotalValue);*/
			return totalActivityTotalVo;
			}

			@Override
			public MgtTotalActivityTotalVo getTotalActivityJoinMemberTotal(MgtBaseShopDto mgtBaseShopDto) {
			MgtTotalActivityTotalVo totalActivityTotalVo = new MgtTotalActivityTotalVo();
			//日期全部时固定为5天
			if(StringUtils.isBlank(mgtBaseShopDto.getStartDate())){
			mgtBaseShopDto.setEndDate(DateUtils.getDate());
			mgtBaseShopDto.setStartDate(DateUtils.parseDateToStr("yyyy-MM-dd",DateUtils.addDays(new Date(),-4)));
			}
			if(mgtBaseShopDto.getAgeType()!=null){
			List<Long> userIdList = remoteMemberService.listUserIdByAgeType(mgtBaseShopDto.getAgeType()).getData();
			mgtBaseShopDto.setUserIdList(userIdList);
			}
			//参与人数
			List<MgtMapIntTotalVo> joinList = orderMapper.getActivityMemberTotal(mgtBaseShopDto);
			// 将查询结果转为Map
			Map<String, Integer> mgtMapIntTotalVoMap = new HashMap<>();
			if (joinList != null && !joinList.isEmpty()) {
			mgtMapIntTotalVoMap = joinList.stream()
			.collect(Collectors.toMap(MgtMapIntTotalVo::getMapKey, MgtMapIntTotalVo::getMapValue));
			}
			// 获取日期范围
			List<String> dateList = getDateRange(mgtBaseShopDto.getStartDate(), mgtBaseShopDto.getEndDate());
			int size = dateList.size();
			// 创建日期和成员总数的数组
			String[] joinMemberTotalKey = new String[size];
			Integer[] joinMemberTotalValue = new Integer[size];
			// 遍历日期列表，设置日期和成员总数的数组
			String str;
			Integer value;
			for (int i = 0; i < size; i++) {
			str = dateList.get(i);
			joinMemberTotalKey[i] = str;
			value = mgtMapIntTotalVoMap.get(str);
			joinMemberTotalValue[i] = (value != null) ? value : 0;
			}
			totalActivityTotalVo.setJoinMemberTotalKey(joinMemberTotalKey);
			totalActivityTotalVo.setJoinMemberTotalValue(joinMemberTotalValue);
			return totalActivityTotalVo;
			}

			@@ -2883,7 +3808,7 @@
			* @author jqs
			* @date 2023/6/20 9:56
			*/
			@Override
			/*@Override
			public MgtTotalActivityTotalVo getTotalActivityAgeRank(MgtActivityAgeDto mgtActivityAgeDto) {
			List<Long> userIds = orderMapper.getUserIdAgeRank(mgtActivityAgeDto);
			mgtActivityAgeDto.setUserIds(userIds);
			@@ -2905,7 +3830,7 @@
			totalActivityTotalVo.setActivityAgeKey(activityAgeKey);
			totalActivityTotalVo.setActivityAgeValue(activityAgeValue);
			return totalActivityTotalVo;
			}
			}*/

			/**
			* @param mgtBaseShopDto
			@@ -2916,13 +3841,31 @@
			*/
			@Override
			public MgtTotalDataTotalVo getTotalDataTotal(MgtBaseShopDto mgtBaseShopDto) {
			//获取人数统计
			MgtTotalDataTotalVo mgtTotalDataTotalVo = orderMapper.getTotalDataTotal(mgtBaseShopDto);

			//营业额
			BigDecimal salesTotal = orderMapper.shopSalesTotal(mgtBaseShopDto);
			mgtTotalDataTotalVo.setSalesTotal(salesTotal);
			MgtTotalDataTotalVo mgtTotalDataTotalVo = orderMapper.getTotalDataTotal(mgtBaseShopDto);
			// 获取当月时间
			LocalDate currentDate = LocalDate.now();
			LocalDate firstDayOfMonth = currentDate.withDayOfMonth(1);
			LocalDate lastDayOfMonth = currentDate.withDayOfMonth(currentDate.lengthOfMonth());
			DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
			String firstDayOfMonthStr = firstDayOfMonth.format(formatter);
			String lastDayOfMonthStr = lastDayOfMonth.format(formatter);
			mgtBaseShopDto.setStartDate(firstDayOfMonthStr);
			mgtBaseShopDto.setEndDate(lastDayOfMonthStr);
			//总进店人数体验人数体验开单人数没体验开单人数
			MgtTotalDataTotalVo mgtTotalDataMemberTotalVo = orderMapper.getTotalDataMemberTotal(mgtBaseShopDto);
			mgtTotalDataTotalVo.setOnlyExperiencePerson(mgtTotalDataMemberTotalVo.getOnlyExperiencePerson());
			mgtTotalDataTotalVo.setExperienceCyclePerson(mgtTotalDataMemberTotalVo.getExperienceCyclePerson());
			mgtTotalDataTotalVo.setOnlyCyclePerson(mgtTotalDataMemberTotalVo.getOnlyCyclePerson());
			mgtTotalDataTotalVo.setOrderPerson(mgtTotalDataMemberTotalVo.getOrderPerson());
			//续单人数
			Integer reorderPerson = orderMapper.getReorderPerson(mgtBaseShopDto);
			mgtTotalDataTotalVo.setReorderPerson(reorderPerson);
			//回头客
			Integer returnedPerson = orderMapper.getReturnedPerson(mgtBaseShopDto);
			mgtTotalDataTotalVo.setSalesTotal(salesTotal);
			mgtTotalDataTotalVo.setReorderPerson(reorderPerson);
			mgtTotalDataTotalVo.setReturnedPerson(returnedPerson);
			return mgtTotalDataTotalVo;
			}
			@@ -2955,7 +3898,7 @@
			userIdList.add(mgtBasePlatformDto.getUserId());
			} else {
			MgtUserIdByDept mgtUserIdByDept = new MgtUserIdByDept();
			mgtUserIdByDept.setDeptId(mgtBasePlatformDto.getUserId());
			mgtUserIdByDept.setDeptId(mgtBasePlatformDto.getDeptId());
			mgtUserIdByDept = remoteConfigService.getUserIdByDept(mgtUserIdByDept).getData();
			userIdList = mgtUserIdByDept.getUserIdList();
			}
			@@ -2963,10 +3906,43 @@
			mgtBasePlatformDto.setUserIdList(userIdList);
			}
			}
			List<Long> shopIdList = remoteShopService.listShopIdByPlTotal(mgtBasePlatformDto).getData();
			//数据权限
			List<Long> userIds = remoteUserService.getScopeOfAuthorityUserId();
			if(null != userIds){
			List<Long> userIdList = mgtBasePlatformDto.getUserIdList();
			if(null != userIdList){
			userIdList.addAll(userIds);
			}else{
			userIdList = userIds;
			}
			mgtBasePlatformDto.setUserIdList(userIdList);
			}


			List<Long> shopIdList = new ArrayList<>();
			if(mgtBasePlatformDto.getShopId()!=null){
			shopIdList.add(mgtBasePlatformDto.getShopId());
			}else{
			shopIdList = remoteShopService.listShopIdByPlTotal(mgtBasePlatformDto).getData();
			}
			List<MgtTotalDataTotalVo> mgtTotalDataTotalVoList = new ArrayList<>();
			MgtBaseShopDto mgtBaseShopDto;
			MgtTotalDataTotalVo mgtTotalDataTotalVo;
			MgtSimpleShopVo simpleShopVo;
			HashSet<String> set = new HashSet<>();
			// 遍历MgtMemberOrderPageVoList，获取shopId并添加到set中
			if(null != shopIdList){
			for (Long entity : shopIdList) {
			set.add(entity.toString());
			}
			}
			String joinedString = String.join(",", set);
			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()));
			if (shopIdList != null && !shopIdList.isEmpty()) {
			for (Long shopId : shopIdList) {
			mgtBaseShopDto = new MgtBaseShopDto();
			@@ -2974,8 +3950,10 @@
			mgtBaseShopDto.setEndDate(mgtBasePlatformDto.getEndDate());
			mgtBaseShopDto.setShopId(shopId);
			mgtTotalDataTotalVo = this.getTotalDataTotal(mgtBaseShopDto);
			Shop shop = remoteShopService.getShop(shopId).getData();
			mgtTotalDataTotalVo.setShopName(shop.getShopName());
			simpleShopVo = shopMap.get(shopId);
			if (simpleShopVo!=null) {
			mgtTotalDataTotalVo.setShopName(simpleShopVo.getShopName());
			}
			mgtTotalDataTotalVoList.add(mgtTotalDataTotalVo);
			}
			}
			@@ -2997,33 +3975,72 @@
			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();
			List<SysUser> data = remoteUserService.getUsersByDeptId(mgtBasePlatformDto.getDeptId()).getData();
			userIdList.addAll(data.stream().map(SysUser::getUserId).collect(Collectors.toList()));
			}
			if (!userIdList.isEmpty()) {
			mgtBasePlatformDto.setUserIdList(userIdList);
			}
			}
			//数据权限
			List<Long> userIdList = mgtBasePlatformDto.getUserIdList();
			List<Long> userIds = remoteUserService.getScopeOfAuthorityUserId();
			if(null != userIds){
			if(null != userIdList){
			userIdList.addAll(userIds);
			}else{
			userIdList = userIds;
			}
			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.setItemTotal(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.setItemMoney(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);
			List<MgtMapTotalPlusVo> MgtMapIntTotalVos = orderMapper.listPlTotalOrderTotal(mgtBasePlatformDto);
			if (MgtMapIntTotalVos != null && MgtMapIntTotalVos.size() > 0) {
			String[] orderTotalKey = new String[MgtMapIntTotalVos.size()];
			Integer[] orderTotalValue = new Integer[MgtMapIntTotalVos.size()];
			BigDecimal[] orderMoneyValue = new BigDecimal[MgtMapIntTotalVos.size()];
			for (int i = 0; i < MgtMapIntTotalVos.size(); i++) {
			orderTotalKey[i] = MgtMapIntTotalVos.get(i).getMapKey();
			orderTotalValue[i] = MgtMapIntTotalVos.get(i).getMapValueFirst();
			orderMoneyValue[i] = MgtMapIntTotalVos.get(i).getMapValueSecond();
			}
			mgtTotalOrderTotalVo.setOrderTotalKey(orderTotalKey);
			mgtTotalOrderTotalVo.setOrderTotalValue(orderTotalValue);
			mgtTotalOrderTotalVo.setOrderMoneyValue(orderMoneyValue);
			}
			MgtTotalOrderTotalVo totalOrderTotalVo = orderMapper.getPlTotalOrderTotalOrderFrom(mgtBasePlatformDto);
			mgtTotalOrderTotalVo.setOrderTotal(totalOrderTotalVo.getOrderTotal());
			mgtTotalOrderTotalVo.setOnlineTotal(totalOrderTotalVo.getOnlineTotal());
			mgtTotalOrderTotalVo.setOfflineTotal(totalOrderTotalVo.getOfflineTotal());
			mgtTotalOrderTotalVo.setActivityTotal(totalOrderTotalVo.getActivityTotal());
			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<>();
			@@ -3032,37 +4049,90 @@
			mgtTotalOrderTotalVo.setCycleMoney(BigDecimal.ZERO);
			mgtTotalOrderTotalVo.setServiceTotal(0);
			mgtTotalOrderTotalVo.setServiceMoney(BigDecimal.ZERO);
			mgtTotalOrderTotalVo.setItemTotal(0);
			mgtTotalOrderTotalVo.setItemMoney(BigDecimal.ZERO);
			mgtTotalOrderTotalVo.setExperienceTotal(0);
			mgtTotalOrderTotalVo.setExperienceMoney(BigDecimal.ZERO);
			if (MgtMapIntTotalVoGoodsType != null && MgtMapIntTotalVoGoodsType.size() > 0) {
			MgtMapIntTotalVo MgtMapIntTotalVo;
			MgtMapIntTotalVo mgtMapIntTotalVo;
			MgtMapBigTotalVo mgtMapBigTotalVo;
			// 遍历不同商品类型的会员数列表，设置商品类型数组和对应的会员数数组
			Boolean noCycle = true;
			Boolean noService = true;
			Boolean noExperience = true;
			Boolean noGoods = true;
			for (int i = 0; i < MgtMapIntTotalVoGoodsType.size(); i++) {
			MgtMapIntTotalVo = new MgtMapIntTotalVo();
			mgtMapIntTotalVo = new MgtMapIntTotalVo();
			mgtMapBigTotalVo = new MgtMapBigTotalVo();
			MgtMapIntTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtMapIntTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtMapBigTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond());
			if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("1")) {
			MgtMapIntTotalVo.setMapKey("周期");
			mgtMapIntTotalVo.setMapKey("周期");
			mgtMapBigTotalVo.setMapKey("周期");
			mgtTotalOrderTotalVo.setCycleTotal(mgtTotalOrderTotalVo.getCycleTotal() + MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtTotalOrderTotalVo.setCycleMoney(mgtTotalOrderTotalVo.getCycleMoney().add(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond()));
			noCycle= false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("2")) {
			MgtMapIntTotalVo.setMapKey("服务");
			mgtMapIntTotalVo.setMapKey("服务");
			mgtMapBigTotalVo.setMapKey("服务");
			mgtTotalOrderTotalVo.setServiceTotal(mgtTotalOrderTotalVo.getServiceTotal() + MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtTotalOrderTotalVo.setServiceMoney(mgtTotalOrderTotalVo.getServiceMoney().add(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond()));
			noService= false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("3")) {
			MgtMapIntTotalVo.setMapKey("体验");
			mgtMapIntTotalVo.setMapKey("体验");
			mgtMapBigTotalVo.setMapKey("体验");
			mgtTotalOrderTotalVo.setExperienceTotal(mgtTotalOrderTotalVo.getExperienceTotal() + MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtTotalOrderTotalVo.setExperienceMoney(mgtTotalOrderTotalVo.getExperienceMoney().add(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond()));
			noExperience = false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("4")) {
			MgtMapIntTotalVo.setMapKey("单品");
			mgtMapIntTotalVo.setMapKey("单品");
			mgtMapBigTotalVo.setMapKey("单品");
			mgtTotalOrderTotalVo.setItemTotal(mgtTotalOrderTotalVo.getItemTotal() + MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtTotalOrderTotalVo.setItemMoney(mgtTotalOrderTotalVo.getItemMoney().add(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond()));
			noGoods = false;
			}
			goodsTypeTotalList.add(MgtMapIntTotalVo);
			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);
			@@ -3080,6 +4150,36 @@
			orderFromList = bigListRemoveNull(orderFromList);
			mgtTotalOrderTotalVo.setOrderFromRankList(orderFromList);
			}
			//订单分布
			//日期全部时固定为5天
			Boolean fillZero = false;
			if(StringUtils.isBlank(mgtBasePlatformDto.getStartDate())){
			mgtBasePlatformDto.setEndDate(DateUtils.getDate());
			mgtBasePlatformDto.setStartDate(DateUtils.parseDateToStr("yyyy-MM-dd",DateUtils.addDays(new Date(),-4)));
			fillZero = true;
			}
			List<MgtMapTotalPlusVo> MgtMapIntTotalVos = orderMapper.listPlTotalOrderTotal(mgtBasePlatformDto);
			if (MgtMapIntTotalVos != null && MgtMapIntTotalVos.size() > 0) {
			String[] orderTotalKey = new String[MgtMapIntTotalVos.size()];
			Integer[] orderTotalValue = new Integer[MgtMapIntTotalVos.size()];
			BigDecimal[] orderMoneyValue = new BigDecimal[MgtMapIntTotalVos.size()];
			for (int i = 0; i < MgtMapIntTotalVos.size(); i++) {
			orderTotalKey[i] = MgtMapIntTotalVos.get(i).getMapKey();
			orderTotalValue[i] = MgtMapIntTotalVos.get(i).getMapValueFirst();
			orderMoneyValue[i] = MgtMapIntTotalVos.get(i).getMapValueSecond();
			}
			if(fillZero){
			MerOrderDistributionTotalVo merOrderDistributionTotalVo = fillOrderTotalKeyAndValuesToRecentFiveDays(orderTotalKey,orderTotalValue,orderMoneyValue);
			mgtTotalOrderTotalVo.setOrderTotalKey(merOrderDistributionTotalVo.getOrderTotalKey());
			mgtTotalOrderTotalVo.setOrderTotalValue(merOrderDistributionTotalVo.getOrderTotalValue());
			mgtTotalOrderTotalVo.setOrderMoneyValue(merOrderDistributionTotalVo.getOrderMoneyValue());
			}else{
			mgtTotalOrderTotalVo.setOrderTotalKey(orderTotalKey);
			mgtTotalOrderTotalVo.setOrderTotalValue(orderTotalValue);
			mgtTotalOrderTotalVo.setOrderMoneyValue(orderMoneyValue);
			}

			}
			return mgtTotalOrderTotalVo;
			}

			@@ -3092,25 +4192,72 @@
			*/
			@Override
			public MgtPlTotalActivityTotalVo getPlTotalActivityTotal(MgtBasePlatformDto mgtBasePlatformDto) {
			//获取需要关联的用户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();
			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;
			}

			//数据权限
			List<Long> userIds = remoteUserService.getScopeOfAuthorityUserId();
			if(null != userIds){
			List<Long> userIdList = mgtBasePlatformDto.getUserIdList();
			if(null == userIdList){
			userIdList = new ArrayList<>();
			}
			if (!userIdList.isEmpty()) {
			mgtBasePlatformDto.setUserIdList(userIdList);
			userIdList.addAll(userIds);
			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;
			}
			}
			List<Long> shopIdList = remoteShopService.listShopIdByPlTotal(mgtBasePlatformDto).getData();
			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());
			totalActivityTotalVo.setCyclePerson(totalActivityMemberTotalVo.getCyclePerson());
			totalActivityTotalVo.setServicePerson(totalActivityMemberTotalVo.getServicePerson());
			totalActivityTotalVo.setExperiencePerson(totalActivityMemberTotalVo.getExperiencePerson());
			//获取商品分类销售数据
			List<MgtMapTotalPlusVo> MgtMapIntTotalVoGoodsType = orderMapper.listPlTotalActivityTotalGoodsType(mgtBasePlatformDto);
			List<MgtMapIntTotalVo> goodsTypeTotalList = new ArrayList<>();
			@@ -3122,36 +4269,146 @@
			totalActivityTotalVo.setExperienceTotal(0);
			totalActivityTotalVo.setExperienceMoney(BigDecimal.ZERO);
			if (MgtMapIntTotalVoGoodsType != null && MgtMapIntTotalVoGoodsType.size() > 0) {
			MgtMapIntTotalVo MgtMapIntTotalVo;
			MgtMapIntTotalVo mgtMapIntTotalVo;
			MgtMapBigTotalVo mgtMapBigTotalVo;
			// 遍历不同商品类型的会员数列表，设置商品类型数组和对应的会员数数组
			Boolean noCycle = true;
			Boolean noService = true;
			Boolean noExperience = true;
			Boolean noGoods = true;
			for (int i = 0; i < MgtMapIntTotalVoGoodsType.size(); i++) {
			MgtMapIntTotalVo = new MgtMapIntTotalVo();
			mgtMapIntTotalVo = new MgtMapIntTotalVo();
			mgtMapBigTotalVo = new MgtMapBigTotalVo();
			MgtMapIntTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtMapIntTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtMapBigTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond());
			if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("1")) {
			MgtMapIntTotalVo.setMapKey("周期");
			mgtMapIntTotalVo.setMapKey("周期");
			mgtMapBigTotalVo.setMapKey("周期");
			totalActivityTotalVo.setCycleTotal(totalActivityTotalVo.getCycleTotal() + MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			totalActivityTotalVo.setCycleMoney(totalActivityTotalVo.getCycleMoney().add(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond()));
			noCycle= false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("2")) {
			MgtMapIntTotalVo.setMapKey("服务");
			mgtMapIntTotalVo.setMapKey("服务");
			mgtMapBigTotalVo.setMapKey("服务");
			totalActivityTotalVo.setServiceTotal(totalActivityTotalVo.getServiceTotal() + MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			totalActivityTotalVo.setServiceMoney(totalActivityTotalVo.getServiceMoney().add(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond()));
			noService= false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("3")) {
			MgtMapIntTotalVo.setMapKey("体验");
			mgtMapIntTotalVo.setMapKey("体验");
			mgtMapBigTotalVo.setMapKey("体验");
			totalActivityTotalVo.setExperienceTotal(totalActivityTotalVo.getExperienceTotal() + MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			totalActivityTotalVo.setExperienceMoney(totalActivityTotalVo.getExperienceMoney().add(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond()));
			noExperience = false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("4")) {
			MgtMapIntTotalVo.setMapKey("单品");
			mgtMapIntTotalVo.setMapKey("单品");
			mgtMapBigTotalVo.setMapKey("单品");
			noGoods = false;
			}
			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);
			}
			totalActivityTotalVo.setGoodsTypeTotalList(goodsTypeTotalList);
			totalActivityTotalVo.setGoodsTypeMoneyList(goodsTypeMoneyList);
			}
			HashSet<String> set = new HashSet<>();
			// 遍历MgtMemberOrderPageVoList，获取shopId并添加到set中
			if(null != mgtBasePlatformDto.getShopIdList()){
			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());
			mgtBasePlatformDto.setStartDate(DateUtils.parseDateToStr("yyyy-MM-dd",DateUtils.addDays(new Date(),-4)));
			}
			//获取订单分布
			List<MgtMapTotalPlusVo> MgtMapIntTotalVos = orderMapper.listPlTotalActivityTotal(mgtBasePlatformDto);
			@@ -3168,40 +4425,159 @@
			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> map = simpleShopVoList.stream()
			.collect(Collectors.toMap(MgtSimpleShopVo::getShopId, Function.identity()));
			//商户活动次数排名
			List<MgtMapBigTotalVo> shopActivityRank = orderMapper.listPlTotalShopActivityRank(mgtBasePlatformDto);
			if (shopActivityRank != null && shopActivityRank.size() > 0) {
			shopActivityRank = bigListRemoveNull(shopActivityRank);
			totalActivityTotalVo.setShopSalesRankList(shopActivityRank);
			}
			//商户活动销售额排名
			List<MgtMapBigTotalVo> shopActivitySalesRank = orderMapper.listPlTotalShopActivitySalesRank(mgtBasePlatformDto);
			if (shopActivitySalesRank != null && shopActivitySalesRank.size() > 0) {
			shopActivitySalesRank = bigListRemoveNull(shopActivitySalesRank);
			totalActivityTotalVo.setShopSalesRankList(shopActivitySalesRank);
			}
			//活动销售额排名
			List<MgtMapBigTotalVo> activitySalesRank = orderMapper.listPlTotalActivitySalesRank(mgtBasePlatformDto);
			if (activitySalesRank != null && activitySalesRank.size() > 0) {
			activitySalesRank = bigListRemoveNull(activitySalesRank);
			totalActivityTotalVo.setActivitySalesRankList(activitySalesRank);
			}
			return totalActivityTotalVo;
			}


			@Override
			public MgtPlTotalActivityTotalVo getPlTotalActivityJoinMemberTotal(MgtBasePlatformDto mgtBasePlatformDto) {
			//店铺活动返回空
			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;
			}

			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());
			}

			List<Long> userIds = remoteUserService.getScopeOfAuthorityUserId();
			BoardMemberTotalDto boardMemberTotalDto = new BoardMemberTotalDto();
			boardMemberTotalDto.setUserIds(userIds);
			List<Shop> shopList = remoteShopService.getShopBySysUserIds(boardMemberTotalDto);
			List<Long> collect = shopList.stream().map(Shop::getShopId).collect(Collectors.toList());
			if(null != shopIdList){
			shopIdList.addAll(collect);
			}else{
			shopIdList = collect;
			}
			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);
			}
			//日期全部时固定为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
			Map<String, Integer> mgtMapIntTotalVoMap = new HashMap<>();
			if (joinList != null && !joinList.isEmpty()) {
			mgtMapIntTotalVoMap = joinList.stream()
			.collect(Collectors.toMap(MgtMapIntTotalVo::getMapKey, MgtMapIntTotalVo::getMapValue));
			}
			// 获取日期范围
			List<String> dateList = getDateRange(mgtBasePlatformDto.getStartDate(), mgtBasePlatformDto.getEndDate());
			int size = dateList.size();
			// 创建日期和成员总数的数组
			String[] joinMemberTotalKey = new String[size];
			Integer[] joinMemberTotalValue = new Integer[size];
			// 遍历日期列表，设置日期和成员总数的数组
			String str;
			Integer value;
			for (int i = 0; i < size; i++) {
			str = dateList.get(i);
			joinMemberTotalKey[i] = str;
			value = mgtMapIntTotalVoMap.get(str);
			joinMemberTotalValue[i] = (value != null) ? value : 0;
			}
			totalActivityTotalVo.setJoinMemberTotalKey(joinMemberTotalKey);
			totalActivityTotalVo.setJoinMemberTotalValue(joinMemberTotalValue);
			return totalActivityTotalVo;
			}

			@Override
			public MgtPlTotalActivityTotalVo getPlTotalActivityGetMemberTotal(MgtBasePlatformDto mgtBasePlatformDto) {
			//店铺活动返回空
			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;
			}
			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());
			}
			//数据权限
			List<Long> userIds = remoteUserService.getScopeOfAuthorityUserId();
			BoardMemberTotalDto boardMemberTotalDto = new BoardMemberTotalDto();
			boardMemberTotalDto.setUserIds(userIds);
			List<Shop> shopList = remoteShopService.getShopBySysUserIds(boardMemberTotalDto);
			List<Long> collect = shopList.stream().map(Shop::getShopId).collect(Collectors.toList());
			if(null != shopIdList){
			shopIdList.addAll(collect);
			}else{
			shopIdList = collect;
			}
			mgtBasePlatformDto.setShopIdList(shopIdList);
			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());
			mgtBasePlatformDto.setStartDate(DateUtils.parseDateToStr("yyyy-MM-dd",DateUtils.addDays(new Date(),-4)));
			}
			//获客人数
			List<MgtMapIntTotalVo> getList = orderMapper.getMgtActivityGetMemberTotal(mgtBasePlatformDto);
			// 将查询结果转为Map
			Map<String, Integer> getMemberMap = new HashMap<>();
			if (getList != null && !getList.isEmpty()) {
			getMemberMap = getList.stream()
			.collect(Collectors.toMap(MgtMapIntTotalVo::getMapKey, MgtMapIntTotalVo::getMapValue));
			}
			// 获取日期范围
			List<String> dateList = getDateRange(mgtBasePlatformDto.getStartDate(), mgtBasePlatformDto.getEndDate());
			int size = dateList.size();
			// 创建日期和成员总数的数组
			String[] getMemberTotalKey = new String[size];
			Integer[] getMemberTotalValue = new Integer[size];
			// 遍历日期列表，设置日期和成员总数的数组
			String str;
			Integer value;
			// 遍历日期列表，设置日期和成员总数的数组
			for (int i = 0; i < size; i++) {
			str = dateList.get(i);
			getMemberTotalKey[i] = str;
			value = getMemberMap.get(str);
			getMemberTotalValue[i] = (value != null) ? value : 0;
			}
			totalActivityTotalVo.setGetMemberTotalKey(getMemberTotalKey);
			totalActivityTotalVo.setGetMemberTotalValue(getMemberTotalValue);
			return totalActivityTotalVo;
			}


			/**
			* @param mgtPlActivityAgeDto
			@@ -3210,7 +4586,7 @@
			* @author jqs
			* @date 2023/6/20 9:56
			*/
			@Override
			/*@Override
			public MgtPlTotalActivityTotalVo getPlTotalActivityAgeRank(MgtPlActivityAgeDto mgtPlActivityAgeDto) {
			List<Long> userIds = orderMapper.getPlUserIdAgeRank(mgtPlActivityAgeDto);
			MgtActivityAgeDto mgtActivityAgeDto = new MgtActivityAgeDto();
			@@ -3234,7 +4610,7 @@
			plTotalActivityTotalVo.setActivityAgeKey(activityAgeKey);
			plTotalActivityTotalVo.setActivityAgeValue(activityAgeValue);
			return plTotalActivityTotalVo;
			}
			}*/

			/**
			* @param verifyCode
			@@ -3251,7 +4627,11 @@
			// 创建MerVerifyCouponVo对象
			MerVerifyCouponVo merVerifyCouponVo = new MerVerifyCouponVo();
			// 调用remoteCouponService的getVerifyCoupon方法获取MerVerifyCouponGetVo对象
			MerVerifyCouponGetVo verifyCouponGetVo = remoteCouponService.getVerifyCoupon(verifyCode).getData();
			R<MerVerifyCouponGetVo> verifyCoupon = remoteCouponService.getVerifyCoupon(Long.valueOf(verifyCode));
			if(verifyCoupon.getCode() != 200){
			throw new ServiceException(verifyCoupon.getMsg());
			}
			MerVerifyCouponGetVo verifyCouponGetVo = verifyCoupon.getData();
			MemberCoupon memberCoupon = verifyCouponGetVo.getMemberCoupon();
			// 检查优惠券状态
			int couponStatus = memberCoupon.getCouponStatus();
			@@ -3265,7 +4645,7 @@
			Long userId = verifyCouponGetVo.getUserId();
			Member member = remoteMemberService.getMember(userId).getData();
			//如果是商户优惠券，验证商户一致
			if (memberCoupon.getCouponFrom() == 2 && !memberCoupon.getShopId().equals(shopId)) {
			if (memberCoupon.getCouponFrom() == 2) {
			if(!memberCoupon.getShopId().equals(member.getRelationShopId())){
			throw new ServiceException(AppErrorConstant.BLINDING_VERIFY_SHOP_ERROR);
			}
			@@ -3278,6 +4658,7 @@
			/*if(!memberCoupon.getShopId().equals(member.getRelationShopId())){
			throw new ServiceException(AppErrorConstant.BLINDING_VERIFY_SHOP_ERROR);
			}*/
			//判断绑定商户是否和核销商户一致
			if(!member.getRelationShopId().equals(shopId)){
			throw new ServiceException(AppErrorConstant.VERIFY_SHOP_ERROR);
			}
			@@ -3457,10 +4838,14 @@
			*/
			@Override
			public MerOrderDistributionTotalVo MerOrderDistributionTotalVo(MerTotalDto merTotalDto) {
			//获取查询的商户列表
			if (merTotalDto.getShopAllFlag() != null && merTotalDto.getShopAllFlag() == 1) {
			List<Long> shopIdList = remoteShopService.listShopIdByShopId(merTotalDto.getShopId()).getData();
			merTotalDto.setShopIdList(shopIdList);
			merTotalDto.setShopId(null);
			}
			if(merTotalDto.getGoodsType()!=null&&merTotalDto.getGoodsType()==0){
			merTotalDto.setGoodsType(null);
			}
			MerOrderDistributionTotalVo orderDistributionTotalVo = new MerOrderDistributionTotalVo();
			// 获取订单年龄用户列表
			@@ -3509,10 +4894,11 @@
			}
			}*/
			List<MgtMapTotalPlusVo> mgtMapTotalPlusVoList = orderMapper.listMerOrderDistributionTotal(merTotalDto);
			String[] orderTotalKey = new String[mgtMapTotalPlusVoList.size()];
			Integer[] orderTotalValue = new Integer[mgtMapTotalPlusVoList.size()];
			BigDecimal[] orderMoneyValue = new BigDecimal[mgtMapTotalPlusVoList.size()];
			//数据为空返回空数组
			if (mgtMapTotalPlusVoList != null && !mgtMapTotalPlusVoList.isEmpty()) {
			String[] orderTotalKey = new String[mgtMapTotalPlusVoList.size()];
			Integer[] orderTotalValue = new Integer[mgtMapTotalPlusVoList.size()];
			BigDecimal[] orderMoneyValue = new BigDecimal[mgtMapTotalPlusVoList.size()];
			MgtMapTotalPlusVo mgtMapTotalPlusVo;
			for (int i = 0; i < mgtMapTotalPlusVoList.size(); i++) {
			mgtMapTotalPlusVo = mgtMapTotalPlusVoList.get(i);
			@@ -3520,6 +4906,9 @@
			orderTotalValue[i] = mgtMapTotalPlusVo.getMapValueFirst();
			orderMoneyValue[i] = mgtMapTotalPlusVo.getMapValueSecond();
			}
			//补充日期到近5日
			orderDistributionTotalVo = fillOrderTotalKeyAndValuesToRecentFiveDays(orderTotalKey,orderTotalValue,orderMoneyValue);
			}else{
			orderDistributionTotalVo.setOrderTotalKey(orderTotalKey);
			orderDistributionTotalVo.setOrderTotalValue(orderTotalValue);
			orderDistributionTotalVo.setOrderMoneyValue(orderMoneyValue);
			@@ -3548,28 +4937,93 @@
			List<MgtMapIntTotalVo> goodsTypeTotalList = new ArrayList<>();
			List<MgtMapBigTotalVo> goodsTypeMoneyList = new ArrayList<>();
			if (MgtMapIntTotalVoGoodsType != null && MgtMapIntTotalVoGoodsType.size() > 0) {
			MgtMapIntTotalVo MgtMapIntTotalVo;
			MgtMapIntTotalVo mgtMapIntTotalVo;
			MgtMapBigTotalVo mgtMapBigTotalVo;
			Integer intTotal = 0;
			BigDecimal bigTotal = BigDecimal.ZERO;
			for(MgtMapTotalPlusVo mgtMapTotalPlusVo : MgtMapIntTotalVoGoodsType){
			intTotal = intTotal + mgtMapTotalPlusVo.getMapValueFirst();
			bigTotal = bigTotal.add(mgtMapTotalPlusVo.getMapValueSecond());
			}
			BigDecimal hundredBig = new BigDecimal("100");
			BigDecimal intTotalBig = hundredBig;
			if(intTotal!=0){
			intTotalBig = new BigDecimal(intTotal.toString());
			}
			if(bigTotal.compareTo(BigDecimal.ZERO)<1){
			bigTotal = hundredBig;
			}
			// 遍历不同商品类型的会员数列表，设置商品类型数组和对应的会员数数组
			Boolean noCycle = true;
			Boolean noService = true;
			Boolean noExperience = true;
			Boolean noGoods = true;
			for (int i = 0; i < MgtMapIntTotalVoGoodsType.size(); i++) {
			MgtMapIntTotalVo = new MgtMapIntTotalVo();
			mgtMapIntTotalVo = new MgtMapIntTotalVo();
			mgtMapBigTotalVo = new MgtMapBigTotalVo();
			MgtMapIntTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtMapIntTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtMapIntTotalVo.setMapPercent(BigDecimal.valueOf(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst()).divide(intTotalBig,2,BigDecimal.ROUND_HALF_UP).multiply(hundredBig));
			mgtMapBigTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond());
			mgtMapBigTotalVo.setMapPercent(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond().divide(bigTotal,2,BigDecimal.ROUND_HALF_UP).multiply(hundredBig));
			if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("1")) {
			MgtMapIntTotalVo.setMapKey("周期");
			mgtMapIntTotalVo.setMapKey("周期");
			mgtMapBigTotalVo.setMapKey("周期");
			noCycle= false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("2")) {
			MgtMapIntTotalVo.setMapKey("服务");
			mgtMapIntTotalVo.setMapKey("服务");
			mgtMapBigTotalVo.setMapKey("服务");
			noService= false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("3")) {
			MgtMapIntTotalVo.setMapKey("体验");
			mgtMapIntTotalVo.setMapKey("体验");
			mgtMapBigTotalVo.setMapKey("体验");
			noExperience = false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("4")) {
			MgtMapIntTotalVo.setMapKey("单品");
			mgtMapIntTotalVo.setMapKey("单品");
			mgtMapBigTotalVo.setMapKey("单品");
			noGoods = false;
			}
			goodsTypeTotalList.add(MgtMapIntTotalVo);
			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);
			}
			orderTypeTotalVo.setGoodsTypeTotalList(goodsTypeTotalList);
			@@ -3597,6 +5051,7 @@
			List<MgtMapBigTotalVo> goodsRankList = orderMapper.listMerOrderTotalGoodsRank(merTotalDto);
			if (goodsRankList != null && goodsRankList.size() > 0) {
			goodsRankList = bigListRemoveNull(goodsRankList);
			Collections.reverse(goodsRankList);
			orderGoodsRankVo.setGoodsRankList(goodsRankList);
			}
			return orderGoodsRankVo;
			@@ -3622,6 +5077,7 @@
			List<MgtMapBigTotalVo> orderFromList = orderMapper.listMerOrderTotalOrderFrom(merTotalDto);
			if (orderFromList != null && orderFromList.size() > 0) {
			orderFromList = bigListRemoveNull(orderFromList);
			Collections.reverse(orderFromList);
			merOrderFromRankVo.setOrderFromRankList(orderFromList);
			}
			return merOrderFromRankVo;
			@@ -3678,7 +5134,7 @@
			String userJoinedString = String.join(",", userIdSet.stream().map(Object::toString).collect(Collectors.toList()));
			MgtBaseBathDto mgtBaseBathDto = new MgtBaseBathDto();
			mgtBaseBathDto.setIds(userJoinedString);
			List<MgtSimpleMemberVo> simpleMemberVoList = remoteMemberService.listSimpleVoByIds(mgtBaseBathDto).getData();
			List<MgtSimpleMemberVo> simpleMemberVoList = remoteMemberService.listSimpleVoByIds(userJoinedString).getData();
			userMap = simpleMemberVoList.stream()
			.collect(Collectors.toMap(MgtSimpleMemberVo::getUserId, Function.identity()));
			}
			@@ -3720,6 +5176,7 @@
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public void autoCancelOrder(String orderId) {
			//更新订单信息
			Order order = this.getById(orderId);
			@@ -3737,6 +5194,9 @@
			try {
			redissonLock.lock(30, TimeUnit.SECONDS);
			Integer surpNum = redisService.getCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + order.getActivityId() + "-" + orderGoods.getGoodsId());
			if(null == surpNum){
			surpNum = 0;
			}
			redisService.setCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + order.getActivityId() + "-" + orderGoods.getGoodsId(), surpNum + orderGoods.getBuyNum());
			} finally {
			redissonLock.unlock();
			@@ -3786,10 +5246,16 @@
			*/
			@Override
			@Transactional
			public void payBack(PartnerTransactionsResult transaction) {
			// 更新订单状态
			String orderId = transaction.getOutTradeNo();
			Order order = this.getById(orderId);
			@GlobalTransactional(rollbackFor = Exception.class)
			public void payBack(PartnerTransactionsResult transaction, BigDecimal feeAmount) {
			log.info("订单支付回调---"+transaction.toString());
			// 更新订单状态 outTradeNo
			String outTradeNo = transaction.getOutTradeNo();
			Order order = this.getByOutTradeNo(outTradeNo);
			if(order.getOrderStatus() != 1){
			return;
			}
			String orderId = order.getOrderId();
			order.setOrderStatus(2);
			order.setPayTime(new Date());
			this.saveOrUpdate(order);
			@@ -3834,37 +5300,15 @@
			goodsTotalChangeDto.setChangeType(1);
			goodsTotalChangeDto.setChangeNum(orderGoods.getBuyNum());
			goodsTotalChangeDto.setMoney(orderGoods.getGoodsReceivableMoney());
			Integer bugGoodsNum = orderMapper.countUserBuyGoodsNum(order.getUserId(), orderGoods.getGoodsId());
			if (bugGoodsNum == null \|\| bugGoodsNum < 1) {
			goodsTotalChangeDto.setPersonNum(1);
			}
			Integer bugGoodsNum = orderMapper.countUserBuyGoodsNum(orderGoods.getGoodsId());
			goodsTotalChangeDto.setPersonNum(bugGoodsNum);
			goodsTotalChangeDtoList.add(goodsTotalChangeDto);
			}
			//更新商品统计
			remoteGoodsService.changeGoodsTotal(goodsTotalChangeDtoList);
			// 更新商户统计信息
			/*ShopTotalChangeDto shopTotalChangeDto = new ShopTotalChangeDto();
			shopTotalChangeDto.setShopId(order.getShopId());
			shopTotalChangeDto.setOrderType(1);
			shopTotalChangeDto.setCycleMoney(cycleMoney);
			shopTotalChangeDto.setServiceMoney(serviceMoney);
			shopTotalChangeDto.setExperienceMoney(experienceMoney);
			shopTotalChangeDto.setGoodsMoney(goodsMoney);
			remoteShopService.changeShopTotal(shopTotalChangeDto);*/
			// 初始化会员统计信息
			MemberTotalChangeDto memberTotalChangeDto = new MemberTotalChangeDto();
			memberTotalChangeDto.setUserId(order.getUserId());
			// 如果存在积分兑换比例，则计算积分
			if (redisService.hasKey(SecurityConstant.PAY_MONEY_INTEGRAL)) {
			Integer moneyValue = redisService.getCacheObject(SecurityConstant.PAY_MONEY_INTEGRAL);
			BigDecimal moneyValueBig = BigDecimal.valueOf(moneyValue);
			BigDecimal integralBig = moneyValueBig.multiply(order.getPayMoney()).setScale(0,BigDecimal.ROUND_HALF_UP);
			Integer integral = Integer.valueOf(integralBig.toString());
			memberTotalChangeDto.setChangeIntegral(integral);
			memberTotalChangeDto.setTypeIntegral(1);
			memberTotalChangeDto.setOrderId(orderId);
			memberTotalChangeDto.setOrderNo(order.getOrderNo());
			}
			// 设置会员支付金额和支付时间
			memberTotalChangeDto.setPayMoney(order.getPayMoney());
			memberTotalChangeDto.setPayTime(new Date());
			@@ -3894,6 +5338,7 @@
			activityTotalChangeDto.setChangeNum(1);
			activityTotalChangeDto.setMoney(order.getPayMoney());
			Integer userActivityNum = orderMapper.countUserActivityByActivity(order.getUserId(), order.getActivityId());
			//判断用户是否下过单如果只有当前订单则为1
			if (userActivityNum == 1) {
			activityTotalChangeDto.setPersonNum(1);
			} else {
			@@ -3901,8 +5346,6 @@
			}
			activityTotalChangeDto.setUserId(order.getUserId());
			remoteActivityService.changeActivityTotal(activityTotalChangeDto);


			//活动订单进行分账
			/*ProfitSharingApplyRequest request=new ProfitSharingApplyRequest();
			request.setAppid(this.appId);
			@@ -3910,8 +5353,8 @@
			request.setTransactionId(transaction.getTransactionId());
			profitsSharingService.applyProfitSharing(request);*/
			}
			//生成支付记录
			OrderPayment orderPayment = new OrderPayment();
			//修改支付记录生成支付记录
			orderPaymentService.updatePaySuccess(transaction.getOutTradeNo(), feeAmount, transaction.getTransactionId());
			PayRecord payRecord = new PayRecord();
			payRecord.setDelFlag(0);
			payRecord.setOrderId(orderId);
			@@ -3919,6 +5362,25 @@
			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
			public Order getByOrderNo(String orderNo) {
			LambdaQueryWrapper<Order> queryWrapper = Wrappers.lambdaQuery();
			queryWrapper.eq(Order::getOrderNo, orderNo)
			.last(" limit 1 ");
			return this.getOne(queryWrapper);
			}

			@Override
			public Order getByOutTradeNo(String outTradeNo) {
			LambdaQueryWrapper<Order> queryWrapper = Wrappers.lambdaQuery();
			queryWrapper.eq(Order::getOutTradeNo, outTradeNo)
			.last(" limit 1 ");
			return this.getOne(queryWrapper);
			}

			/**
			@@ -3930,6 +5392,7 @@
			*/
			@Override
			@Transactional
			@GlobalTransactional(rollbackFor = Exception.class)
			public void refundOrder(String orderId) {
			// 更新订单信息
			Order order = this.getById(orderId);
			@@ -3957,6 +5420,9 @@
			Boolean haveService = false;
			Boolean haveExperience = false;
			Boolean haveGoods = false;
			//商品统计回退
			List<GoodsTotalChangeDto> goodsTotalChangeDtoList = new ArrayList<>();
			GoodsTotalChangeDto goodsTotalChangeDto;
			List<OrderGoods> orderGoodsList = orderGoodsService.listByOrderId(orderId);
			if (orderGoodsList != null && !orderGoodsList.isEmpty()) {
			StringJoiner memberCouponSJ = new StringJoiner(",");
			@@ -3969,6 +5435,9 @@
			try {
			redissonLock.lock(30, TimeUnit.SECONDS);
			Integer surpNum = redisService.getCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + order.getActivityId() + "-" + orderGoods.getGoodsId());
			if(null == surpNum){
			surpNum = 0;
			}
			redisService.setCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + order.getActivityId() + "-" + orderGoods.getGoodsId(), surpNum + orderGoods.getBuyNum());
			} finally {
			redissonLock.unlock();
			@@ -3992,6 +5461,7 @@
			} else {
			memberCouponSJ.add(orderGoods.getCouponId());
			}
			//会员统计更新
			switch (orderGoods.getGoodsType()) {
			case 1:
			cycleMoney = cycleMoney.add(orderGoods.getGoodsReceivableMoney());
			@@ -4012,33 +5482,25 @@
			default:
			break;
			}
			//商品统计更新
			goodsTotalChangeDto = new GoodsTotalChangeDto();
			goodsTotalChangeDto.setGoodsId(orderGoods.getGoodsId());
			goodsTotalChangeDto.setChangeType(2);
			goodsTotalChangeDto.setChangeNum(orderGoods.getBuyNum());
			goodsTotalChangeDto.setMoney(orderGoods.getGoodsReceivableMoney());
			Integer bugGoodsNum = orderMapper.countUserBuyGoodsNum(orderGoods.getGoodsId());
			goodsTotalChangeDto.setPersonNum(bugGoodsNum);
			goodsTotalChangeDtoList.add(goodsTotalChangeDto);
			}
			remoteGoodsService.changeGoodsTotal(goodsTotalChangeDtoList);
			//回退优惠券
			if (memberCouponSJ != null) {
			remoteCouponService.backMemberCoupon(memberCouponSJ.toString());
			}
			}
			// 更新商户统计信息
			/*ShopTotalChangeDto shopTotalChangeDto = new ShopTotalChangeDto();
			shopTotalChangeDto.setOrderType(2);
			shopTotalChangeDto.setShopId(order.getShopId());
			shopTotalChangeDto.setCycleMoney(cycleMoney);
			shopTotalChangeDto.setServiceMoney(serviceMoney);
			shopTotalChangeDto.setExperienceMoney(experienceMoney);
			shopTotalChangeDto.setGoodsMoney(goodsMoney);
			remoteShopService.changeShopTotal(shopTotalChangeDto);*/
			// 初始化会员统计信息
			MemberTotalChangeDto memberTotalChangeDto = new MemberTotalChangeDto();
			memberTotalChangeDto.setUserId(order.getUserId());
			// 如果存在积分兑换比例，则计算积分
			/*if (redisService.hasKey(SecurityConstant.PAY_MONEY_INTEGRAL)) {
			Integer moneyValue = redisService.getCacheObject(SecurityConstant.PAY_MONEY_INTEGRAL);
			BigDecimal moneyValueBig = BigDecimal.valueOf(moneyValue);
			BigDecimal integralBig = moneyValueBig.multiply(order.getPayMoney());
			Integer integral = Integer.valueOf(integralBig.toString());
			memberTotalChangeDto.setChangeIntegral(integral);
			memberTotalChangeDto.setTypeIntegral(2);
			}*/
			// 设置会员支付金额和支付时间
			memberTotalChangeDto.setPayMoney(order.getPayMoney().negate());
			// 根据商品存在状态，设置会员统计信息
			@@ -4065,20 +5527,25 @@
			activityTotalChangeDto.setRefundNum(1);
			activityTotalChangeDto.setMoney(order.getPayMoney());
			Integer userActivityNum = orderMapper.countUserActivityByActivity(order.getUserId(), order.getActivityId());
			//判断用户是否还有活动订单无则减少人数
			if (userActivityNum > 0) {
			activityTotalChangeDto.setPersonNum(1);
			} else {
			activityTotalChangeDto.setPersonNum(0);
			} else {
			activityTotalChangeDto.setPersonNum(1);
			}
			activityTotalChangeDto.setUserId(order.getUserId());
			remoteActivityService.changeActivityTotal(activityTotalChangeDto);
			}

			log.info("用户取消订单退款, 检查退款");
			// 用户取消订单退款
			BigDecimal onlinePayMoney = order.getOnlinePayMoney();
			if(BigDecimal.ZERO.compareTo(onlinePayMoney) < 0){
			log.info("订单支付金额大于0，可发起退款");
			// 订单支付金额大于0，可发起退款
			//orderWxApplyRefund(orderId, refundId, onlinePayMoney, orderRefund);
			// orderWxApplyRefund(orderId, refundId, onlinePayMoney, orderRefund);
			// 订单支付金额大于0，可发起退款 todo 修改渠道（汇付天下）
			orderWxApplyRefund1(orderId, refundId, onlinePayMoney, orderRefund);
			}

			orderRefund.setRefundStatus(1);
			@@ -4088,13 +5555,16 @@
			/**
			* 申请退款API
			*/
			/*private void orderWxApplyRefund(String orderId, String outRefundNo, BigDecimal payMoney, OrderRefund orderRefund){
			private void orderWxApplyRefund(String orderId, String outRefundNo, BigDecimal payMoney, OrderRefund orderRefund){
			try {
			// 创建支付订单
			OrderPayment orderPayment = orderPaymentService.getByOrderId(orderId);
			if (null == orderPayment) {
			return;
			}

			log.info("调用微信退款---发起退款");

			String subMchId = orderPayment.getSubMchId();
			WxPayConfig config = wxService.getConfig();

			@@ -4105,7 +5575,8 @@
			request.setOutRefundNo(outRefundNo);
			request.setReason("用户取消订单");
			// 订单金额
			int total = payMoney.multiply(new BigDecimal(100)).intValue();
			int total = orderPayment.getPayMoney().multiply(new BigDecimal(100)).intValue();

			RefundsRequest.Amount amount = RefundsRequest.Amount.builder().refund(total).total(total).currency("CNY").build();
			request.setAmount(amount);
			request.setNotifyUrl(config.getNotifyUrl());
			@@ -4121,13 +5592,75 @@
			// 返回参数
			String refundResponseJson = gson.toJson(result);

			log.info("调用微信退款返回参数---{}", refundResponseJson);

			// 保存支付订单统一下单日志
			paymentMessageService.savePaymentMessage("3", orderId, refundRequestJson, refundResponseJson);

			} catch (WxPayException e) {
			throw new ServiceException(e.getMessage());
			}
			}*/
			}



			/**
			* 申请退款API
			*/
			private void orderWxApplyRefund1(String orderId, String outRefundNo, BigDecimal payMoney, OrderRefund orderRefund){
			try {
			// 创建支付订单
			OrderPayment orderPayment = orderPaymentService.getByOrderId(orderId);
			if (null == orderPayment) {
			return;
			}

			log.info("调用微信退款---发起退款");

			String subMchId = orderPayment.getSubMchId();
			// WxPayConfig config = wxService.getConfig();

			RefundsRequest request = new RefundsRequest();
			// request.setSpAppid(config.getAppId());
			request.setSubMchid(subMchId);
			request.setTransactionId(orderPayment.getTransactionId());
			request.setOutRefundNo(outRefundNo);
			request.setReason("用户取消订单");
			// 订单金额
			int total = orderPayment.getPayMoney().multiply(new BigDecimal(100)).intValue();

			RefundsRequest.Amount amount = RefundsRequest.Amount.builder().refund(total).total(total).currency("CNY").build();
			request.setAmount(amount);
			request.setNotifyUrl(callbackPath + "/order/app/notify/wechatPaymentRefundCallback");

			// RefundsResult result = wxService.getEcommerceService().refunds(request);

			SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
			String org_req_date = sdf.format(orderPayment.getCreateTime());
			String outTradeNo = orderPayment.getOutTradeNo();
			R<String> r = HuiFuTianXiaUtil.weixinPaymentRefund(outRefundNo, orderPayment.getPayMoney().doubleValue(), org_req_date, outTradeNo, request.getNotifyUrl());
			if(r.getCode() != 200){
			throw new ServiceException(r.getMsg());
			}

			// 微信退款id
			orderRefund.setWxRefundId(r.getData());

			// 请求参数
			Gson gson = new Gson();
			String refundRequestJson = gson.toJson(request);
			// 返回参数
			// String refundResponseJson = gson.toJson(result);

			// log.info("调用微信退款返回参数---{}", refundResponseJson);

			// 保存支付订单统一下单日志
			// paymentMessageService.savePaymentMessage("3", orderId, refundRequestJson, refundResponseJson);

			} catch (Exception e) {
			throw new ServiceException(e.getMessage());
			}
			}

			/**
			* @param staffTotalDto
			@@ -4138,7 +5671,14 @@
			*/
			@Override
			public StaffActivityOrderTotalVo getStaffActivityOrderTotal(StaffTotalDto staffTotalDto) {
			StaffActivityOrderTotalVo staffActivityOrderTotalVo = orderMapper.getStaffActivityOrderTotal(staffTotalDto);
			StaffActivityOrderTotalVo staffActivityOrderTotalVo = new StaffActivityOrderTotalVo();
			if(staffTotalDto.getActivityFrom()==1){
			staffActivityOrderTotalVo = orderMapper.getStaffActivityOrderTotal(staffTotalDto);
			StaffActivityOrderTotalVo staffActivityOrderGoodsTotalVo = orderMapper.getStaffActivityOrderGoodsTotal(staffTotalDto);
			staffActivityOrderTotalVo.setCycleTotal(staffActivityOrderGoodsTotalVo.getCycleTotal());
			staffActivityOrderTotalVo.setServiceTotal(staffActivityOrderGoodsTotalVo.getServiceTotal());
			staffActivityOrderTotalVo.setExperienceTotal(staffActivityOrderGoodsTotalVo.getExperienceTotal());
			}
			return staffActivityOrderTotalVo;
			}

			@@ -4151,7 +5691,10 @@
			*/
			@Override
			public StaffActivityTotalVo getStaffActivityTotal(StaffTotalDto staffTotalDto) {
			StaffActivityTotalVo staffActivityTotalVo = orderMapper.getStaffActivityTotal(staffTotalDto);
			StaffActivityTotalVo staffActivityTotalVo = new StaffActivityTotalVo();
			if(staffTotalDto.getActivityFrom()==1){
			staffActivityTotalVo = orderMapper.getStaffActivityTotal(staffTotalDto);
			}
			return staffActivityTotalVo;
			}

			@@ -4164,13 +5707,16 @@
			*/
			@Override
			public MerOrderDistributionTotalVo getStaffOrderDistributionTotal(StaffTotalDto staffTotalDto) {
			if(staffTotalDto.getGoodsType()!=null&&staffTotalDto.getGoodsType()==0){
			staffTotalDto.setGoodsType(null);
			}
			MerOrderDistributionTotalVo orderDistributionTotalVo = new MerOrderDistributionTotalVo();
			// 获取订单年龄用户列表
			MerTotalDto merTotalDto = new MerTotalDto();
			merTotalDto.setShopId(staffTotalDto.getShopId());
			List<MerOrderAgeUserVo> orderAgeUserVoList = remoteMemberService.listOrderAgeUser(merTotalDto).getData();
			//MerTotalDto merTotalDto = new MerTotalDto();
			//merTotalDto.setShopId(staffTotalDto.getShopId());
			//List<MerOrderAgeUserVo> orderAgeUserVoList = remoteMemberService.listOrderAgeUser(merTotalDto).getData();
			// 如果订单年龄用户列表不为空
			if (orderAgeUserVoList != null && !orderAgeUserVoList.isEmpty()) {
			/*if (orderAgeUserVoList != null && !orderAgeUserVoList.isEmpty()) {
			// 定义变量
			Integer ageType;
			List<Long> userIdList;
			@@ -4216,9 +5762,90 @@
			orderDistributionTotalVo.setOrderTotalKey(orderTotalKey);
			orderDistributionTotalVo.setOrderTotalValue(orderTotalValue);
			orderDistributionTotalVo.setOrderMoneyValue(orderMoneyValue);
			}*/
			if(staffTotalDto.getActivityFrom()==1){
			List<MgtMapTotalPlusVo> mgtMapTotalPlusVoList = orderMapper.listStaffActivityOrderDistributionTotal(staffTotalDto);
			String[] orderTotalKey = new String[mgtMapTotalPlusVoList.size()];
			Integer[] orderTotalValue = new Integer[mgtMapTotalPlusVoList.size()];
			BigDecimal[] orderMoneyValue = new BigDecimal[mgtMapTotalPlusVoList.size()];
			if (mgtMapTotalPlusVoList != null && !mgtMapTotalPlusVoList.isEmpty()) {
			MgtMapTotalPlusVo mgtMapTotalPlusVo;
			for (int i = 0; i < mgtMapTotalPlusVoList.size(); i++) {
			mgtMapTotalPlusVo = mgtMapTotalPlusVoList.get(i);
			orderTotalKey[i] = mgtMapTotalPlusVo.getMapKey();
			orderTotalValue[i] = mgtMapTotalPlusVo.getMapValueFirst();
			orderMoneyValue[i] = mgtMapTotalPlusVo.getMapValueSecond();
			}
			orderDistributionTotalVo = fillOrderTotalKeyAndValuesToRecentFiveDays(orderTotalKey,orderTotalValue,orderMoneyValue);
			}else{
			orderDistributionTotalVo.setOrderTotalKey(orderTotalKey);
			orderDistributionTotalVo.setOrderTotalValue(orderTotalValue);
			orderDistributionTotalVo.setOrderMoneyValue(orderMoneyValue);
			}
			}
			// 返回订单分布总数对象
			return orderDistributionTotalVo;
			}

			/**
			* @description 补时间
			* @author jqs
			* @date 2023/8/28 15:03
			* @param orderTotalKey
			* @param orderTotalValue
			* @param orderMoneyValue
			* @return MerOrderDistributionTotalVo
			*/
			public MerOrderDistributionTotalVo fillOrderTotalKeyAndValuesToRecentFiveDays(String[] orderTotalKey,Integer[] orderTotalValue,BigDecimal[] orderMoneyValue) {
			MerOrderDistributionTotalVo orderDistributionTotalVo = new MerOrderDistributionTotalVo();
			// 获取当前日期
			LocalDate currentDate = LocalDate.now();

			// 创建最近五天日期列表
			List<String> recentFiveDays = new ArrayList<>();
			for (int i = 0; i < 5; i++) {
			LocalDate date = currentDate.minusDays(i);
			recentFiveDays.add(date.toString());
			}

			// 创建新的数组
			String[] newOrderTotalKey = new String[5];
			Integer[] newOrderTotalValue = new Integer[5];
			BigDecimal[] newOrderMoneyValue = new BigDecimal[5];

			// 遍历最近五天日期列表，并补充数据
			for (int i = 0; i < 5; i++) {
			String day = recentFiveDays.get(i);
			int index = getIndexInOrderTotalKey(day,orderTotalKey);
			if (index != -1) {
			newOrderTotalKey[i] = orderTotalKey[index];
			newOrderTotalValue[i] = orderTotalValue[index];
			newOrderMoneyValue[i] = orderMoneyValue[index];
			} else {
			newOrderTotalKey[i] = day;
			newOrderTotalValue[i] = 0;
			newOrderMoneyValue[i] = BigDecimal.ZERO;
			}
			}

			// 更新属性
			orderTotalKey = newOrderTotalKey;
			orderTotalValue = newOrderTotalValue;
			orderMoneyValue = newOrderMoneyValue;
			orderDistributionTotalVo.setOrderTotalKey(orderTotalKey);
			orderDistributionTotalVo.setOrderTotalValue(orderTotalValue);
			orderDistributionTotalVo.setOrderMoneyValue(orderMoneyValue);
			return orderDistributionTotalVo;
			}


			private int getIndexInOrderTotalKey(String day,String[] orderTotalKey) {
			for (int i = 0; i < orderTotalKey.length; i++) {
			if (orderTotalKey[i].equals(day)) {
			return i;
			}
			}
			return -1;
			}


			@@ -4232,37 +5859,104 @@
			@Override
			public MerOrderTypeTotalVo getStaffOrderTypeTotal(StaffTotalDto staffTotalDto) {
			MerOrderTypeTotalVo orderTypeTotalVo = new MerOrderTypeTotalVo();
			//获取商品分类销售数据
			List<MgtMapTotalPlusVo> MgtMapIntTotalVoGoodsType = orderMapper.listStaffOrderTotalGoodsType(staffTotalDto);
			List<MgtMapIntTotalVo> goodsTypeTotalList = new ArrayList<>();
			List<MgtMapBigTotalVo> goodsTypeMoneyList = new ArrayList<>();
			if (MgtMapIntTotalVoGoodsType != null && MgtMapIntTotalVoGoodsType.size() > 0) {
			MgtMapIntTotalVo MgtMapIntTotalVo;
			MgtMapBigTotalVo mgtMapBigTotalVo;
			// 遍历不同商品类型的会员数列表，设置商品类型数组和对应的会员数数组
			for (int i = 0; i < MgtMapIntTotalVoGoodsType.size(); i++) {
			MgtMapIntTotalVo = new MgtMapIntTotalVo();
			mgtMapBigTotalVo = new MgtMapBigTotalVo();
			MgtMapIntTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtMapBigTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond());
			if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("1")) {
			MgtMapIntTotalVo.setMapKey("周期");
			mgtMapBigTotalVo.setMapKey("周期");
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("2")) {
			MgtMapIntTotalVo.setMapKey("服务");
			mgtMapBigTotalVo.setMapKey("服务");
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("3")) {
			MgtMapIntTotalVo.setMapKey("体验");
			mgtMapBigTotalVo.setMapKey("体验");
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("4")) {
			MgtMapIntTotalVo.setMapKey("单品");
			mgtMapBigTotalVo.setMapKey("单品");
			if(staffTotalDto.getActivityFrom()==1){
			//获取商品分类销售数据
			List<MgtMapTotalPlusVo> MgtMapIntTotalVoGoodsType = orderMapper.listStaffOrderTotalGoodsType(staffTotalDto);
			List<MgtMapIntTotalVo> goodsTypeTotalList = new ArrayList<>();
			List<MgtMapBigTotalVo> goodsTypeMoneyList = new ArrayList<>();
			if (MgtMapIntTotalVoGoodsType != null && MgtMapIntTotalVoGoodsType.size() > 0) {
			MgtMapIntTotalVo mgtMapIntTotalVo;
			MgtMapBigTotalVo mgtMapBigTotalVo;
			Integer intTotal = 0;
			BigDecimal bigTotal = BigDecimal.ZERO;
			for(MgtMapTotalPlusVo mgtMapTotalPlusVo : MgtMapIntTotalVoGoodsType){
			intTotal = intTotal + mgtMapTotalPlusVo.getMapValueFirst();
			bigTotal = bigTotal.add(mgtMapTotalPlusVo.getMapValueSecond());
			}
			goodsTypeTotalList.add(MgtMapIntTotalVo);
			goodsTypeMoneyList.add(mgtMapBigTotalVo);
			BigDecimal hundredBig = new BigDecimal("100");
			BigDecimal intTotalBig = hundredBig;
			if(intTotal!=0){
			intTotalBig = new BigDecimal(intTotal.toString());
			}
			if(bigTotal.compareTo(BigDecimal.ZERO)<1){
			bigTotal = hundredBig;
			}
			// 遍历不同商品类型的会员数列表，设置商品类型数组和对应的会员数数组
			Boolean noCycle = true;
			Boolean noService = true;
			Boolean noExperience = true;
			Boolean noGoods = true;
			for (int i = 0; i < MgtMapIntTotalVoGoodsType.size(); i++) {
			mgtMapIntTotalVo = new MgtMapIntTotalVo();
			mgtMapBigTotalVo = new MgtMapBigTotalVo();
			mgtMapIntTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst());
			mgtMapIntTotalVo.setMapPercent(BigDecimal.valueOf(MgtMapIntTotalVoGoodsType.get(i).getMapValueFirst()).divide(intTotalBig,2,BigDecimal.ROUND_HALF_UP).multiply(hundredBig));
			mgtMapBigTotalVo.setMapValue(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond());
			mgtMapBigTotalVo.setMapPercent(MgtMapIntTotalVoGoodsType.get(i).getMapValueSecond().divide(bigTotal,2,BigDecimal.ROUND_HALF_UP).multiply(hundredBig));
			if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("1")) {
			mgtMapIntTotalVo.setMapKey("周期");
			mgtMapBigTotalVo.setMapKey("周期");
			noCycle= false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("2")) {
			mgtMapIntTotalVo.setMapKey("服务");
			mgtMapBigTotalVo.setMapKey("服务");
			noService= false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("3")) {
			mgtMapIntTotalVo.setMapKey("体验");
			mgtMapBigTotalVo.setMapKey("体验");
			noExperience = false;
			} else if (MgtMapIntTotalVoGoodsType.get(i).getMapKey().equals("4")) {
			mgtMapIntTotalVo.setMapKey("单品");
			mgtMapBigTotalVo.setMapKey("单品");
			noGoods = false;
			}
			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);
			}
			orderTypeTotalVo.setGoodsTypeTotalList(goodsTypeTotalList);
			orderTypeTotalVo.setGoodsTypeMoneyList(goodsTypeMoneyList);
			}
			orderTypeTotalVo.setGoodsTypeTotalList(goodsTypeTotalList);
			orderTypeTotalVo.setGoodsTypeMoneyList(goodsTypeMoneyList);
			}
			return orderTypeTotalVo;
			}
			@@ -4278,32 +5972,34 @@
			public StaffActivityDateMemberTotalVo getStaffActivityGetMemberTotal(StaffTotalDto staffTotalDto) {
			// 创建返回对象
			StaffActivityDateMemberTotalVo staffActivityDateMemberTotalVo = new StaffActivityDateMemberTotalVo();
			// 查询数据库获取数据
			List<MgtMapIntTotalVo> mgtMapIntTotalVoList = orderMapper.getStaffActivityGetMemberTotal(staffTotalDto);
			// 将查询结果转为Map
			Map<String, Integer> map = new HashMap<>();
			if (mgtMapIntTotalVoList != null && !mgtMapIntTotalVoList.isEmpty()) {
			map = mgtMapIntTotalVoList.stream()
			.collect(Collectors.toMap(MgtMapIntTotalVo::getMapKey, MgtMapIntTotalVo::getMapValue));
			if(staffTotalDto.getActivityFrom()==1){
			// 查询数据库获取数据
			List<MgtMapIntTotalVo> mgtMapIntTotalVoList = orderMapper.getStaffActivityGetMemberTotal(staffTotalDto);
			// 将查询结果转为Map
			Map<String, Integer> map = new HashMap<>();
			if (mgtMapIntTotalVoList != null && !mgtMapIntTotalVoList.isEmpty()) {
			map = mgtMapIntTotalVoList.stream()
			.collect(Collectors.toMap(MgtMapIntTotalVo::getMapKey, MgtMapIntTotalVo::getMapValue));
			}
			// 获取日期范围
			List<String> dateList = getDateRange(staffTotalDto.getStartDate(), staffTotalDto.getEndDate());
			int size = dateList.size();
			// 创建日期和成员总数的数组
			String[] dateMemberTotalKey = new String[size];
			Integer[] dateMemberTotalValue = new Integer[size];
			// 遍历日期列表，设置日期和成员总数的数组
			String str;
			Integer value;
			for (int i = 0; i < size; i++) {
			str = dateList.get(i);
			dateMemberTotalKey[i] = str;
			value = map.get(str);
			dateMemberTotalValue[i] = (value != null) ? value : 0;
			}
			// 设置返回对象的日期和成员总数数组
			staffActivityDateMemberTotalVo.setDateMemberTotalKey(dateMemberTotalKey);
			staffActivityDateMemberTotalVo.setDateMemberTotalValue(dateMemberTotalValue);
			}
			// 获取日期范围
			List<String> dateList = getDateRange(staffTotalDto.getStartDate(), staffTotalDto.getEndDate());
			int size = dateList.size();
			// 创建日期和成员总数的数组
			String[] dateMemberTotalKey = new String[size];
			Integer[] dateMemberTotalValue = new Integer[size];
			// 遍历日期列表，设置日期和成员总数的数组
			String str;
			Integer value;
			for (int i = 0; i < size; i++) {
			str = dateList.get(i);
			dateMemberTotalKey[i] = str;
			value = map.get(str);
			dateMemberTotalValue[i] = (value != null) ? value : 0;
			}
			// 设置返回对象的日期和成员总数数组
			staffActivityDateMemberTotalVo.setDateMemberTotalKey(dateMemberTotalKey);
			staffActivityDateMemberTotalVo.setDateMemberTotalValue(dateMemberTotalValue);
			// 返回结果对象
			return staffActivityDateMemberTotalVo;
			}
			@@ -4319,32 +6015,40 @@
			public StaffActivityDateMemberTotalVo getStaffActivityMemberTotal(StaffTotalDto staffTotalDto) {
			// 创建返回对象
			StaffActivityDateMemberTotalVo staffActivityDateMemberTotalVo = new StaffActivityDateMemberTotalVo();
			// 查询数据库获取数据
			List<MgtMapIntTotalVo> mgtMapIntTotalVoList = orderMapper.getStaffActivityMemberTotal(staffTotalDto);
			// 将查询结果转为Map
			Map<String, Integer> map = new HashMap<>();
			if (mgtMapIntTotalVoList != null && !mgtMapIntTotalVoList.isEmpty()) {
			map = mgtMapIntTotalVoList.stream()
			.collect(Collectors.toMap(MgtMapIntTotalVo::getMapKey, MgtMapIntTotalVo::getMapValue));
			if(staffTotalDto.getActivityFrom()==1){
			MerTotalDto merTotalDto = new MerTotalDto();
			merTotalDto.setAgeType(staffTotalDto.getAgeType());
			if(staffTotalDto.getAgeType()!=null){
			List<Long> userIdList = remoteMemberService.listUserIdByAgeType(staffTotalDto.getAgeType()).getData();
			staffTotalDto.setUserIdList(userIdList);
			}
			// 查询数据库获取数据
			List<MgtMapIntTotalVo> mgtMapIntTotalVoList = orderMapper.getStaffActivityMemberTotal(staffTotalDto);
			// 将查询结果转为Map
			Map<String, Integer> map = new HashMap<>();
			if (mgtMapIntTotalVoList != null && !mgtMapIntTotalVoList.isEmpty()) {
			map = mgtMapIntTotalVoList.stream()
			.collect(Collectors.toMap(MgtMapIntTotalVo::getMapKey, MgtMapIntTotalVo::getMapValue));
			}
			// 获取日期范围
			List<String> dateList = getDateRange(staffTotalDto.getStartDate(), staffTotalDto.getEndDate());
			int size = dateList.size();
			// 创建日期和成员总数的数组
			String[] dateMemberTotalKey = new String[size];
			Integer[] dateMemberTotalValue = new Integer[size];
			// 遍历日期列表，设置日期和成员总数的数组
			String str;
			Integer value;
			for (int i = 0; i < size; i++) {
			str = dateList.get(i);
			dateMemberTotalKey[i] = str;
			value = map.get(str);
			dateMemberTotalValue[i] = (value != null) ? value : 0;
			}
			// 设置返回对象的日期和成员总数数组
			staffActivityDateMemberTotalVo.setDateMemberTotalKey(dateMemberTotalKey);
			staffActivityDateMemberTotalVo.setDateMemberTotalValue(dateMemberTotalValue);
			}
			// 获取日期范围
			List<String> dateList = getDateRange(staffTotalDto.getStartDate(), staffTotalDto.getEndDate());
			int size = dateList.size();
			// 创建日期和成员总数的数组
			String[] dateMemberTotalKey = new String[size];
			Integer[] dateMemberTotalValue = new Integer[size];
			// 遍历日期列表，设置日期和成员总数的数组
			String str;
			Integer value;
			for (int i = 0; i < size; i++) {
			str = dateList.get(i);
			dateMemberTotalKey[i] = str;
			value = map.get(str);
			dateMemberTotalValue[i] = (value != null) ? value : 0;
			}
			// 设置返回对象的日期和成员总数数组
			staffActivityDateMemberTotalVo.setDateMemberTotalKey(dateMemberTotalKey);
			staffActivityDateMemberTotalVo.setDateMemberTotalValue(dateMemberTotalValue);
			// 返回结果对象
			return staffActivityDateMemberTotalVo;
			}
			@@ -4432,6 +6136,7 @@
			}
			}

			@GlobalTransactional(rollbackFor = Exception.class)
			private void autoTimeCancelOrder(Order order) {
			String orderId = order.getOrderId();
			order.setOrderStatus(0);
			@@ -4448,6 +6153,9 @@
			try {
			redissonLock.lock(30, TimeUnit.SECONDS);
			Integer surpNum = redisService.getCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + order.getActivityId() + "-" + orderGoods.getGoodsId());
			if(null == surpNum){
			surpNum = 0;
			}
			redisService.setCacheObject(SecurityConstant.ACTIVITY_GOODS + "-" + order.getActivityId() + "-" + orderGoods.getGoodsId(), surpNum + orderGoods.getBuyNum());
			} finally {
			redissonLock.unlock();
			@@ -4508,51 +6216,122 @@
			*/
			@Override
			public List<MerOrderPageVo> pageMerMemberPayOrder(Page page,MerMemberNoClearOrderDto merOrderPageDto){
			// 获取订单列表
			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) {
			userId = merOrderPageVo.getUserId();
			userIdSj.add(userId.toString());
			orderFrom = merOrderPageVo.getOrderFrom();
			if (orderFrom != null) {
			if (orderFrom == 1) {
			orderFromDesc = "商城订单";
			} else {
			orderFromDesc = "线下创建";
			}
			} else {
			orderFromDesc = "商城订单";
			}
			merOrderPageVo.setOrderFromDesc(orderFromDesc);
			merOrderPageVo.setUnPaidMoney(merOrderPageVo.getPayMoney().subtract(merOrderPageVo.getReceiveMoney()));
			if (merOrderPageVo.getUnPaidMoney() == null) {
			merOrderPageVo.setUnPaidMoney(zeroBig);
			}
			if(merOrderPageVo.getUnPaidMoney().compareTo(zeroBig)<0){
			// 如果未支付金额小于零，则设置为零
			if (merOrderPageVo.getUnPaidMoney().compareTo(zeroBig) < 0) {
			merOrderPageVo.setUnPaidMoney(zeroBig);
			}
			}
			// 获取用户列表
			MgtBaseBathDto mgtBaseBathDto = new MgtBaseBathDto();
			mgtBaseBathDto.setIds(userIdSj.toString());
			List<MgtSimpleMemberVo> simpleMemberVoList = remoteMemberService.listSimpleVoByIds(mgtBaseBathDto).getData();
			List<MgtSimpleMemberVo> simpleMemberVoList = remoteMemberService.listSimpleVoByIds(userIdSj.toString()).getData();
			// 将用户列表转换为Map，以便根据用户ID快速查找用户信息
			Map<Long, MgtSimpleMemberVo> userMap = simpleMemberVoList.stream()
			.collect(Collectors.toMap(MgtSimpleMemberVo::getUserId, Function.identity()));
			// 遍历订单列表
			for (MerOrderPageVo merOrderPageVo : merOrderPageVoList) {
			if(merOrderPageVo.getUserId()!=null&&userMap.get(merOrderPageVo.getUserId())!=null){
			// 如果订单的用户ID不为空，并且用户Map中存在对应的用户信息
			if (merOrderPageVo.getUserId() != null && userMap.get(merOrderPageVo.getUserId()) != null) {
			// 设置订单的用户名、昵称和手机号
			merOrderPageVo.setUserName(userMap.get(merOrderPageVo.getUserId()).getRealName());
			merOrderPageVo.setNickName(userMap.get(merOrderPageVo.getUserId()).getNickName());
			merOrderPageVo.setUserMobile(userMap.get(merOrderPageVo.getUserId()).getUserMobile());
			}else{
			log.debug("订单merOrderPageVo"+merOrderPageVo.getOrderId()+"缺少用户");
			} else {
			log.debug("订单merOrderPageVo" + merOrderPageVo.getOrderId() + "缺少用户");
			}
			}
			}
			return merOrderPageVoList;
			}

			/**
			* @description 获取销售排行
			* @author jqs
			* @date 2023/8/24 18:00
			* @param shopIdList
			* @return List<MgtMapIntTotalVo>
			*/
			@Override
			public List<MgtMapBigTotalVo> shopSalesRank(List<Long> shopIdList){
			return orderMapper.shopSalesRank(shopIdList);
			}

			/**
			* @description 获取商户服务统计
			* @author jqs
			* @date 2023/8/24 18:28
			* @param shopId
			* @return MerHomeShopTotalVo
			*/
			@Override
			public MerHomeShopTotalVo getShopServiceTotal(Long shopId){
			MerHomeShopTotalVo serviceTotalVo = orderMapper.getMerHomeShopServiceTotalVo(shopId);
			return serviceTotalVo;
			}

			/**
			* @description 获取区域统计
			* @author jqs
			* @date 2023/8/25 11:49
			* @param shopIdList
			* @return AgencyTotalVo
			*/
			@Override
			public AgencyTotalVo getAgencyTotalVo(List<Long> shopIdList){
			AgencyTotalVo agencyTotalVo = orderMapper.getAgencyTotalVo(shopIdList);
			return agencyTotalVo;
			}

			/**
			* @description 商户端会员订单统计
			* @author jqs
			* @date 2023/8/29 17:39
			* @param merBaseDto
			* @return MerMemberSimpleTotalVo
			*/
			@Override
			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;
			}

			@Override
			public List<String> getActivityOrderGoods(String activityId) {
			List<Order> orders = this.baseMapper.selectList(new QueryWrapper<Order>()
			.eq("del_flag", 0)
			.in("order_status", Arrays.asList(1, 2, 3))
			.eq("activity_id", activityId)
			);
			if(orders.size() > 0){
			List<String> collect = orders.stream().map(Order::getOrderId).collect(Collectors.toList());
			List<OrderGoods> list = orderGoodsService.list(new QueryWrapper<OrderGoods>()
			.eq("del_flag", 0)
			.in("order_id", collect)
			);
			return list.stream().map(OrderGoods::getGoodsId).collect(Collectors.toList());
			}
			return new ArrayList<>();
			}
			}