后台：首页统计、系统管理、广告管理、用户管理、商品分类管理

huliguo

2025-04-17 19df67e19f23cd2a04d1c7f355e1e656f4140af4

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

@@ -1,40 +1,38 @@
package com.ruoyi.order.service.impl;

import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpUtil;
import cn.hutool.json.JSONUtil;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;

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.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.account.api.feignClient.*;
import com.ruoyi.account.api.model.*;
import com.ruoyi.account.api.vo.CouponInfoVo;
import com.ruoyi.account.api.vo.PaymentUserCoupon;
import com.ruoyi.account.api.vo.PaymentUserCouponVo;

import com.ruoyi.common.core.constant.ExpressCompanyMap;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.utils.HttpUtils;

import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.core.utils.bean.BeanUtils;
import com.ruoyi.common.core.utils.uuid.QRCodeGenerator;
import com.ruoyi.common.core.web.page.PageInfo;
import com.ruoyi.common.security.service.TokenService;
import com.ruoyi.order.enums.OrderStatus;
import com.ruoyi.order.event.ConfirmDeliveryEvent;

import com.ruoyi.order.mapper.OrderGoodMapper;
import com.ruoyi.order.mapper.OrderMapper;
import com.ruoyi.order.model.Order;
import com.ruoyi.order.model.OrderGood;
import com.ruoyi.order.service.OrderGoodService;
import com.ruoyi.order.service.OrderService;
import com.ruoyi.order.util.ExpressDeliveryUtil;

import com.ruoyi.order.util.payment.PaymentUtil;
import com.ruoyi.order.util.payment.model.RefundCallbackResult;
import com.ruoyi.order.util.payment.model.RefundResult;
import com.ruoyi.order.util.vo.MapTrackKD100Vo;
import com.ruoyi.order.util.vo.QueryKD100ListVo;
import com.ruoyi.order.util.payment.model.*;

import com.ruoyi.order.vo.*;
import com.ruoyi.other.api.domain.*;
import com.ruoyi.other.api.feignClient.*;
@@ -44,33 +42,26 @@
import com.ruoyi.system.api.feignClient.SysConfigClient;
import com.ruoyi.system.api.feignClient.SysUserClient;
import com.ruoyi.system.api.model.LoginUser;
import lombok.SneakyThrows;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.jetbrains.annotations.Nullable;

import lombok.extern.slf4j.Slf4j;

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 java.io.IOException;
import java.io.InputStream;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.net.MalformedURLException;
import java.net.URL;
import java.time.LocalDateTime;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;

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

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

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

@@ -82,6 +73,7 @@
 * @author luodangjia
 * @since 2024-11-21
 */
@Slf4j
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
    @Resource
@@ -112,7 +104,16 @@
    private OrderGoodService orderGoodService;

    @Resource
    private UserPointClient userPointClient;

    @Resource
    private RedisTemplate redisTemplate;

    @Resource
    private  ShopBalanceStatementClient shopBalanceStatementClient;

    @Resource
    private GoodsEvaluateClient goodsEvaluateClient;

    @Resource
    private SystemConfigClient systemConfigClient;
