所有代码

无关风月

2025-08-05 2134c13b7b2815983281fdc819e3138ffde1bc48

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

@@ -9,6 +9,7 @@
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.kuaidi100.sdk.request.samecity.OrderGoods;
import com.ruoyi.account.api.feignClient.*;
import com.ruoyi.account.api.model.*;

@@ -25,6 +26,7 @@

import com.ruoyi.order.mapper.OrderGoodMapper;
import com.ruoyi.order.mapper.OrderMapper;
import com.ruoyi.order.model.ChargeOrder;
import com.ruoyi.order.model.Order;
import com.ruoyi.order.model.OrderGood;
import com.ruoyi.order.service.OrderGoodService;
@@ -33,6 +35,11 @@
import com.ruoyi.order.util.payment.PaymentUtil;
import com.ruoyi.order.util.payment.model.*;

import com.ruoyi.order.util.payment.wechat.PayMoneyUtil;
import com.ruoyi.order.util.payment.wx.WechatPayConfig;
import com.ruoyi.order.util.payment.wx.WechatPayService;
import com.ruoyi.order.util.payment.wx.vo.PayResult;
import com.ruoyi.order.util.payment.wx.vo.RefundCallbackResult;
import com.ruoyi.order.vo.*;
import com.ruoyi.other.api.domain.*;
import com.ruoyi.other.api.feignClient.*;
@@ -43,26 +50,35 @@
import com.ruoyi.system.api.feignClient.SysUserClient;
import com.ruoyi.system.api.model.LoginUser;

import io.swagger.models.auth.In;
import lombok.extern.slf4j.Slf4j;

import org.apache.poi.ss.formula.functions.T;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.math.RoundingMode;

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.*;

import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.util.*;

import java.util.function.Function;
import java.util.stream.Collectors;

