小程序收付款

huliguo

8 天以前 6acf6357094588946b5528f1ef1ed84a0f1037fd

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

@@ -33,6 +33,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.*;
@@ -52,6 +57,8 @@
import org.springframework.util.CollectionUtils;

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

import java.math.BigDecimal;
import java.math.RoundingMode;
@@ -124,6 +131,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 +146,7 @@

    @Override
    public OrderDetailVO getOrderDetail(Long orderId) {
        OrderDetailVO orderDetailVO = new OrderDetailVO();
        Order order = orderMapper.selectById(orderId);
        if (order == null) {
            throw new ServiceException("订单不存在");
@@ -140,14 +155,17 @@
        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());
@@ -163,7 +181,7 @@

        orderGoodsVO.setOriginalPrice(goods.getOriginalPrice());

        OrderDetailVO orderDetailVO = new OrderDetailVO();

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

@@ -177,6 +195,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());
@@ -280,6 +299,26 @@
            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<OrderManagePageListVO> pageInfo = new PageInfo<>(orderPageList.getPageCurr(), orderPageList.getPageSize());

@@ -316,6 +355,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;
            }
@@ -386,10 +447,16 @@
        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());//退款失败
            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());
@@ -469,16 +536,90 @@
     * @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();
    }

@@ -793,7 +934,7 @@
        order.setPointDeductionAmount(pointDeductionAmount.setScale(2, RoundingMode.HALF_EVEN));
        order.setPaymentAmount(paymentMoney);//实际支付价格
        order.setPoint(orderPoint);//使用积分
        if (orderPayment.getPaymentType()==3 && orderPoint>0){//微信支付 但支付的积分也大于0
        if (orderPayment.getPaymentType()==1 && orderPoint>0){//微信支付 但支付的积分也大于0
            order.setPayMethod(4);//组合支付
        }else {
            order.setPayMethod(orderPayment.getPaymentType());//积分或者微信
@@ -866,18 +1007,54 @@
        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());


        }

@@ -915,15 +1092,18 @@
        shopBalanceStatement.setCreateUserId(appUser.getId());
        shopBalanceStatement.setObjectId(order.getId());
        shopBalanceStatementClient.saveShopBalanceStatement(shopBalanceStatement);
        return R.ok(order.getId().toString());
        Map<String, String> payParams = new HashMap<>();
        payParams.put("payMethod","3");//给前端标识 3-不需要调微信支付
        payParams.put("orderId",order.getId().toString());
        return R.ok(JSON.toJSONString(payParams));
    }

    /**
     * 订单支付回调通知
     * 订单支付回调 处理业务逻辑
     */
    @Override
    public R orderPaymentCallback(UniPayCallbackResult uniPayCallbackResult) {
        Order order = orderMapper.selectOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNumber, uniPayCallbackResult.getR2_OrderNo()));
    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();
        }
@@ -939,7 +1119,7 @@
        order.setPayStatus(2);
        //待使用
        order.setOrderStatus(3);
        String r7TrxNo = uniPayCallbackResult.getR9_BankTrxNo();
        String r7TrxNo = payResult.getTransactionId();
        order.setSerialNumber(r7TrxNo);
        orderMapper.updateById(order);

@@ -990,21 +1170,20 @@
        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));
            List<Order> list = orderMapper.selectList(new LambdaQueryWrapper<Order>().in(Order::getId, 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())){
                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) {
                    //返回订单抵扣积分
                    AppUser appUser = appUserClient.getAppUserById(order.getAppUserId());
@@ -1028,6 +1207,10 @@
                    userPointClient.saveUserPoint(userPoint);

                    appUserClient.editAppUserById(appUser);

                    //删除订单
                    order.setDelFlag(1);
                    orderMapper.updateById(order);
                }
            }
        }
@@ -1040,6 +1223,10 @@
        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);
@@ -1053,13 +1240,21 @@
        }
        // 模糊查询条件
        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)  // 商品名
            );
        }

@@ -1094,11 +1289,12 @@
     * @return
     */
    @Override
    public List<OrderStatisticsDetail> getOrderListGroupByDate(LocalDate startTime, LocalDate endTime) {
    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)
                endTime.atTime(23,59,59),
                shopId
        );

        // 创建完整日期范围的映射