@@ -141,57 +142,44 @@
        }

        // 商品
        List<OrderGood> orderGoods = orderGoodMapper.selectList(new LambdaQueryWrapper<OrderGood>()
                .eq(OrderGood::getOrderId, orderId));
        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);

        List<OrderGoodsVO> goodsList = new ArrayList<>();
        for (OrderGood orderGood : orderGoods) {
            String goodJson = orderGood.getGoodJson();
            Goods goods = JSONObject.parseObject(goodJson, Goods.class);
            OrderGoodsVO orderGoodsVO = new OrderGoodsVO();
            orderGoodsVO.setGoodsId(orderGood.getGoodsId());
            orderGoodsVO.setNum(orderGood.getNum());
            orderGoodsVO.setGoodsName(goods.getName());
            orderGoodsVO.setType(goods.getType());
            orderGoodsVO.setGoodsPic(goods.getHomePagePicture());
            orderGoodsVO.setSellingPrice(orderGood.getSellingPrice());
            orderGoodsVO.setIntegral(orderGood.getIntegral());
            orderGoodsVO.setOriginalPrice(goods.getOriginalPrice());
            goodsList.add(orderGoodsVO);
        OrderGoodsVO orderGoodsVO = new OrderGoodsVO();
        orderGoodsVO.setGoodsId(goods.getId());
        orderGoodsVO.setGoodsName(goods.getName());
        orderGoodsVO.setGoodsPic(goods.getHomePagePicture());
        orderGoodsVO.setNum(order.getNum());
        if (null!=goodsSeckill){
            orderGoodsVO.setSellingPrice(goodsSeckill.getSellingPrice());
            orderGoodsVO.setIntegral(goodsSeckill.getIntegral());
        }else {
            orderGoodsVO.setSellingPrice(goods.getSellingPrice());
            orderGoodsVO.setIntegral(goods.getIntegral());
        }
        // 优惠券
        String couponJson = order.getCouponJson();
        JSONObject jsonObject = new JSONObject();
        if (StringUtils.isNotEmpty(couponJson)) {
            jsonObject = JSONObject.parseObject(couponJson);
        }


        orderGoodsVO.setOriginalPrice(goods.getOriginalPrice());

        OrderDetailVO orderDetailVO = new OrderDetailVO();
        orderDetailVO.setDistributionMode(order.getDistributionMode());
        orderDetailVO.setOrderGoodsVO(orderGoodsVO);
        Shop shop = shopR.getData();

        orderDetailVO.setId(order.getId());
        orderDetailVO.setOrderStatus(order.getOrderStatus());
        orderDetailVO.setPoint(order.getPoint());
        orderDetailVO.setPoint(order.getPoint());//使用的积分
        orderDetailVO.setOrderNumber(order.getOrderNumber());
        orderDetailVO.setCreateTime(order.getCreateTime());
        orderDetailVO.setTotalAmount(order.getTotalAmount());
        orderDetailVO.setCouponName(jsonObject.getString("couponName"));
        orderDetailVO.setCouponAmount(order.getDiscountTotalAmount());
        orderDetailVO.setExpressAmount(order.getExpressAmount());
        orderDetailVO.setPointAmount(order.getGetPoint());
        orderDetailVO.setPointDeductionAmount(order.getPointDeductionAmount());//积分抵扣金额
        orderDetailVO.setPaymentAmount(order.getPaymentAmount());
        orderDetailVO.setGoodsList(goodsList);
        orderDetailVO.setShopName(shop.getName());
        orderDetailVO.setShopAddress(shop.getAddress());
        orderDetailVO.setLongitude(shop.getLongitude());
        orderDetailVO.setLatitude(shop.getLatitude());
        orderDetailVO.setShopId(shop.getId());
        if (StringUtils.isNotEmpty(order.getExpressResult())) {
            MapTrackKD100Vo mapTrackKD100Vo = JSON.parseObject(order.getExpressResult(), MapTrackKD100Vo.class);
            List<QueryKD100ListVo> data = mapTrackKD100Vo.getData();
            orderDetailVO.setExpress(null != data && data.size() > 0 ? data.get(0).getContext() : "");
        }

        // 生成核销码BASE64
        try {
            String base64 = QRCodeGenerator.generateQRCodeBase64(String.valueOf(order.getId()), 124, 124);
@@ -200,6 +188,14 @@
            e.printStackTrace();
            throw new ServiceException("生成核销码失败");
        }
        if(3!=order.getOrderStatus()){
            //不属于未使用的，应该有个核销\取消时间
            orderDetailVO.setEndTime(order.getEndTime());
        }
        //该商品是否被用户评论
        Long evaluateId = goodsEvaluateClient.getEvaluateIdByOrderId(order.getId()).getData();
        orderDetailVO.setEvaluateId(evaluateId);

        return orderDetailVO;
    }