/**
@@ -110,7 +126,7 @@
    private RedisTemplate redisTemplate;

    @Resource
    private  ShopBalanceStatementClient shopBalanceStatementClient;
    private ShopBalanceStatementClient shopBalanceStatementClient;

    @Resource
    private GoodsEvaluateClient goodsEvaluateClient;
@@ -124,6 +140,13 @@
    private ApplicationEventPublisher applicationEventPublisher;


    @Resource
    private PayMoneyUtil payMoneyUtil;

    @Resource
    private WechatPayService wechatPayService;


    @Override
    public List<OrderVO> selectOrderListByUserId(Integer status, Long userId) {
        return orderMapper.selectOrderListByUserId(status, userId);
@@ -132,6 +155,7 @@

    @Override
    public OrderDetailVO getOrderDetail(Long orderId) {
        OrderDetailVO orderDetailVO = new OrderDetailVO();
        Order order = orderMapper.selectById(orderId);
        if (order == null) {
            throw new ServiceException("订单不存在");
@@ -140,22 +164,33 @@
        if (!R.isSuccess(shopR)) {
            throw new ServiceException("获取门店信息失败");
        }

        AppUser appUserById = appUserClient.getAppUserById(order.getAppUserId());
        if (appUserById != null) {
            orderDetailVO.setUsername(appUserById.getName());
        }
        // 商品
        OrderGood orderGood = orderGoodMapper.selectOne(new LambdaQueryWrapper<OrderGood>().eq(OrderGood::getOrderId, orderId));
        String goodJson = orderGood.getGoodJson();
        Goods goods = JSONObject.parseObject(goodJson, Goods.class);

        GoodsSeckill goodsSeckill = JSON.parseObject(orderGood.getSeckillJson(), GoodsSeckill.class);
        OrderGoodsVO orderGoodsVO = new OrderGoodsVO();

        orderGoodsVO.setGoodsId(goods.getId());
        orderGoodsVO.setGoodsName(goods.getName());
        orderGoodsVO.setGoodsPic(goods.getHomePagePicture());
        orderGoodsVO.setNum(order.getNum());
        orderGoodsVO.setSellingPrice(goods.getSellingPrice());
        orderGoodsVO.setIntegral(goods.getIntegral());
        if (null != goodsSeckill) {
            orderGoodsVO.setSellingPrice(goodsSeckill.getSellingPrice());
            orderGoodsVO.setIntegral(goodsSeckill.getIntegral());
        } else {
            orderGoodsVO.setSellingPrice(goods.getSellingPrice());
            orderGoodsVO.setIntegral(goods.getIntegral());
        }


        orderGoodsVO.setOriginalPrice(goods.getOriginalPrice());

        OrderDetailVO orderDetailVO = new OrderDetailVO();

        orderDetailVO.setOrderGoodsVO(orderGoodsVO);
        Shop shop = shopR.getData();

@@ -169,6 +204,7 @@
        orderDetailVO.setPaymentAmount(order.getPaymentAmount());
        orderDetailVO.setShopName(shop.getName());
        orderDetailVO.setShopAddress(shop.getAddress());
        orderDetailVO.setDetailAddress(shop.getDetailAddress());
        orderDetailVO.setLongitude(shop.getLongitude());
        orderDetailVO.setLatitude(shop.getLatitude());
        orderDetailVO.setShopId(shop.getId());
@@ -180,8 +216,12 @@
            e.printStackTrace();
            throw new ServiceException("生成核销码失败");
        }
        if (3 != order.getOrderStatus()) {
            //不属于未使用的，应该有个核销\取消时间
            orderDetailVO.setEndTime(order.getEndTime());
        }
        //该商品是否被用户评论
        Long evaluateId = goodsEvaluateClient.getEvaluateIdByUserIdAndGoodId(goods.getId(), order.getAppUserId()).getData();
        Long evaluateId = goodsEvaluateClient.getEvaluateIdByOrderId(order.getId()).getData();
        orderDetailVO.setEvaluateId(evaluateId);

        return orderDetailVO;
@@ -207,6 +247,9 @@
        }
        if (!order.getShopId().equals(shopId)) {
            throw new ServiceException("该订单与当前扫码门店不一致");
        }
        if (order.getOrderStatus() != 3) {
            throw new ServiceException("订单已被核销过");
        }


@@ -241,27 +284,7 @@
     * @return
     */
    @Override
    public PageInfo<OrderPageListVo> getOrderPageList(OrderPageList orderPageList) {
       /* Long userid = tokenService.getLoginUser().getUserid();
        SysUser sysUser = sysUserClient.getSysUser(userid).getData();
        if (2 == sysUser.getRoleType()) {
            orderPageList.setShopId(sysUser.getObjectId());
        }
        //搜索条件，用户姓名
        if (StringUtils.isNotEmpty(orderPageList.getUserName())) {
            List<AppUser> data = appUserClient.getAppUserByNameNoFilter(orderPageList.getUserName()).getData();
            List<Long> collect = data.stream().map(AppUser::getId).collect(Collectors.toList());
            if (CollectionUtils.isEmpty(collect)) {
                return new PageInfo<>();
            }
            if (null != orderPageList.getAppUserIds()) {
                List<Long> appUserIds = orderPageList.getAppUserIds();
                appUserIds.addAll(collect);
                orderPageList.setAppUserIds(appUserIds);
            } else {
                orderPageList.setAppUserIds(collect);
            }
        }
    public PageInfo<OrderManagePageListVO> getOrderPageList(OrderPageList orderPageList) {
        //搜索条件，用户电话
        if (StringUtils.isNotEmpty(orderPageList.getPhone())) {
            List<AppUser> data = appUserClient.getAppUserByPhoneNoFilter(orderPageList.getPhone()).getData();
@@ -285,33 +308,47 @@
            orderPageList.setAppUserIds(orderPageList.getAppUserIds().stream().distinct().collect(Collectors.toList()));
        }

        //搜索条件 店铺名称
        if (StringUtils.isNotEmpty(orderPageList.getShopName())) {
            List<Integer> shopSet = new ArrayList<>(shopClient.getShopIdByName(orderPageList.getShopName()).getData());
            if (CollectionUtils.isEmpty(shopSet)) {
                return new PageInfo<>();
            }
            if (null != orderPageList.getShopIds()) {
                List<Integer> shopIds = orderPageList.getShopIds();
                if (!containsIntegerAny(shopIds, shopSet)) {
                    return new PageInfo<>();
                }
                shopIds.addAll(shopSet);
                orderPageList.setShopIds(shopIds);
            } else {
                orderPageList.setShopIds(shopSet);
            }
        }
        if (null != orderPageList.getShopIds()) {
            orderPageList.setShopIds(orderPageList.getShopIds().stream().distinct().collect(Collectors.toList()));
        }

        PageInfo<OrderPageListVo> pageInfo = new PageInfo<>(orderPageList.getPageCurr(), orderPageList.getPageSize());
        PageInfo<OrderManagePageListVO> pageInfo = new PageInfo<>(orderPageList.getPageCurr(), orderPageList.getPageSize());

        List<OrderPageListVo> list = this.baseMapper.getOrderPageList(pageInfo, orderPageList);
        for (OrderPageListVo orderPageListVo : list) {
        List<OrderManagePageListVO> list = this.baseMapper.getOrderPageList(pageInfo, orderPageList);

        for (OrderManagePageListVO orderPageListVo : list) {
            Long appUserId = orderPageListVo.getAppUserId();
            AppUser appUser = appUserClient.getAppUserById(appUserId);
            if (null != appUser) {
                orderPageListVo.setUserName(appUser.getName());
                orderPageListVo.setPhone(appUser.getPhone());
            }
            String expressJson = orderPageListVo.getExpressJson();
            if (StringUtils.isNotEmpty(expressJson) && !expressJson.equals("NULL")) {
                JSONObject jsonObject = null;
                try {
                    jsonObject = JSONObject.parseObject(expressJson);
                    String companyName = ExpressCompanyMap.getCompanyNameByCode(jsonObject.getString("com"));
                    orderPageListVo.setExpressCompany(companyName);
                    orderPageListVo.setExpressNum(jsonObject.getString("num"));
                } catch (Exception e) {
                }

            //店铺名称
            Shop shop = shopClient.getShopById(orderPageListVo.getShopId()).getData();
            if (null != shop) {
                orderPageListVo.setShopName(shop.getName());
            }
            orderPageListVo.setIdStr(orderPageListVo.getId().toString());

        }
        return pageInfo.setRecords(list);*/
        return null;
        return pageInfo.setRecords(list);
    }

    /**
@@ -327,6 +364,28 @@

        // 遍历 list2，检查是否有元素存在于 set1 中
        for (Long element : list2) {
            if (set1.contains(element)) {
                return true;
            }
        }

        // 如果没有找到共同元素，返回 false
        return false;
    }

    /**
     * 判断 list1 是否包含 list2 中的至少一个元素
     *
     * @param list1 第一个列表
     * @param list2 第二个列表
     * @return 如果 list1 包含 list2 中的至少一个元素，返回 true；否则返回 false
     */
    private boolean containsIntegerAny(List<Integer> list1, List<Integer> list2) {
        // 将 list1 转换为 HashSet 以提高查询效率
        Set<Integer> set1 = new HashSet<>(list1);

        // 遍历 list2，检查是否有元素存在于 set1 中
        for (Integer element : list2) {
            if (set1.contains(element)) {
                return true;
            }
@@ -365,8 +424,6 @@
    }




    /**
     * 取消订单操作
     *
@@ -376,12 +433,10 @@
    @Override
    public R cancelOrder(Long orderId) {
        Order order = this.getById(orderId);
        if (Arrays.asList(5, 6, 7).contains(order.getOrderStatus())) {
        if (Arrays.asList(4, 5, 8).contains(order.getOrderStatus())) {
            return R.fail("无效的操作");
        }
        if (null != order.getAfterSaleTime() && LocalDateTime.now().isAfter(order.getAfterSaleTime())) {
            return R.fail("订单取消失败");
        }

        order.setOrderStatus(5);
        R r = refundPayMoney(order);
        if (200 == r.getCode()) {
@@ -396,9 +451,26 @@
     */
    public R refundPayMoney(Order order) {
        //开始退款
        //先回退积分
        BigDecimal paymentAmount = order.getPaymentAmount();
        if (BigDecimal.ZERO.compareTo(order.getPaymentAmount()) < 0) {//支付的金额是否大于0
            //微信退款
            Map<String, String> map = wechatPayService.refund(order.getOrderNumber(), order.getOrderNumber(), order.getPaymentAmount().toString(), order.getPaymentAmount().toString(), "退款", "/order/order/refundPayMoneyCallback");

//            RefundResult refund = PaymentUtil.refund(order.getOrderNumber(), "R" + order.getOrderNumber(), paymentAmount.doubleValue(), "/order/order/refundPayMoneyCallback");
            if (!"SUCCESS".equals(map.get("return_code"))) {
                return R.fail(map.get("return_msg"));//退款失败
            }
            //这里申请成功后先返回，等待微信退款成功再返回积分这些
            order.setRefundStatus(1);
            this.updateById(order);
            return R.ok();
        }
        //退款成功再回退积分
        AppUser appUser = appUserClient.getAppUserById(order.getAppUserId());
        if (order.getPoint()>0) {
        if (order.getPoint() > 0) {
            if (null == appUser.getCancelPoint()) {
                appUser.setCancelPoint(0);
            }
            //返回订单抵扣积分
            Integer historicalPoint = appUser.getAvailablePoint();
            Integer availablePoint = appUser.getAvailablePoint() + order.getPoint();//可用积分
@@ -406,6 +478,7 @@

            appUser.setAvailablePoint(availablePoint);
            appUser.setCancelPoint(cancelPoint);
            appUser.setTotalPoint(appUser.getTotalPoint() + order.getPoint());
            appUserClient.editAppUserById(appUser);
            //构建积分流水
            UserPoint userPoint = new UserPoint();
@@ -419,15 +492,6 @@
            userPointClient.saveUserPoint(userPoint);
        }

        BigDecimal paymentAmount = order.getPaymentAmount();
        if (BigDecimal.ZERO.compareTo(order.getPaymentAmount()) < 0) {//支付的金额是否大于0
            //微信退款
            RefundResult refund = PaymentUtil.refund(order.getOrderNumber(), "R" + order.getOrderNumber(), paymentAmount.doubleValue(), "/order/order/refundPayMoneyCallback");
            if (!"100".equals(refund.getRa_Status())) {
                return R.fail(refund.getRc_CodeMsg());//退款失败
            }
        }

        order.setRefundStatus(2);
        order.setRefundTime(LocalDateTime.now());

@@ -436,13 +500,20 @@
        goodsClient.editGoodsNum(orderGood.getGoodsId(), -1);
        //获取商品json
        Goods good = JSON.parseObject(orderGood.getGoodJson(), Goods.class);
        GoodsSeckill goodsSeckill = JSON.parseObject(orderGood.getSeckillJson(), GoodsSeckill.class);

        //门店减少冻结资金 即减少余额， 冻结资金=余额-可用资金
        Shop shop = shopClient.getShopById(order.getShopId()).getData();

        BigDecimal historicalBalance=shop.getBalance();//历史余额
        BigDecimal variableAmount=good.getSellingPrice();//变动金额
        BigDecimal balance=shop.getBalance().subtract(good.getSellingPrice());//变动后余额
        BigDecimal historicalBalance = shop.getBalance();//历史余额
        BigDecimal variableAmount = BigDecimal.ZERO;//变动金额
        if (null != goodsSeckill) {
            variableAmount = goodsSeckill.getSellingPrice();
        } else {
            variableAmount = good.getSellingPrice();
        }

        BigDecimal balance = shop.getBalance().subtract(variableAmount);//变动后余额

        shop.setBalance(balance);
        shopClient.updateShop(shop);
@@ -472,20 +543,92 @@
     * @return
     */
    @Override
    public R refundPayMoneyCallback(RefundCallbackResult refundCallbackResult) {
        String code = refundCallbackResult.getR3_RefundOrderNo().substring(1);
        Order order = this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNumber, code));
        if (null == order || order.getPayStatus() == 1 || order.getOrderStatus() == 6) {
    public R refundPayMoneyCallback(String xmlData) {

        RefundCallbackResult result = wechatPayService.processRefundCallback(xmlData);
        if (!result.isSuccess()) {
            return R.fail(result.getMsg());
        }

        Order order = this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNumber, result.getOrderNo()));
        if (null == order || order.getPayStatus() == 1 || order.getRefundStatus() == 2) {
            return R.ok();
        }
        order.setRefundCode(refundCallbackResult.getR5_RefundTrxNo());
//        order.setRefundCode(refundCallbackResult.getR5_RefundTrxNo());
        order.setRefundCode(result.getRefundNo());
        order.setRefundStatus(2);
        order.setRefundTime(LocalDateTime.now());
        this.updateById(order);

        //退款成功再回退积分
        AppUser appUser = appUserClient.getAppUserById(order.getAppUserId());
        if (order.getPoint() > 0) {
            if (null == appUser.getCancelPoint()) {
                appUser.setCancelPoint(0);
            }
            //返回订单抵扣积分
            Integer historicalPoint = appUser.getAvailablePoint();
            Integer availablePoint = appUser.getAvailablePoint() + order.getPoint();//可用积分
            Integer cancelPoint = appUser.getCancelPoint() + order.getPoint();//取消订单积分

            appUser.setAvailablePoint(availablePoint);
            appUser.setCancelPoint(cancelPoint);
            appUser.setTotalPoint(appUser.getTotalPoint() + order.getPoint());
            appUserClient.editAppUserById(appUser);
            //构建积分流水
            UserPoint userPoint = new UserPoint();
            userPoint.setType(16);//取消订单
            userPoint.setHistoricalPoint(historicalPoint);
            userPoint.setVariablePoint(order.getPoint());
            userPoint.setBalance(availablePoint);
            userPoint.setCreateTime(LocalDateTime.now());
            userPoint.setAppUserId(order.getAppUserId());
            userPoint.setObjectId(order.getId());
            userPointClient.saveUserPoint(userPoint);
        }

        order.setRefundStatus(2);
        order.setRefundTime(LocalDateTime.now());

        //商品销售数量
        OrderGood orderGood = orderGoodService.getOne(new LambdaQueryWrapper<OrderGood>().eq(OrderGood::getOrderId, order.getId()));
        goodsClient.editGoodsNum(orderGood.getGoodsId(), -1);
        //获取商品json
        Goods good = JSON.parseObject(orderGood.getGoodJson(), Goods.class);
        GoodsSeckill goodsSeckill = JSON.parseObject(orderGood.getSeckillJson(), GoodsSeckill.class);

        //门店减少冻结资金 即减少余额， 冻结资金=余额-可用资金
        Shop shop = shopClient.getShopById(order.getShopId()).getData();

        BigDecimal historicalBalance = shop.getBalance();//历史余额
        BigDecimal variableAmount = BigDecimal.ZERO;//变动金额
        if (null != goodsSeckill) {
            variableAmount = goodsSeckill.getSellingPrice();
        } else {
            variableAmount = good.getSellingPrice();
        }

        BigDecimal balance = shop.getBalance().subtract(variableAmount);//变动后余额

        shop.setBalance(balance);
        shopClient.updateShop(shop);

        //门店余额流水记录
        ShopBalanceStatement shopBalanceStatement = new ShopBalanceStatement();
        shopBalanceStatement.setShopId(shop.getId());
        shopBalanceStatement.setShopName(shop.getName());
        shopBalanceStatement.setShopManagerName(shop.getShopManager());
        shopBalanceStatement.setPhone(shop.getPhone());
        shopBalanceStatement.setType(6);//变更类型，订单退款
        shopBalanceStatement.setHistoricalBalance(historicalBalance);
        shopBalanceStatement.setVariableAmount(variableAmount);
        shopBalanceStatement.setCreateTime(LocalDateTime.now());
        shopBalanceStatement.setBalance(balance);
        shopBalanceStatement.setCreateUserId(appUser.getId());
        shopBalanceStatement.setObjectId(order.getId());
        shopBalanceStatementClient.saveShopBalanceStatement(shopBalanceStatement);
        return R.ok();
    }

    


    /**
@@ -532,6 +675,8 @@
        orderInfo.setOrderNumber(order.getOrderNumber());
        orderInfo.setOrderStatus(order.getOrderStatus());
        orderInfo.setCreateTime(order.getCreateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        orderInfo.setPointDeductionAmount(order.getPointDeductionAmount());

        AppUser appUser = appUserClient.getAppUserById(order.getAppUserId());
        if (null != appUser) {
            orderInfo.setUserName(appUser.getName());
@@ -548,19 +693,15 @@
        orderInfo.setPaymentAmount(order.getPaymentAmount());


        List<OrderGood> orderGoods = orderGoodMapper.selectList(new LambdaQueryWrapper<OrderGood>().eq(OrderGood::getOrderId, orderId).eq(OrderGood::getDelFlag, 0));
        int sum = orderGoods.stream().mapToInt(OrderGood::getNum).sum();
        orderInfo.setGoodsNum(sum);
        List<Object> goodsJson = new ArrayList<>();
        for (OrderGood orderGood : orderGoods) {
            Goods goods = JSON.parseObject(orderGood.getGoodJson(), Goods.class);
            Map<String, Object> map = new HashMap<>();
            map.put("name", goods.getName());
            map.put("imgUrl", goods.getHomePagePicture());
            map.put("number", orderGood.getNum());
            goodsJson.add(map);
        OrderGood orderGood = orderGoodMapper.selectOne(new LambdaQueryWrapper<OrderGood>().eq(OrderGood::getOrderId, orderId).eq(OrderGood::getDelFlag, 0));
        orderInfo.setGoodsNum(1);
        orderInfo.setGoodsJson(orderGood.getGoodJson());
        if (null != orderGood.getSeckillJson() && !"".equals(orderGood.getSeckillJson())) {
            orderInfo.setSeckillJson(orderGood.getSeckillJson());
            orderInfo.setActivityName("秒杀活动");
        }
        orderInfo.setGoodsJson(JSON.toJSONString(goodsJson));


        orderInfo.setPoint(order.getPoint());
        if (null != order.getAfterSaleTime()) {
            orderInfo.setAfterSaleTime(order.getAfterSaleTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
@@ -597,7 +738,7 @@
    public Integer getShopSaleNum(Integer shopId, Integer type) {
        return this.baseMapper.getShopSaleNum(shopId, type);
    }
    


    @Override
    public Integer getShopSaleNumByShopIds(List<Integer> shopIds, Integer type) {
@@ -613,14 +754,14 @@
     * 确认订单
     */
    @Override
    public ConfirmOrderVo confirmOrder(Integer goodId,Integer type) {
        ConfirmOrderVo confirmOrderVo=new ConfirmOrderVo();
    public ConfirmOrderVo confirmOrder(Integer goodId, Integer type) {
        ConfirmOrderVo confirmOrderVo = new ConfirmOrderVo();
        //用户信息
        Long userid = tokenService.getLoginUserApplet().getUserid();
        AppUser appUser = appUserClient.getAppUserById(userid);
        //获取商品信息
        Goods good = goodsClient.getGoodsById(goodId).getData();
        if (null == good||good.getDelFlag()==1||good.getStatus()==0) {
        if (null == good || good.getDelFlag() == 1 || good.getStatus() == 0) {
            //商品不存在
            throw new ServiceException("商品不存在");
        }
@@ -628,7 +769,7 @@

        GoodsShop shop = goodsShopClient.getGoodsShop(goodId).getData();
        System.out.println(shop);
        if (null == shop){
        if (null == shop) {
            //门店不存在
            throw new ServiceException("该商品门店不存在");
        }
@@ -652,42 +793,48 @@
        info.setGoodsId(goodId);
        GoodsSeckill goodsSeckill = seckillActivityInfoClient.getSeckillActivityInfo(info).getData();

        if (null != goodsSeckill){
        if (null != goodsSeckill) {
            SeckillActivityInfo activityInfo = seckillActivityInfoClient.getSeckillActivityInfoById(goodsSeckill.getSeckillActivityInfoId()).getData();
            //价格
            confirmOrderVo.setCash(goodsSeckill.getSellingPrice());//秒杀活动价格
            confirmOrderVo.setPoint(goodsSeckill.getIntegral());//秒杀活动积分价格
            confirmOrderVo.setPurchaseLimitNum(activityInfo.getMaxNum());//限购数量
            confirmOrderVo.setEndTimeStamp(activityInfo.getEndTime().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli());//结束时间戳
        }


        //判断是否是积分支付
        if (type == 1) {//现金
            confirmOrderVo.setOrderMoney(confirmOrderVo.getCash());
            Integer availablePoint = appUser.getAvailablePoint();//用户可用积分

            BigDecimal maxPointDeductionAmount = getCashByPoint(availablePoint);//最大可抵扣金额

            //计算积分抵扣的金额  将积分转为金额，去掉小数
            BigDecimal deduction=getCashByPoint(confirmOrderVo.getResidualPoint());
            //实际抵扣金额
            BigDecimal deduction = maxPointDeductionAmount.min(confirmOrderVo.getCash());
            confirmOrderVo.setDeduction(deduction);
        }else {//积分
            confirmOrderVo.setOrderPoint(good.getIntegral());
        } else {//积分
            confirmOrderVo.setOrderPoint(confirmOrderVo.getPoint());
        }
        //限购检查
        //判断当前数量是否已经超出限购数量（需要计算已经购买的数量）
        if(null == good.getPurchaseLimit() || -1 == good.getPurchaseLimit()){
        if (null == confirmOrderVo.getPurchaseLimitNum() || -1 == confirmOrderVo.getPurchaseLimitNum()) {
            confirmOrderVo.setIsPurchaseLimit(false);
            confirmOrderVo.setPurchaseLimitNum(-1);
        }else{
        } else {
            // 查当前用户的订单
            List<Order> orders = this.list(new LambdaQueryWrapper<Order>().eq(Order::getAppUserId, appUser.getId()).eq(Order::getDelFlag, 0).in(Order::getOrderStatus, Arrays.asList(4, 8)));
            List<Long> orderIds = orders.stream().map(Order::getId).collect(Collectors.toList());
            int sum = 0;
            if(!orderIds.isEmpty()){
            if (!orderIds.isEmpty()) {
                //关于该商品的订单
                List<OrderGood> orderGoodList = orderGoodService.list(new LambdaQueryWrapper<OrderGood>().in(OrderGood::getOrderId, orderIds)
                        .eq(OrderGood::getGoodsId, good.getId()).eq(OrderGood::getDelFlag, 0));
                sum = orderGoodList.stream().mapToInt(OrderGood::getNum).sum();
            }
            confirmOrderVo.setIsPurchaseLimit((1 + sum) > good.getPurchaseLimit());
            confirmOrderVo.setPurchaseLimitNum(good.getPurchaseLimit() - sum);
            confirmOrderVo.setPurchaseLimitNum(confirmOrderVo.getPurchaseLimitNum() - sum);
        }

        return confirmOrderVo;
@@ -700,13 +847,14 @@
    public R orderPayment(OrderPayment orderPayment) {
        Long userid = tokenService.getLoginUserApplet().getUserid();
        AppUser appUser = appUserClient.getAppUserById(userid);
        int type=1;//商品类型  1=普通商品，2=秒杀商品
        int type = 1;//商品类型  1=普通商品，2=秒杀商品
        //商品信息
        Goods goods = goodsClient.getGoodsById(orderPayment.getGoodId()).getData();
        if (null == goods || 1==goods.getDelFlag()){
            return  R.fail( "商品不存在");
        String goodsJson = JSON.toJSONString(goods);
        if (null == goods || 1 == goods.getDelFlag()) {
            return R.fail("商品不存在");
        }
        if(goods.getStatus() == 1){
        if (goods.getStatus() == 1) {
            return R.fail(goods.getName() + "商品已被下架");
        }

@@ -715,30 +863,30 @@
        info.setGoodsId(orderPayment.getGoodId());
        GoodsSeckill goodsSeckill = seckillActivityInfoClient.getSeckillActivityInfo(info).getData();

        if (null != goodsSeckill){
        if (null != goodsSeckill) {
            //秒杀商品
            type=2;
            type = 2;
            //判断当前数量是否已经超出限购数量（需要计算已经购买的数量）
            Integer goodsSaleNum = orderMapper.getGoodsSaleNum(orderPayment.getGoodId(), 2, userid);//已购买数量
            SeckillActivityInfo activityInfo = seckillActivityInfoClient.getSeckillActivityInfoById(goodsSeckill.getSeckillActivityInfoId()).getData();
            if(null != activityInfo.getMaxNum() && -1 != activityInfo.getMaxNum() && (goodsSaleNum + 1) > activityInfo.getMaxNum()){
            if (null != activityInfo.getMaxNum() && -1 != activityInfo.getMaxNum() && (goodsSaleNum + 1) > activityInfo.getMaxNum()) {
                return R.fail(goods.getName() + "已超出秒杀活动购买上限");
            }
            //价格
            goods.setSellingPrice(goodsSeckill.getSellingPrice());//秒杀活动价格
            goods.setIntegral(goodsSeckill.getIntegral());//秒杀活动积分价格
        }else {
        } else {
            //普通商品
            //判断当前数量是否已经超出限购数量（需要计算已经购买的数量）
            Integer goodsSaleNum = orderMapper.getGoodsSaleNum(orderPayment.getGoodId(), 1, userid);//已购买数量
            //普通商品
            if(null != goods.getPurchaseLimit() && -1 != goods.getPurchaseLimit() && (goodsSaleNum + 1) > goods.getPurchaseLimit()){
            if (null != goods.getPurchaseLimit() && -1 != goods.getPurchaseLimit() && (goodsSaleNum + 1) > goods.getPurchaseLimit()) {
                return R.fail(goods.getName() + "已超出购买上限");
            }
        }

        //判断支付方式是否正确
        if(1 != orderPayment.getPaymentType() && 3 != orderPayment.getPaymentType()){
        if (1 != orderPayment.getPaymentType() && 3 != orderPayment.getPaymentType()) {
            return R.fail("支付方式不正确");
        }

@@ -752,28 +900,29 @@
        //积分抵扣金额
        BigDecimal pointDeductionAmount = BigDecimal.ZERO;

        if(3 != orderPayment.getPaymentType()){
        if (3 != orderPayment.getPaymentType()) {
            //现金支付
            orderMoney = goods.getSellingPrice();
            paymentMoney=orderMoney.setScale(2, RoundingMode.HALF_EVEN);;
            paymentMoney = orderMoney.setScale(2, RoundingMode.HALF_EVEN);
            ;

            //是否使用积分抵扣
            if (orderPayment.getIsPointDeduction() == 1) {
                //积分抵扣金额
                Integer availablePoint = appUser.getAvailablePoint();//用户可用积分
                BigDecimal maxPointDeductionAmount = getCashByPoint(availablePoint);//最大可抵扣金额
                pointDeductionAmount=maxPointDeductionAmount.min(orderMoney);//实际抵扣金额
                pointDeductionAmount = maxPointDeductionAmount.min(orderMoney);//实际抵扣金额
                // 计算实际支付金额
                paymentMoney = orderMoney.subtract(pointDeductionAmount).setScale(2, RoundingMode.HALF_EVEN);
                //计算消耗积分
                orderPoint=getPoint(pointDeductionAmount);
                orderPoint = getPoint(pointDeductionAmount);
            }
        }else{
        } else {
            //积分支付
            orderPoint=goods.getIntegral();
            orderPoint = goods.getIntegral();
            orderMoney = goods.getSellingPrice();
            Integer availablePoint = appUser.getAvailablePoint();//用户可用积分
            if(availablePoint.compareTo(orderPoint) < 0){
            if (availablePoint.compareTo(orderPoint) < 0) {
                return R.fail("账户可用积分不足");
            }
        }
@@ -783,20 +932,25 @@
        order.setNum(1);
        order.setGoodPics(goods.getHomePagePicture());
        order.setGoodName(goods.getName());
        order.setOrderStatus( 3 );//待使用
        order.setOrderStatus(3);//待使用
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
        order.setOrderNumber("QJS" + getNumber(3) + sdf.format(new Date()));
        order.setTotalAmount(orderMoney.setScale(2, RoundingMode.HALF_EVEN));//订单总金额
        order.setPointDeductionAmount(pointDeductionAmount.setScale(2, RoundingMode.HALF_EVEN));
        order.setPaymentAmount(paymentMoney);//实际支付价格
        order.setPoint(orderPoint);//使用积分
        order.setPayMethod(orderPayment.getPaymentType());//支付方式
        if (orderPayment.getPaymentType() == 1 && orderPoint > 0) {//微信支付 但支付的积分也大于0
            order.setPayMethod(4);//组合支付
        } else {
            order.setPayMethod(orderPayment.getPaymentType());//积分或者微信
        }
        order.setPayStatus(1);
        order.setShopId(orderPayment.getShopId());
        order.setDelFlag(0);
        order.setCreateTime(LocalDateTime.now());

        orderMapper.insert(order);
        this.save(order);


        //构建订单明细数据
        OrderGood orderGood = new OrderGood();
@@ -804,31 +958,39 @@
        orderGood.setOrderId(order.getId());
        orderGood.setNum(1);
        orderGood.setType(type);
        if (2==type){
        if (2 == type) {
            orderGood.setSeckillJson(JSON.toJSONString(goodsSeckill));
        }
        orderGood.setGoodJson(JSON.toJSONString(goods));
        orderGood.setGoodJson(goodsJson);
        orderGood.setDelFlag(0);
        orderGood.setCreateTime(LocalDateTime.now());
        orderGood.setCashPayment(orderPayment.getPaymentType()==1 ? 1 : 0);
        orderGood.setPointPayment(orderPayment.getPaymentType()==3 ? 1 : 0);
        orderGood.setCashPayment(orderPayment.getPaymentType() == 1 ? 1 : 0);
        orderGood.setPointPayment(orderPayment.getPaymentType() == 3 ? 1 : 0);
        orderGood.setSellingPrice(goods.getSellingPrice());
        orderGood.setIntegral(goods.getIntegral());
        orderGoodService.save(orderGood);

        //开始构建支付信息
        if(BigDecimal.ZERO.compareTo(paymentMoney) > 0){
        if (BigDecimal.ZERO.compareTo(paymentMoney) > 0) {
            paymentMoney = BigDecimal.ZERO;
        }
        //判断积分是否为零，积分支付
        if (0 != order.getPoint()){
        if (0 != order.getPoint()) {
            if (null == appUser.getAvailablePoint()) {
                appUser.setAvailablePoint(0);
            }
            if (null == appUser.getExchangePoint()) {
                appUser.setExchangePoint(0);
            }

            //积分支付
            Integer historicalPoint = appUser.getAvailablePoint();//历史积分
            Integer availablePoint = historicalPoint - orderPoint;//可用积分
            Integer exchangePoint = appUser.getExchangePoint() + orderPoint;//兑换商品消费积分
            //扣减订单支付积分
            appUser.setAvailablePoint(availablePoint);
            appUser.setExchangePoint(exchangePoint );
            appUser.setExchangePoint(exchangePoint);
            appUser.setTotalPoint(appUser.getTotalPoint() + order.getPoint());//总积分
            //构建积分流水记录
            UserPoint userPoint = new UserPoint();
            userPoint.setType(4);//兑换商品
@@ -847,21 +1009,57 @@

        }
        //判断需要支付的金额是否大于0
        if ( BigDecimal.ZERO.compareTo(paymentMoney) < 0){
        if (BigDecimal.ZERO.compareTo(paymentMoney) < 0) {
            //调起微信支付
            String goodsNames = goods.getName();
            UniPayResult uniPayResult = PaymentUtil.uniPay(order.getOrderNumber(), paymentMoney.doubleValue(),  "购买单品商品",
                    goodsNames, "", "/order/order/orderPaymentCallback", appUser.getWxOpenid(), null);
            if(null == uniPayResult || !"100".equals(uniPayResult.getRa_Code())){
                return R.fail(null == uniPayResult ? "支付失败" : uniPayResult.getRb_CodeMsg());
            try {
                R r = wechatPayService.unifiedOrder(order.getId().toString(), order.getOrderNumber(), paymentMoney.toString(), "购买单品商品", appUser.getWxOpenid(), "/order/order/orderPaymentCallback");
                if (null == r || 200 != r.getCode()) {
                    //支付失败，积分回退 ，删除订单
                    //检查是否先有过积分抵扣了，是的话要返回订单已抵扣的积分，以及用户积分流水的删除
                    if (order.getPoint() > 0) {
                        //返回订单抵扣积分
                        AppUser appUser2 = appUserClient.getAppUserById(order.getAppUserId());
                        Integer availablePoint = appUser2.getAvailablePoint();//可用积分
                        Integer variablePoint = order.getPoint();//变动积分
                        Integer balance = appUser2.getAvailablePoint() + order.getPoint();//变动后积分
                        Integer cancelPoint = appUser2.getCancelPoint() + order.getPoint();//取消订单积分
                        appUser2.setAvailablePoint(availablePoint);
                        appUser2.setCancelPoint(cancelPoint);
                        appUser2.setTotalPoint(appUser2.getTotalPoint() + order.getPoint());

                        //构建积分流水记录
                        UserPoint userPoint = new UserPoint();
                        userPoint.setType(16);//取消订单
                        userPoint.setHistoricalPoint(availablePoint);
                        userPoint.setVariablePoint(variablePoint);
                        userPoint.setBalance(balance);
                        userPoint.setCreateTime(LocalDateTime.now());
                        userPoint.setAppUserId(appUser2.getId());
                        userPoint.setObjectId(order.getId());
                        userPointClient.saveUserPoint(userPoint);

                        appUserClient.editAppUserById(appUser2);


                    }
                    //删除订单
                    order.setDelFlag(1);
                    orderMapper.updateById(order);
                    //返回报错信息
                    return R.fail(null == r ? "支付失败" : r.getMsg());
                }
            /*if(null == uniPayResult || !"100".equals(uniPayResult.getRa_Code())){

            }*/
                //将支付数据添加到redis队列中，便于定时任务去校验是否完成支付，没有完成支付支付，15分钟后关闭订单。
                long second = LocalDateTime.now().plusMinutes(15).toEpochSecond(ZoneOffset.UTC);
                redisTemplate.opsForZSet().add("OrderPayment", order.getId(), second);
                return r;
            } catch (Exception e) {
                e.printStackTrace();
            }
            String rc_result = uniPayResult.getRc_Result();
            JSONObject jsonObject = JSON.parseObject(rc_result);
            jsonObject.put("orderId", order.getId().toString());
            //将支付数据添加到redis队列中，便于定时任务去校验是否完成支付，没有完成支付支付，15分钟后关闭订单。
            long second = LocalDateTime.now().plusMinutes(15).toEpochSecond(ZoneOffset.UTC);
            redisTemplate.opsForZSet().add("OrderPayment", order.getOrderNumber(), second);
            return R.ok(jsonObject.toJSONString());


        }

@@ -873,12 +1071,16 @@

        //门店增加冻结资金 即增加余额， 冻结资金=余额-可用资金
        Shop shop = shopClient.getShopById(order.getShopId()).getData();
        BigDecimal historicalBalance=shop.getBalance();//历史余额
        BigDecimal variableAmount=goods.getSellingPrice();//变动金额
        BigDecimal balance=shop.getBalance().add(goods.getSellingPrice());//变动后余额
        if (null == shop.getBalance()) {
            shop.setBalance(BigDecimal.ZERO);
        }

        BigDecimal historicalBalance = shop.getBalance();//历史余额
        BigDecimal variableAmount = goods.getSellingPrice();//变动金额
        BigDecimal balance = shop.getBalance().add(goods.getSellingPrice());//变动后余额

        shop.setBalance(balance);
        shop.setOrderNumber(shop.getOrderNumber()+1);
        shop.setOrderNumber(shop.getOrderNumber() + 1);
        shopClient.updateShop(shop);

        //门店余额流水记录
@@ -895,16 +1097,19 @@
        shopBalanceStatement.setCreateUserId(appUser.getId());
        shopBalanceStatement.setObjectId(order.getId());
        shopBalanceStatementClient.saveShopBalanceStatement(shopBalanceStatement);
        Map<String, String> payParams = new HashMap<>();
//        payParams.put("payMethod","3");//给前端标识 3-不需要调微信支付
//        payParams.put("orderId",order.getId().toString());
        return R.ok(order.getId().toString());
    }

    /**
     * 订单支付回调通知
     * 订单支付回调 处理业务逻辑
     */
    @Override
    public R orderPaymentCallback(UniPayCallbackResult uniPayCallbackResult) {
        Order order = orderMapper.selectOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNumber, uniPayCallbackResult.getR2_OrderNo()));
        if(null == order || order.getPayStatus() == 2){
    public R orderPaymentCallback(PayResult payResult) {
        Order order = orderMapper.selectOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNumber, payResult.getOrderNumber()));
        if (null == order || order.getPayStatus() == 2) {
            return R.ok();
        }

@@ -919,7 +1124,7 @@
        order.setPayStatus(2);
        //待使用
        order.setOrderStatus(3);
        String r7TrxNo = uniPayCallbackResult.getR9_BankTrxNo();
        String r7TrxNo = payResult.getTransactionId();
        order.setSerialNumber(r7TrxNo);
        orderMapper.updateById(order);

@@ -927,15 +1132,20 @@
        //商品销量增加
        goodsClient.editGoodsNum(orderGood.getGoodsId(), 1);
        Goods goods = JSON.parseObject(orderGood.getGoodJson(), Goods.class);

        GoodsSeckill goodsSeckill = JSON.parseObject(orderGood.getSeckillJson(), GoodsSeckill.class);
        //门店增加冻结资金 即增加金额， 冻结资金=余额-可用资金
        Shop shop = shopClient.getShopById(order.getShopId()).getData();
        BigDecimal historicalBalance=shop.getBalance();//历史余额
        BigDecimal variableAmount=goods.getSellingPrice();//变动余额
        BigDecimal balance=shop.getBalance().add(variableAmount);//变动后余额
        BigDecimal historicalBalance = shop.getBalance();//历史余额
        BigDecimal variableAmount = BigDecimal.ZERO;//变动金额
        if (null != goodsSeckill) {
            variableAmount = goodsSeckill.getSellingPrice();
        } else {
            variableAmount = goods.getSellingPrice();
        }
        BigDecimal balance = shop.getBalance().add(variableAmount);//变动后余额

        shop.setBalance(balance);
        shop.setOrderNumber(shop.getOrderNumber()+1);
        shop.setOrderNumber(shop.getOrderNumber() + 1);
        shopClient.updateShop(shop);

        //门店金额变动记录
@@ -964,23 +1174,22 @@
        //订单支付数据
        long second = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC);
        Set<String> orderPayment = redisTemplate.opsForZSet().rangeByScore("OrderPayment", 0, second);
        if(orderPayment.size() > 0){
            List<Order> list = orderMapper.selectList(new LambdaQueryWrapper<Order>().in(Order::getOrderNumber, orderPayment));
        if (orderPayment.size() > 0) {
            List<Order> list = orderMapper.selectList(new LambdaQueryWrapper<Order>().in(Order::getId, orderPayment));
            for (Order order : list) {
                if(null == order || order.getPayStatus() != 1){
                if (null == order || order.getPayStatus() != 1) {
                    redisTemplate.opsForZSet().remove("OrderPayment", order.getOrderNumber());
                    continue;
                }
                //开始执行关闭订单操作
                CloseOrderResult closeOrderResult = PaymentUtil.closeOrder(order.getOrderNumber());
                if((null == closeOrderResult || !closeOrderResult.getRa_Status().equals("100")) &&
                        Arrays.asList("0", "4", "101", "10080000", "10080002", "10083004", "10083005").contains(closeOrderResult.getRb_Code())){
                Map<String, String> map = wechatPayService.closeOrder(order.getOrderNumber());
                if ((null == map || !map.get("return_code").equals("SUCCESS"))) {
                    redisTemplate.opsForZSet().add("OrderPayment", order.getOrderNumber(), 0);
                    log.error("关闭订单失败：{}---->{}", order.getOrderNumber(), JSON.toJSONString(closeOrderResult));
                    log.error("关闭订单失败：{}---->{}", order.getOrderNumber(), map.get("return_msg"));
                }
                redisTemplate.opsForZSet().remove("OrderPayment", order.getOrderNumber());
                //关闭订单后，检查是否先有过积分抵扣了，是的话要返回订单已抵扣的积分，以及用户积分流水的删除
                if (order.getPoint()>0) {
                //关闭订单后，检查是否先有过积分抵扣了，是的话要返回订单已抵扣的积分，以及用户积分流水的删除， 删除订单
                if (order.getPoint() > 0) {
                    //返回订单抵扣积分
                    AppUser appUser = appUserClient.getAppUserById(order.getAppUserId());
                    Integer availablePoint = appUser.getAvailablePoint();//可用积分
@@ -989,6 +1198,7 @@
                    Integer cancelPoint = appUser.getCancelPoint() + order.getPoint();//取消订单积分
                    appUser.setAvailablePoint(availablePoint);
                    appUser.setCancelPoint(cancelPoint);
                    appUser.setTotalPoint(appUser.getTotalPoint() + order.getPoint());

                    //构建积分流水记录
                    UserPoint userPoint = new UserPoint();
@@ -1002,6 +1212,10 @@
                    userPointClient.saveUserPoint(userPoint);

                    appUserClient.editAppUserById(appUser);

                    //删除订单
                    order.setDelFlag(1);
                    orderMapper.updateById(order);
                }
            }
        }
@@ -1014,23 +1228,38 @@
        Page<Order> page = new Page<>(pageNum, pageSize);
        // 构建查询条件
        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
        //添加基础条件
        queryWrapper.eq("del_flag", 0);
        queryWrapper.eq("pay_status", 2);
        queryWrapper.orderByDesc("create_time");
        // 添加门店ID条件
        if (shopId != null) {
            queryWrapper.eq("shop_id", shopId);
        }
        // 添加订单状态条件
        if (status != null) {
        if (status != null && status == 4) { //4-已完成 8-已评价
            queryWrapper.in("order_status", Arrays.asList(4, 8));
        }
        if (status != null && status != 4) {//3-待核销 5-已取消
            queryWrapper.eq("order_status", status);
        }
        // 模糊查询条件
        if (StringUtils.isNotBlank(content)) {
            //根据手机号查询用户id
            List<Long> ids = new ArrayList<>();
            List<AppUser> data = appUserClient.getAppUserByPhone(content).getData();
            if (data != null && !data.isEmpty()) {
                ids = data.stream().map(AppUser::getId).collect(Collectors.toList());
            }
            // 构建OR条件组：订单编号/商品名/手机号
            if (null != ids && !ids.isEmpty()) {
                queryWrapper.in("app_user_id", ids);
            }

            queryWrapper.and(wrapper -> wrapper
                    .like("order_number", content)  // 订单编号
                    .or()
                    .like("goods_name", content)  // 商品名
                    .or()
                    .inSql("app_user_id", "select id from t_app_user where phone like '%" + content + "%'")  // 手机号
                    .like("good_name", content)  // 商品名
            );
        }

@@ -1050,6 +1279,7 @@
            return R.fail("订单取消失败");
        }
        order.setOrderStatus(5);
        order.setEndTime(LocalDateTime.now());
        R r = refundPayMoney(order);
        if (200 == r.getCode()) {
            this.updateById(order);
@@ -1057,21 +1287,288 @@
        return r;
    }

    /**
     * 后台-工作台-折线图
     *
     * @param startTime
     * @param endTime
     * @return
     */
    @Override
    public List<OrderStatisticsDetail> getOrderListGroupByDate(LocalDate startTime, LocalDate endTime, Integer shopId) {
        // 查询数据库获取原始数据
        List<OrderStatisticsDetail> rawData = orderMapper.getOrderListGroupByDate(
                startTime.atTime(0, 0, 0),
                endTime.atTime(23, 59, 59),
                shopId
        );

        // 创建完整日期范围的映射
        Map<LocalDate, OrderStatisticsDetail> dateMap = rawData.stream()
                .collect(Collectors.toMap(
                        OrderStatisticsDetail::getDateTime,
                        Function.identity()
                ));

        // 生成完整日期序列并填充缺失数据
        List<OrderStatisticsDetail> completeList = new ArrayList<>();
        for (LocalDate date = startTime; !date.isAfter(endTime); date = date.plusDays(1)) {
            if (dateMap.containsKey(date)) {
                completeList.add(dateMap.get(date));
            } else {
                completeList.add(new OrderStatisticsDetail(date, 0, BigDecimal.ZERO));
            }
        }
        return completeList;
    }

    @Override
    public R importExpress(MultipartFile file) {
        List<Shop> shops = shopClient.getAllShop().getData();
        List<Goods> goods = goodsClient.getAllGoods().getData();
        List<Order> orderList = new ArrayList<>();
        List<String> orderNumberList = new ArrayList<>();
        List<OrderGood> orderGoodsList = new ArrayList<>();
        cn.hutool.json.JSONObject result = new cn.hutool.json.JSONObject();
        try (InputStream inputStream = file.getInputStream();
             Workbook workbook = new XSSFWorkbook(inputStream)) {
//            Workbook workbook = new XSSFWorkbook(fileInputStream);
            Sheet sheet = workbook.getSheetAt(0); // 获取第一个Sheet
            int lastRowNum = sheet.getLastRowNum();
            for (int i = 1; i <= lastRowNum; i++) {//第二行开始
                Row row = sheet.getRow(i);
                // 订单状态
                if (row.getCell(0) == null) {
                    throw new ServiceException("第" + i + "行订单状态为空", 500);
                }
                row.getCell(0).setCellType(CellType.STRING);
                String orderStatus = row.getCell(0).getStringCellValue();

                // 订单编号
                if (row.getCell(1) == null) {
                    throw new ServiceException("第" + i + "行订单编号为空", 500);
                }
                row.getCell(1).setCellType(CellType.STRING);
                String orderNum = row.getCell(1).getStringCellValue();

                // 订单类型
                if (row.getCell(2) == null) {
                    throw new ServiceException("第" + i + "行订单类型为空", 500);
                }
                row.getCell(2).setCellType(CellType.STRING);
                String orderType = row.getCell(2).getStringCellValue();

                // 下单时间
                Cell beginTimeCell = row.getCell(3);
                if (beginTimeCell == null) {
                    throw new ServiceException("第" + (i + 1) + "行下单时间为空", 500);
                }
                LocalDateTime beginTime;
                if (beginTimeCell.getCellType() == CellType.NUMERIC || DateUtil.isCellDateFormatted(beginTimeCell)) {
                    // 处理数值型日期（包括Excel内置日期格式）
                    beginTime = beginTimeCell.getDateCellValue().toInstant()
                            .atZone(ZoneId.systemDefault())
                            .toLocalDateTime();
                } else {
                    // 处理文本型日期（如 "2025/4/3 23:25:38"）
                    String dateStr = beginTimeCell.getStringCellValue().trim();
                    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/M/d H:mm:ss");
                    beginTime = LocalDateTime.parse(dateStr, formatter);
                }


                // 下单用户
                if (row.getCell(4) == null) {
                    throw new ServiceException("第" + i + "行下单用户为空", 500);
                }
                row.getCell(4).setCellType(CellType.STRING);
                String userName = row.getCell(4).getStringCellValue();

                // 联系电话
                if (row.getCell(5) == null) {
                    throw new ServiceException("第" + i + "行联系方式为空", 500);
                }
                row.getCell(5).setCellType(CellType.STRING);
                String phone = row.getCell(5).getStringCellValue();

                // 商品名称
                if (row.getCell(6) == null) {
                    throw new ServiceException("第" + i + "行商品名称为空", 500);
                }
                row.getCell(6).setCellType(CellType.STRING);
                String goodsName = row.getCell(6).getStringCellValue();

                // 店铺名称
                if (row.getCell(7) == null) {
                    throw new ServiceException("第" + i + "行店铺名称为空", 500);
                }
                row.getCell(7).setCellType(CellType.STRING);
                String shopName = row.getCell(7).getStringCellValue();

                // 商品售价
                if (row.getCell(8) == null) {
                    throw new ServiceException("第" + i + "行商品售价为空", 500);
                }
                row.getCell(8).setCellType(CellType.STRING);
                String sellingPrice = row.getCell(8).getStringCellValue();

                // 支付方式
                if (row.getCell(9) == null) {
                    throw new ServiceException("第" + i + "行支付方式为空", 500);
                }
                row.getCell(9).setCellType(CellType.STRING);
                String payType = row.getCell(9).getStringCellValue();
                // 支付积分
                String pointPayment;
                if (row.getCell(10) == null) {
                    pointPayment="0";
                }else{
                    row.getCell(10).setCellType(CellType.STRING);
                    pointPayment = row.getCell(10).getStringCellValue();
                }

                // 支付金额
                String cashPayment;
                if (row.getCell(11) == null) {
                    cashPayment = "0";
                }else{
                    row.getCell(11).setCellType(CellType.STRING);
                    cashPayment = row.getCell(11).getStringCellValue();
                }


                //数据库中是否存在
                Order order = this.getOne(new LambdaQueryWrapper<Order>()
                        .eq(Order::getOrderNumber, orderNum)
                );
                if (order != null) {
//                    throw new ServiceException("数据库中订单已存在：" + orderNum, 500);
                    result.append("订单号：[", orderNum + "]数据库中订单已存在");
                    continue;
                }
                AppUser appuser = appUserClient.getAppUserByPhone1(phone).getData();
                if (null == appuser) {
                    //创建用户
                    appuser = new AppUser();
                    appuser.setPhone(phone);
                    appuser.setStatus(1);
                    appuser.setAvatar(DEFAULT_AVATAR_URL);
                    appuser.setCreateTime(LocalDateTime.now());
                    appuser.setDelFlag(false);
                    appuser.setName(appuser.getPhone().substring(0, 3) + "****" + appuser.getPhone().substring(7));
                    appuser.setRechargePoint(0);
                    appuser.setAvailablePoint(0);
                    appuser.setTotalPoint(0);
                    Long userId = appUserClient.saveOrUpdateAppUser(appuser);
                    appuser.setId(userId);
                }
                if (!orderNumberList.contains(orderNum)){
                    orderNumberList.add(orderNum);
                    Order order1 = new Order();
                    order1.setAppUserId(appuser.getId());
                    switch (orderStatus){
                        case "待使用":
                            order1.setOrderStatus(3);
                            order1.setOldOrderStatus(3);
                            break;
                        case "已完成":
                            order1.setOrderStatus(4);
                            order1.setOldOrderStatus(4);
                            break;
                        case "已取消":
                            order1.setOrderStatus(5);
                            order1.setOldOrderStatus(5);
                            break;
                        case "已评价":
                            order1.setOrderStatus(8);
                            order1.setOldOrderStatus(8);
                            break;
                    }
                    order1.setOrderNumber(orderNum);

                    order1.setPayStatus(2);
                    Shop shop = shops.stream().filter(e -> e.getName().equals(shopName)).findFirst().orElse(null);
                    if (shop!=null){
                        order1.setShopId(shop.getId());
                    }
                    order1.setDelFlag(0);
                    order1.setCreateTime(LocalDateTime.now());
                    orderList.add(order1);//添加到订单集合中
                }

                OrderGood orderGood = new OrderGood();
                Shop shop = shops.stream().filter(e -> e.getName().equals(shopName)).findFirst().orElse(null);
                if (shop!=null){
                    Goods goods1 = goods.stream().filter(e -> e.getName().equals(goodsName)
                    && e.getShopId().equals(shop.getId())).findFirst().orElse(null);
                    if(goods1!=null){
                        orderGood.setGoodsId(goods1.getId());
                        orderGood.setSellingPrice(goods1.getSellingPrice());
                        orderGood.setIntegral(goods1.getIntegral());
                    }
                }
                orderGood.setDelFlag(0);
                orderGood.setCreateTime(LocalDateTime.now());
                orderGood.setCashPayment(cashPayment.equals("0")?0:1);
                orderGood.setPointPayment(pointPayment.equals("0")?0:1);
                orderGood.setCashPaymentValue(new BigDecimal(cashPayment));
                orderGood.setPointPaymentValue(Integer.parseInt(pointPayment));
                orderGood.setOrderNumber(orderNum);
                orderGoodsList.add(orderGood);

            }


            // 新增数据
            for (Order order : orderList) {
                List<OrderGood> orderGoods = orderGoodsList.stream().filter(e -> e.getOrderNumber().equals(order.getOrderNumber())).collect(Collectors.toList());
                BigDecimal totalAmount = orderGoods.stream().map(OrderGood::getCashPaymentValue).reduce(BigDecimal::add).get();
                Integer totalIntegral = orderGoods.stream().map(OrderGood::getIntegral).reduce(Integer::sum).get();
                order.setNum(orderGoods.size());
                order.setTotalAmount(totalAmount);
                order.setPaymentAmount(totalAmount);
                order.setPoint(totalIntegral);
                if (totalAmount.compareTo(BigDecimal.ZERO)!=0&&totalIntegral!=0){
                    order.setPayMethod(4);
                }else if (totalAmount.compareTo(BigDecimal.ZERO)!=0){
                    order.setPayMethod(1);
                }else if (totalIntegral!=0){
                    order.setPayMethod(3);
                }
                this.save(order);
                for (OrderGood orderGood : orderGoods) {
                    orderGood.setOrderId(order.getId());
                }
                orderGoodService.saveBatch(orderGoods);
            }
        } catch (IOException e) {
            e.printStackTrace();
            throw new ServiceException(e.getMessage());
        }
        if (!result.isEmpty()) {
            return R.ok(result);
        }
        return R.ok();
    }

    private static final String DEFAULT_AVATAR_URL = "http://qijishenghuiyuan.obs.cn-southwest-2.myhuaweicloud.com/admin/58084a0ce8c34dc79f9d8b4c0bc3774a.png";


    private OrderPageListVo convertToOrderListVo(Order order) {
        OrderPageListVo vo = new OrderPageListVo();
        // 复制属性
        BeanUtils.copyProperties(order, vo);

        // 查询用户信息
        AppUser user = appUserClient.getAppUserById(order.getAppUserId());
        if (user != null) {
            vo.setPhone(user.getPhone());
        }
        vo.setIdStr(order.getId().toString());
        return vo;
    }


    public String getNumber(Integer size){
    public String getNumber(Integer size) {
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < size; i++) {
            str.append(Double.valueOf(Math.random() * 10).intValue());
@@ -1082,7 +1579,7 @@
    /**
     * 获取现金对应积分
     */
    public Integer getPoint(BigDecimal cash){
    public Integer getPoint(BigDecimal cash) {
        if (cash == null || cash.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("金额不能为null或负数");
        }
@@ -1116,7 +1613,7 @@
    /**
     * 获取积分对应金额
     */
    public BigDecimal getCashByPoint(Integer point){
    public BigDecimal getCashByPoint(Integer point) {
        // 参数校验
        if (point == null || point < 0) {
            throw new IllegalArgumentException("积分值不能为null或负数");