@@ -215,13 +211,19 @@

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void writeOff(String id, Integer shopId, String technicianId) {
    public void writeOff(String id, Integer shopId) {
        LoginUser loginUserApplet = tokenService.getLoginUserApplet();
        Order order = orderMapper.selectById(id);
        boolean check = check(order, shopId, loginUserApplet.getUserid());
        if (!check) {
        if (order == null) {
            throw new ServiceException("订单不存在");
        }
        if (!order.getShopId().equals(shopId)) {
            throw new ServiceException("该订单与当前扫码门店不一致");
        }
        if (order.getOrderStatus()!=3){
            throw new ServiceException("订单已被核销过");
        }


        // 售后设置
        R<BaseSetting> baseSettingR = baseSettingClient.getBaseSetting(5);
@@ -239,10 +241,11 @@
        order.setAfterSaleTime(LocalDateTime.now().plusDays(days));
        order.setEndTime(LocalDateTime.now());
        order.setCancellerAppUserId(loginUserApplet.getUserid());
        if (StringUtils.isNotEmpty(technicianId) && !"null".equals(technicianId)) {
            order.setTechnicianId(Integer.valueOf(technicianId));
        }
        orderMapper.updateById(order);
        //店铺可用金额增加
        Shop shop = shopClient.getShopById(shopId).getData();
        shop.setCanWithdrawMoney(shop.getCanWithdrawMoney().add(order.getTotalAmount()));
        shopClient.updateShop(shop);
    }


@@ -254,7 +257,7 @@
     */
    @Override
    public PageInfo<OrderPageListVo> getOrderPageList(OrderPageList orderPageList) {
        Long userid = tokenService.getLoginUser().getUserid();
       /* Long userid = tokenService.getLoginUser().getUserid();
        SysUser sysUser = sysUserClient.getSysUser(userid).getData();
        if (2 == sysUser.getRoleType()) {
            orderPageList.setShopId(sysUser.getObjectId());
@@ -322,7 +325,8 @@
            }

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

    /**
@@ -350,9 +354,6 @@

    /**
     * 小程序取消订单
     *
     * @param orderId
     * @return
     */
    @Override
    public R cancel(Long orderId) {
@@ -406,78 +407,92 @@


    /**
     * 返回订单支付金额和回退积分和会员等级
     *
     * @param order
     * 回退积分和返回订单支付金额
     */
    public R refundPayMoney(Order order) {
        //开始退款
        Integer payMethod = order.getPayMethod();
        BigDecimal expressAmount = order.getExpressAmount() == null ? BigDecimal.ZERO : order.getExpressAmount();
        BigDecimal paymentAmount = order.getPaymentAmount().add(expressAmount);
        AppUser appUser = appUserClient.getAppUserById(order.getAppUserId());
        if (1 == payMethod) {
        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())) {
                order.setRefundStatus(1);
                return R.ok();
            } else {
                return R.fail(refund.getRc_CodeMsg());
            if (!"100".equals(refund.getRa_Status())) {
                return R.fail(refund.getRc_CodeMsg());//退款失败
            }
        }
        if (2 == payMethod) {
            BigDecimal balance = appUser.getBalance();
            appUser.setBalance(balance.add(paymentAmount).setScale(2, RoundingMode.HALF_EVEN));
            appUser.setShopAmount(appUser.getShopAmount().subtract(paymentAmount).setScale(2, RoundingMode.HALF_EVEN));
            //查询最后一次的消费订单
            Order order1 = this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getAppUserId, order.getAppUserId()).eq(Order::getPayStatus, 2)
                    .eq(Order::getDelFlag, 0).in(Order::getOrderStatus, Arrays.asList(1, 2, 3, 4, 8)).ne(Order::getId, order.getId()).last(" order by create_time desc limit 0, 1"));
            if (null != order1) {
                appUser.setLastShopTime(order1.getCreateTime());
            } else {
                appUser.setLastShopTime(null);
        //退款成功再回退积分
        AppUser appUser = appUserClient.getAppUserById(order.getAppUserId());
        if (order.getPoint()>0) {
            if(null==appUser.getCancelPoint()){
                appUser.setCancelPoint(0);
            }
        }
        if (3 == payMethod) {
            //开始运费退款，积分支付，运费是单独进行支付的，所以需要单独退款
            if (null != order.getExpressAmount() && BigDecimal.ZERO.compareTo(order.getExpressAmount()) < 0) {
                if (1 == order.getExpressPayMethod()) {
                    //微信退款
                    RefundResult refund = PaymentUtil.refund(order.getOrderNumber(), "R" + order.getOrderNumber(), expressAmount.doubleValue(), "/order/order/refundExpressPayMoneyCallback");
                    if ("100".equals(refund.getRa_Status())) {
                        order.setRefundStatus(1);
                        return R.ok();
                    } else {
                        return R.fail(refund.getRc_CodeMsg());
                    }
                }
                if (2 == order.getExpressPayMethod()) {
                    BigDecimal balance = appUser.getBalance();
                    appUser.setBalance(balance.add(expressAmount).setScale(2, RoundingMode.HALF_EVEN));
                }
            }
            //返回订单抵扣积分
            Integer historicalPoint = appUser.getAvailablePoint();
            Integer availablePoint = appUser.getAvailablePoint() + order.getPoint();//可用积分
            Integer cancelPoint = appUser.getCancelPoint() + order.getPoint();//取消订单积分

            Integer lavePoint = appUser.getLavePoint();
            //积分退款
            appUser.setLavePoint(appUser.getLavePoint() + order.getPoint());
            appUser.setAvailablePoint(appUser.getAvailablePoint() + order.getPoint());
            UserPoint userPoint1 = new UserPoint();
            userPoint1.setType(11);
            userPoint1.setObjectId(order.getId());
            Integer transferablePoint = order.getPoint();
            appUser.setTransferablePoint(appUser.getTransferablePoint() + transferablePoint);
            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();
    }


    /**
     * 取消订单后回调处理
     * 退款后后回调处理
     *
     * @return
     */
@@ -547,22 +562,16 @@
            orderInfo.setUserName(appUser.getName());
            orderInfo.setPhone(appUser.getPhone());
        }
        orderInfo.setOrderType(order.getOrderType() == 1 ? "服务" : (StringUtils.isNotEmpty(order.getAddressJson()) ? "单品-快递配送" : "单品-上门自提"));

        Shop shop = shopClient.getShopById(order.getShopId()).getData();
        if (null != shop) {
            orderInfo.setShopName(shop.getName());
        }
        orderInfo.setPaymentMethod(order.getPayMethod());
        orderInfo.setTotalAmount(order.getTotalAmount());
        orderInfo.setDiscountAmount(order.getDiscountTotalAmount());
        orderInfo.setExpressAmount(order.getExpressAmount());

        orderInfo.setPaymentAmount(order.getPaymentAmount());
        orderInfo.setGetPoint(order.getGetPoint());
        if (StringUtils.isNotEmpty(order.getExpressJson()) && !order.getExpressJson().equals("NULL")){
            JSONObject jsonObject = JSON.parseObject(order.getExpressJson());
            orderInfo.setExpressCompany(jsonObject.getString("com"));
            orderInfo.setExpressNumber(jsonObject.getString("num"));
        }


        List<OrderGood> orderGoods = orderGoodMapper.selectList(new LambdaQueryWrapper<OrderGood>().eq(OrderGood::getOrderId, orderId).eq(OrderGood::getDelFlag, 0));
        int sum = orderGoods.stream().mapToInt(OrderGood::getNum).sum();
@@ -657,37 +666,48 @@
        confirmOrderVo.setShopName(shop.getShopName());
        confirmOrderVo.setPurchaseLimitNum(good.getPurchaseLimit());
        confirmOrderVo.setOriginalPrice(good.getOriginalPrice());
        //todo 实时计算用户可用积分


        confirmOrderVo.setResidualPoint(appUser.getAvailablePoint());
        //插入价格
        confirmOrderVo.setCash(good.getSellingPrice());
        confirmOrderVo.setPoint(good.getIntegral());

        //计算活动价格信息
        Price price = getPrice(goodId, 1);
        if (null != price) {
            confirmOrderVo.setCash(price.getCash());
            confirmOrderVo.setOrderPoint(price.getPoint());
            confirmOrderVo.setEndTimeStamp(price.getEndTimeStamp());
        //是否在秒杀活动中
        GetSeckillActivityInfo info = new GetSeckillActivityInfo();
        info.setGoodsId(goodId);
        GoodsSeckill goodsSeckill = seckillActivityInfoClient.getSeckillActivityInfo(info).getData();

        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());
            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{
            //todo 查当前用户的订单
            // 查当前用户的订单
            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;
@@ -698,34 +718,456 @@
                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;
    }

    /**
     * 根据商品的价格配置体系获取商品当前的价格
     * @param goodsId
     * @param type          1普通商品，2秒杀商品
     * 订单支付
     */
    @Override
    public R orderPayment(OrderPayment orderPayment) {
        Long userid = tokenService.getLoginUserApplet().getUserid();
        AppUser appUser = appUserClient.getAppUserById(userid);
        int type=1;//商品类型  1=普通商品，2=秒杀商品
        //商品信息
        Goods goods = goodsClient.getGoodsById(orderPayment.getGoodId()).getData();
        String goodsJson= JSON.toJSONString(goods);
        if (null == goods || 1==goods.getDelFlag()){
            return  R.fail( "商品不存在");
        }
        if(goods.getStatus() == 1){
            return R.fail(goods.getName() + "商品已被下架");
        }

        //是否在秒杀活动中
        GetSeckillActivityInfo info = new GetSeckillActivityInfo();
        info.setGoodsId(orderPayment.getGoodId());
        GoodsSeckill goodsSeckill = seckillActivityInfoClient.getSeckillActivityInfo(info).getData();

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

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

        //订单总金额
        BigDecimal orderMoney = BigDecimal.ZERO;
        //积分支付的订单积分
        Integer orderPoint = 0;

        //现金的实际支付金额
        BigDecimal paymentMoney = BigDecimal.ZERO;
        //积分抵扣金额
        BigDecimal pointDeductionAmount = BigDecimal.ZERO;

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

            //是否使用积分抵扣
            if (orderPayment.getIsPointDeduction() == 1) {
                //积分抵扣金额
                Integer availablePoint = appUser.getAvailablePoint();//用户可用积分
                BigDecimal maxPointDeductionAmount = getCashByPoint(availablePoint);//最大可抵扣金额
                pointDeductionAmount=maxPointDeductionAmount.min(orderMoney);//实际抵扣金额
                // 计算实际支付金额
                paymentMoney = orderMoney.subtract(pointDeductionAmount).setScale(2, RoundingMode.HALF_EVEN);
                //计算消耗积分
                orderPoint=getPoint(pointDeductionAmount);
            }
        }else{
            //积分支付
            orderPoint=goods.getIntegral();
            orderMoney = goods.getSellingPrice();
            Integer availablePoint = appUser.getAvailablePoint();//用户可用积分
            if(availablePoint.compareTo(orderPoint) < 0){
                return R.fail("账户可用积分不足");
            }
        }
        //构建订单
        Order order = new Order();
        order.setAppUserId(appUser.getId());
        order.setNum(1);
        order.setGoodPics(goods.getHomePagePicture());
        order.setGoodName(goods.getName());
        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());//支付方式
        order.setPayStatus(1);
        order.setShopId(orderPayment.getShopId());
        order.setDelFlag(0);
        order.setCreateTime(LocalDateTime.now());

        this.save(order);


        //构建订单明细数据
        OrderGood orderGood = new OrderGood();
        orderGood.setGoodsId(goods.getId());
        orderGood.setOrderId(order.getId());
        orderGood.setNum(1);
        orderGood.setType(type);
        if (2==type){
            orderGood.setSeckillJson(JSON.toJSONString(goodsSeckill));
        }
        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.setSellingPrice(goods.getSellingPrice());
        orderGood.setIntegral(goods.getIntegral());
        orderGoodService.save(orderGood);

        //开始构建支付信息
        if(BigDecimal.ZERO.compareTo(paymentMoney) > 0){
            paymentMoney = BigDecimal.ZERO;
        }
        //判断积分是否为零，积分支付
        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.setTotalPoint(appUser.getTotalPoint() + order.getPoint());//总积分
            //构建积分流水记录
            UserPoint userPoint = new UserPoint();
            userPoint.setType(4);//兑换商品
            userPoint.setHistoricalPoint(historicalPoint);
            userPoint.setVariablePoint(orderPoint);
            userPoint.setBalance(availablePoint);
            userPoint.setCreateTime(LocalDateTime.now());
            userPoint.setAppUserId(appUser.getId());
            userPoint.setObjectId(order.getId());
            userPointClient.saveUserPoint(userPoint);

            //用户积分变动
            appUser.setLastShopTime(LocalDateTime.now());
            appUserClient.editAppUserById(appUser);


        }
        //判断需要支付的金额是否大于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());
            }
            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());

        }

        //积分支付，不需要微信支付，直接修改订支付状态
        order.setPayStatus(2);
        orderMapper.updateById(order);
        //商品销量增加
        goodsClient.editGoodsNum(orderGood.getGoodsId(), 1);

        //门店增加冻结资金 即增加余额， 冻结资金=余额-可用资金
        Shop shop = shopClient.getShopById(order.getShopId()).getData();
        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);
        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(5);//变更类型，订单收入
        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(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){
            return R.ok();
        }

        AppUser appUser = appUserClient.getAppUserById(order.getAppUserId());
        BigDecimal paymentMoney = order.getPaymentAmount();
        //增加用户消费总金额（微信支付金额）
        appUser.setShopAmount(appUser.getShopAmount().add(paymentMoney).setScale(2, RoundingMode.HALF_EVEN));//消费总金额
        appUser.setLastShopTime(LocalDateTime.now());
        appUserClient.editAppUserById(appUser);

        //修改订支付状态
        order.setPayStatus(2);
        //待使用
        order.setOrderStatus(3);
        String r7TrxNo = uniPayCallbackResult.getR9_BankTrxNo();
        order.setSerialNumber(r7TrxNo);
        orderMapper.updateById(order);

        OrderGood orderGood = orderGoodService.getOne(new LambdaQueryWrapper<OrderGood>().eq(OrderGood::getOrderId, order.getId()));
        //商品销量增加
        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=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);
        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(5);//变更类型，订单收入
        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();
    }

    /**
     * 定时任务关闭订单
     */
    @Override
    public void closeOrder() {
        //订单支付数据
        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));
            for (Order order : list) {
                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())){
                    redisTemplate.opsForZSet().add("OrderPayment", order.getOrderNumber(), 0);
                    log.error("关闭订单失败：{}---->{}", order.getOrderNumber(), JSON.toJSONString(closeOrderResult));
                }
                redisTemplate.opsForZSet().remove("OrderPayment", order.getOrderNumber());
                //关闭订单后，检查是否先有过积分抵扣了，是的话要返回订单已抵扣的积分，以及用户积分流水的删除
                if (order.getPoint()>0) {
                    //返回订单抵扣积分
                    AppUser appUser = appUserClient.getAppUserById(order.getAppUserId());
                    Integer availablePoint = appUser.getAvailablePoint();//可用积分
                    Integer variablePoint = order.getPoint();//变动积分
                    Integer balance = appUser.getAvailablePoint() + order.getPoint();//变动后积分
                    Integer cancelPoint = appUser.getCancelPoint() + order.getPoint();//取消订单积分
                    appUser.setAvailablePoint(availablePoint);
                    appUser.setCancelPoint(cancelPoint);
                    appUser.setTotalPoint(appUser.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(appUser.getId());
                    userPoint.setObjectId(order.getId());
                    userPointClient.saveUserPoint(userPoint);

                    appUserClient.editAppUserById(appUser);
                }
            }
        }

    }

    @Override
    public IPage<OrderPageListVo> getShopOrderList(String content, Integer status, Integer shopId, Integer pageNum, Integer pageSize) {
        // 创建分页对象
        Page<Order> page = new Page<>(pageNum, pageSize);
        // 构建查询条件
        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
        // 添加门店ID条件
        if (shopId != null) {
            queryWrapper.eq("shop_id", shopId);
        }
        // 添加订单状态条件
        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)) {
            // 构建OR条件组：订单编号/商品名/手机号
            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 + "%'")  // 手机号
            );
        }

        // 执行分页查询
        IPage<Order> orderPage = orderMapper.selectPage(page, queryWrapper);
        // 转换为VO对象
        return orderPage.convert(this::convertToOrderListVo);
    }

    @Override
    public R shopCancelOrder(Long orderId) {
        Order order = this.getById(orderId);
        if (Arrays.asList(5, 6, 7).contains(order.getOrderStatus())) {
            return R.fail("无效的操作");
        }
        if (null != order.getAfterSaleTime() && LocalDateTime.now().isAfter(order.getAfterSaleTime())) {
            return R.fail("订单取消失败");
        }
        order.setOrderStatus(5);
        order.setEndTime(LocalDateTime.now());
        R r = refundPayMoney(order);
        if (200 == r.getCode()) {
            this.updateById(order);
        }
        return r;
    }

    /**
     * 后台-工作台-折线图
     * @param startTime
     * @param endTime
     * @return
     */
    public Price getPrice( Integer goodsId, Integer type){
        //判断是否有在秒杀活动时间中
        Price price = new Price();
        GetSeckillActivityInfo getSeckillActivityInfo = new GetSeckillActivityInfo();
        getSeckillActivityInfo.setGoodsId(goodsId);
        GoodsSeckill goodsSeckill = seckillActivityInfoClient.getSeckillActivityInfo(getSeckillActivityInfo).getData();
        //没有秒杀活动或者添加的普通商品则使用秒杀活动价格
        if(null == goodsSeckill || type == 1){
            return null;
    @Override
    public List<OrderStatisticsDetail> getOrderListGroupByDate(LocalDate startTime, LocalDate endTime) {
        // 查询数据库获取原始数据
        List<OrderStatisticsDetail> rawData = orderMapper.getOrderListGroupByDate(
                startTime.atTime(0,0, 0),
                endTime.atTime(23,59,59)
        );

        // 创建完整日期范围的映射
        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));
            }
        }
        //秒杀活动价格
        price.setCash(goodsSeckill.getSellingPrice());
        //计算对应积分
        price.setPoint(getPoint(price.getCash()));
        price.setEndTimeStamp(goodsSeckill.getEndTime());
        return price;
        return completeList;
    }


    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){
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < size; i++) {
            str.append(Double.valueOf(Math.random() * 10).intValue());
        }
        return str.toString();
    }

    /**
     * 获取现金对应积分
     */