更新了服务类订单模块

src/main/java/com/cultural/heritage/controller/good/CategoryController.java

@@ -16,6 +16,7 @@ import com.cultural.heritage.model.dto.category.CategoryAddRequest;
 import com.cultural.heritage.model.dto.category.CategoryUpdateRequest;
 import com.cultural.heritage.model.entity.Category;
 import com.cultural.heritage.model.entity.Good;
+import com.cultural.heritage.service.common.CommonService;
 import com.cultural.heritage.service.good.CategoryService;
 import com.cultural.heritage.service.good.GoodService;
 import com.cultural.heritage.service.user.UserService;
@@ -55,6 +56,10 @@ public class CategoryController {
     private UserService userService;
 
 
+    @Resource
+    private CommonService commonService;
+
+
     /**
      * 添加商品类别
      * @param categoryAddRequest  类别添加请求体
@@ -88,20 +93,26 @@ public class CategoryController {
         if (deleteCategoryRequest == null || deleteCategoryRequest.getId() <= 0) {
             throw new BusinessException(ErrorCode.PARAMS_ERROR);
         }
-        // 删除当前类别下的所有商品
+        // 批量删除当前类别下的所有商品
         Long id = deleteCategoryRequest.getId();
-        // 根据类别id获取商品删除的条件
+        Category category = categoryService.getCategoryById(id);
-        QueryWrapper<Good> queryWrapper = categoryService.getDeleteQueryWrapper(id);
+        ThrowUtils.throwIf(category == null, ErrorCode.OPERATION_ERROR, "当前类别不存在");
+
+        String typeName = category.getTypeName();
+        QueryWrapper<Good> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("type", typeName);
         List<Good> goodList = goodService.list(queryWrapper);
+
         // 如果该类别下有商品，就删除
-        if (!CollectionUtils.isEmpty(goodList)) {
+        if (!goodList.isEmpty()) {
             boolean isSuccess = goodService.removeBatchByIds(goodList);
-            ThrowUtils.throwIf(!isSuccess, ErrorCode.OPERATION_ERROR);
+            ThrowUtils.throwIf(!isSuccess, ErrorCode.OPERATION_ERROR, "商品批量删除失败");
         }
         // 删除当前类别
         boolean result = categoryService.removeById(id);
-        ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR);
+        ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "类别删除失败");
-        return ResultUtils.success(true, "类别删除成功");
+
+        return ResultUtils.success(true);
     }
 
 
@@ -118,20 +129,23 @@ public class CategoryController {
             throw new BusinessException(ErrorCode.PARAMS_ERROR);
         }
         List<Long> idList = commonDelBatchRequest.getIdList();
-        // 删除当前类别下的所有商品
+        // 批量删除当前类别下的所有商品
-        idList.forEach(id -> {
+        List<Category> categoryList = commonService.getListByIds(idList, categoryService);
-            // 根据类别id获取商品删除的条件
+        List<String> typeNameList = categoryList.stream().map(Category::getTypeName).toList();
-            QueryWrapper<Good> queryWrapper = categoryService.getDeleteQueryWrapper(id);
+        QueryWrapper<Good> queryWrapper = new QueryWrapper<>();
+        queryWrapper.in("type", typeNameList);
         List<Good> goodList = goodService.list(queryWrapper);
+
         // 如果该类别下有商品，就删除
-            if (!CollectionUtils.isEmpty(goodList)) {
+        if (!goodList.isEmpty()) {
-                boolean isSuccess = goodService.removeBatchByIds(goodList);
+            boolean result = goodService.removeBatchByIds(goodList);
-                ThrowUtils.throwIf(!isSuccess, ErrorCode.OPERATION_ERROR);
+            ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "商品批量删除失败");
         }
-            // 删除当前类别
+
-            boolean result = categoryService.removeById(id);
+        // 批量删除当前类别
-            ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR);
+        boolean remove = categoryService.removeBatchByIds(categoryList);
-        });
+        ThrowUtils.throwIf(!remove, ErrorCode.OPERATION_ERROR, "类别批量删除失败");
+
         return ResultUtils.success(true, "批量删除类别成功");
     }
 

src/main/java/com/cultural/heritage/controller/order/OrderController.java

@@ -29,6 +29,7 @@ import com.cultural.heritage.service.good.GoodService;
 import com.cultural.heritage.service.good.UserCouponService;
 import com.cultural.heritage.service.order.OrderItemService;
 import com.cultural.heritage.service.order.OrderService;
+import com.cultural.heritage.service.order.PendingServiceOrderService;
 import com.cultural.heritage.service.user.UserService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -74,6 +75,7 @@ public class OrderController {
     private CartRecordService cartRecordService;
 
 
+
     @Resource
     private CartExperienceService cartExperienceService;
 
@@ -83,11 +85,16 @@ public class OrderController {
     private GoodService goodService;
 
 
+
     @Resource
     private UserCouponService userCouponService;
 
 
 
+    @Resource
+    private PendingServiceOrderService pendingServiceOrderService;
+
+
 
 
     /**
@@ -450,6 +457,17 @@ public class OrderController {
         boolean update = orderService.updateById(order);
         ThrowUtils.throwIf(!update, ErrorCode.OPERATION_ERROR, "订单状态更新失败");
 
+        // 更新服务类商品待处理订单记录
+        QueryWrapper<PendingServiceOrder> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("orderNumber", order.getOrderNumber());
+        List<PendingServiceOrder> pendingServiceOrderList = pendingServiceOrderService.list(queryWrapper);
+        for (PendingServiceOrder pendingServiceOrder : pendingServiceOrderList) {
+            pendingServiceOrder.setOrderItemStatus(order.getOrderStatus());
+        }
+        boolean updateResult = pendingServiceOrderService.updateBatchById(pendingServiceOrderList);
+        ThrowUtils.throwIf(!updateResult, ErrorCode.OPERATION_ERROR, "服务类商品待处理订单记录更新失败");
+
+
         // 如果使用了优惠券，则退还优惠券
         Long userCouponId = order.getCouponSnapshot().getId();
         if (userCouponId != null) {
@@ -466,5 +484,4 @@ public class OrderController {
 
 
 
-
 }

src/main/java/com/cultural/heritage/service/good/impl/GoodServiceImpl.java

@@ -222,6 +222,7 @@ public class GoodServiceImpl extends ServiceImpl<GoodMapper, Good> implements Go
         QueryWrapper<PendingServiceOrder> queryWrapper = new QueryWrapper<>();
         queryWrapper.eq("pendingId", pendingId);
         queryWrapper.eq("orderItemStatus", OrderStatusConstant.PENDING_SHIPMENT);
+        queryWrapper.or().eq("orderItemStatus", OrderStatusConstant.PENDING_PAYMENT);
         List<PendingServiceOrder> pendingServiceOrderList = pendingServiceOrderService.list(queryWrapper);
         Integer totalNumber = 0;
         for (PendingServiceOrder pendingServiceOrder : pendingServiceOrderList) {
@@ -259,7 +260,8 @@ public class GoodServiceImpl extends ServiceImpl<GoodMapper, Good> implements Go
         pendingServiceOrderList = pendingServiceOrderList.stream().filter(pendingServiceOrder -> {
             String orderItemStatus = pendingServiceOrder.getOrderItemStatus();
             Long serviceOrderPendingId = pendingServiceOrder.getPendingId();
-            return orderItemStatus.equals(OrderStatusConstant.PENDING_SHIPMENT) && serviceOrderPendingId.equals(pendingId);
+            return (orderItemStatus.equals(OrderStatusConstant.PENDING_SHIPMENT) || orderItemStatus.equals(OrderStatusConstant.PENDING_PAYMENT))
+            && serviceOrderPendingId.equals(pendingId);
         }).toList();
 
         Integer totalNumber = 0;

src/main/java/com/cultural/heritage/service/order/impl/OrderServiceImpl.java

@@ -14,6 +14,7 @@ import com.cultural.heritage.model.dto.cart.CartOrderAddRequest;
 import com.cultural.heritage.model.dto.cart.CartOrderItemAddRequest;
 import com.cultural.heritage.model.dto.cartService.CartExperienceOrderAddRequest;
 import com.cultural.heritage.model.dto.cartService.CartExperienceOrderItemAddRequest;
+import com.cultural.heritage.model.dto.order.BookingOrderQueryRequest;
 import com.cultural.heritage.model.dto.order.OrderAddRequest;
 import com.cultural.heritage.model.dto.order.OrderItemAddRequest;
 import com.cultural.heritage.model.dto.order.OrderQueryRequest;
@@ -272,6 +273,9 @@ public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements
             // 扣减商品库存
             List<OrderItemMainInfoAddRequest> orderItemMainInfoAddRequestList = orderMainInfoAddRequest.getOrderItemMainInfoAddRequestList();
             this.deductionGeneralGoodInventory(orderItemMainInfoAddRequestList);
+        } else {
+            // 生成服务类商品待处理订单记录
+            this.pendingOrdersForPackagedServiceItems(order);
         }
 
         // 清空购物车
@@ -284,6 +288,48 @@ public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements
 
 
 
+
+
+
+    /**
+     * 生成服务类商品待处理订单记录
+     */
+    private void pendingOrdersForPackagedServiceItems (Order order) {
+        // 获取map集合（键：服务类商品待处理id, 值：服务类商品待处理记录）
+        Map<String, PendingServiceGood> pendingGoodMap = goodService.getPendingServiceGoodMap();
+
+        QueryWrapper<OrderItems> orderItemsQueryWrapper = new QueryWrapper<>();
+        orderItemsQueryWrapper.eq("orderId", order.getId());
+        List<OrderItems> orderItemsList = orderItemService.list(orderItemsQueryWrapper);
+
+        List<PendingServiceOrder> pendingServiceOrderList = new ArrayList<>();
+        for (OrderItems orderItems : orderItemsList) {
+            PendingServiceOrder pendingServiceOrder = new PendingServiceOrder();
+            pendingServiceOrder.setOrderItemId(orderItems.getId());
+            pendingServiceOrder.setOrderNumber(order.getOrderNumber());
+            pendingServiceOrder.setUserId(order.getUserId());
+            pendingServiceOrder.setName(order.getContactsSnapshot().getName());
+            pendingServiceOrder.setPhone(order.getContactsSnapshot().getPhone());
+            pendingServiceOrder.setQuantity(orderItems.getQuantity());
+            pendingServiceOrder.setItemTotalAmount(orderItems.getItemTotalAmount());
+            pendingServiceOrder.setOrderItemStatus(order.getOrderStatus());
+            BookingOrderQueryRequest bookingOrderQueryRequest = new BookingOrderQueryRequest(orderItems.getGoodSnapshot().getId(), orderItems.getReservationDate(), orderItems.getTimeSlot());
+            PendingServiceGood pendingServiceGood = pendingGoodMap.get(bookingOrderQueryRequest.toString());
+            pendingServiceOrder.setPendingId(pendingServiceGood.getId());
+
+            pendingServiceOrderList.add(pendingServiceOrder);
+        }
+
+        boolean saveBatch = pendingServiceOrderService.saveBatch(pendingServiceOrderList);
+        ThrowUtils.throwIf(!saveBatch, ErrorCode.OPERATION_ERROR, "服务类订单待处理记录批量生成失败");
+    }
+
+
+
+
+
+
+
     /**
      * 扣减常规类商品库存
      */

src/main/java/com/cultural/heritage/service/wx/impl/WeChatServiceImpl.java

@@ -8,13 +8,10 @@ import com.cultural.heritage.common.ErrorCode;
 import com.cultural.heritage.config.WxOpenConfig;
 import com.cultural.heritage.config.WxPayConfig;
 import com.cultural.heritage.constant.OrderStatusConstant;
-import com.cultural.heritage.exception.BusinessException;
 import com.cultural.heritage.exception.ThrowUtils;
-import com.cultural.heritage.model.dto.order.BookingOrderQueryRequest;
 import com.cultural.heritage.model.dto.snapshot.CouponSnapshot;
 import com.cultural.heritage.model.dto.snapshot.GoodSnapshot;
 import com.cultural.heritage.model.entity.*;
-import com.cultural.heritage.model.enums.GoodTypeEnum;
 import com.cultural.heritage.service.good.AppointmentDateService;
 import com.cultural.heritage.service.good.GoodService;
 import com.cultural.heritage.service.order.*;
@@ -35,14 +32,12 @@ import jakarta.annotation.Resource;
 import jakarta.servlet.http.HttpServletRequest;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.io.BufferedReader;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -54,6 +49,7 @@ import java.util.Map;
 @Service
 public class WeChatServiceImpl implements WeChatService {
 
+
     @Resource
     private WxPayConfig wxPayConfig;
 
@@ -124,15 +120,6 @@ public class WeChatServiceImpl implements WeChatService {
 
 
 
-    /**
-     * 获取支付回调信息
-     */
-    @Override
-    public Transaction getTransactionInfo(HttpServletRequest request) {
-        NotificationParser notificationParser = getNotificationParser(request);
-        return notificationParser.parse(requestParam, Transaction.class);
-    }
-
 
     /**
      * 支付回调
@@ -142,58 +129,17 @@ public class WeChatServiceImpl implements WeChatService {
     public synchronized boolean paymentCallback(Transaction transaction) {
         System.out.println("---------------------------微信支付回调（开始）-------------------------------");
         // 获取订单信息
-        String orderIdByString = transaction.getOutTradeNo();
+        String orderNumber = transaction.getOutTradeNo();
-        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
+        Order order = getOrderInfoByOrderNumber(orderNumber);
-        queryWrapper.eq("orderNumber", orderIdByString);
+
-        Order order = orderService.getOne(queryWrapper);
-        if (order == null) {
-            log.error("订单不存在");
-            throw new BusinessException(ErrorCode.NOT_FOUND_ERROR, "订单不存在，订单号：" + transaction.getOutTradeNo());
-        }
         // 修改订单状态
-        order.setOrderStatus(OrderStatusConstant.PENDING_SHIPMENT);
+        modifyOrderStatus(order, OrderStatusConstant.PENDING_SHIPMENT);
-        order.setUpdateTime(DateUtil.date());
-        boolean update = orderService.updateById(order);
-        ThrowUtils.throwIf(!update, ErrorCode.OPERATION_ERROR, "订单状态修改失败");
 
-        // 生成服务类订单待处理记录
+        boolean isGeneral = orderService.isGeneralGood(order.getOrderType());
-        GoodTypeEnum goodTypeEnum = GoodTypeEnum.getEnumByValue(order.getOrderType());
-        if (GoodTypeEnum.SERVICE.equals(goodTypeEnum)) {
-
-            // 封装map集合（键：服务类商品待处理id, 值：服务类商品待处理记录）
-            Map<String, PendingServiceGood> pendingGoodMap = new HashMap<>();
-            List<PendingServiceGood> pendingServiceGoodList = pendingServiceGoodService.list();
-            for (PendingServiceGood pendingServiceGood : pendingServiceGoodList) {
-                BookingOrderQueryRequest bookingOrderQueryRequest = new BookingOrderQueryRequest();
-                BeanUtils.copyProperties(pendingServiceGood, bookingOrderQueryRequest);
-                pendingGoodMap.put(bookingOrderQueryRequest.toString(), pendingServiceGood);
-            }
-
-            QueryWrapper<OrderItems> orderItemsQueryWrapper = new QueryWrapper<>();
-            orderItemsQueryWrapper.eq("orderId", order.getId());
-            List<OrderItems> orderItemsList = orderItemService.list(orderItemsQueryWrapper);
-
-            List<PendingServiceOrder> pendingServiceOrderList = new ArrayList<>();
-            for (OrderItems orderItems : orderItemsList) {
-                PendingServiceOrder pendingServiceOrder = new PendingServiceOrder();
-                pendingServiceOrder.setOrderItemId(orderItems.getId());
-                pendingServiceOrder.setOrderNumber(order.getOrderNumber());
-                pendingServiceOrder.setUserId(order.getUserId());
-                pendingServiceOrder.setName(order.getContactsSnapshot().getName());
-                pendingServiceOrder.setPhone(order.getContactsSnapshot().getPhone());
-                pendingServiceOrder.setQuantity(orderItems.getQuantity());
-                pendingServiceOrder.setItemTotalAmount(orderItems.getItemTotalAmount());
-                pendingServiceOrder.setOrderItemStatus(order.getOrderStatus());
-                BookingOrderQueryRequest bookingOrderQueryRequest = new BookingOrderQueryRequest(orderItems.getGoodSnapshot().getId(), orderItems.getReservationDate(), orderItems.getTimeSlot());
-                PendingServiceGood pendingServiceGood = pendingGoodMap.get(bookingOrderQueryRequest.toString());
-                pendingServiceOrder.setPendingId(pendingServiceGood.getId());
-
-                pendingServiceOrderList.add(pendingServiceOrder);
-            }
-
-            boolean saveBatch = pendingServiceOrderService.saveBatch(pendingServiceOrderList);
-            ThrowUtils.throwIf(!saveBatch, ErrorCode.OPERATION_ERROR, "服务类订单待处理记录批量生成失败");
 
+        if (!isGeneral) {
+            // 更新服务类商品待处理订单记录
+            updatePendingServiceOrder(orderNumber, OrderStatusConstant.PENDING_SHIPMENT);
         }
 
         System.out.println("---------------------------微信支付回调（结束）-------------------------------");
@@ -201,6 +147,8 @@ public class WeChatServiceImpl implements WeChatService {
     }
 
 
+
+
     /**
      * 全额退款
      */
@@ -235,6 +183,41 @@ public class WeChatServiceImpl implements WeChatService {
     }
 
 
+
+
+
+    /**
+     * 全额退款回调
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public synchronized boolean refundCallback(RefundNotification refundNotification) {
+        System.out.println("---------------------------微信退款回调（开始）-------------------------------");
+        // 获取订单信息
+        String orderIdByString = refundNotification.getOutTradeNo();
+        Order order = getOrderInfoByOrderNumber(orderIdByString);
+
+        // 修改订单状态
+        modifyOrderStatus(order, OrderStatusConstant.PAYMENT_REFUNDED);
+
+        // 生成退款记录
+        createRefundRecord(refundNotification);
+
+        boolean isGeneral = orderService.isGeneralGood(order.getOrderType());
+        if (!isGeneral) {
+            // 更新服务类订单待处理记录
+            updatePendingServiceOrder(order.getOrderNumber(), OrderStatusConstant.PAYMENT_REFUNDED);
+        } else {
+            // 恢复商品库存
+            recoverGoodInventory(String.valueOf(order.getId()));
+        }
+        System.out.println("---------------------------微信退款回调（结束）-------------------------------");
+        return true;
+    }
+
+
+
+
     /**
      * 部分退款
      */
@@ -242,15 +225,12 @@ public class WeChatServiceImpl implements WeChatService {
     public Refund refundPartPayment(String orderItemsId, BigDecimal amount) {
         // 获取订单明细
         OrderItems orderItems = orderItemService.getById(orderItemsId);
-        ThrowUtils.throwIf(orderItemsId == null, ErrorCode.OPERATION_ERROR, "订单明细不存在");
+        ThrowUtils.throwIf(orderItems == null, ErrorCode.OPERATION_ERROR, "订单明细不存在");
         // 获取订单明细所属的订单
         Order order = orderService.getById(orderItems.getOrderId());
         ThrowUtils.throwIf(order == null, ErrorCode.OPERATION_ERROR, "订单不存在");
         // 判断该订单明细是否已经退款
-        QueryWrapper<PendingServiceOrder> pendingServiceOrderQueryWrapper = new QueryWrapper<>();
+        checkOrderItemStatus(orderItemsId);
-        pendingServiceOrderQueryWrapper.eq("orderItemId", orderItemsId);
-        PendingServiceOrder pendingServiceOrder = pendingServiceOrderService.getOne(pendingServiceOrderQueryWrapper);
-        ThrowUtils.throwIf(pendingServiceOrder == null || !pendingServiceOrder.getOrderItemStatus().equals(OrderStatusConstant.PENDING_SHIPMENT), ErrorCode.OPERATION_ERROR, "服务类订单待处理记录不存在或者当前订单明细状态错误");
 
         String orderNumber = order.getOrderNumber();
         // 退款请求
@@ -265,7 +245,123 @@ public class WeChatServiceImpl implements WeChatService {
         // 退款金额
         AmountReq amountReq = new AmountReq();
 
+        // 计算部分退款金额
+        BigDecimal refundAmount = getPartRefundAmount(order, amount);
 
+        amountReq.setRefund(refundAmount.longValue());
+        amountReq.setTotal(order.getTotalAmount().movePointRight(2).longValue());
+        amountReq.setCurrency("CNY");
+        createRequest.setAmount(amountReq);
+        // 申请退款
+        System.out.println("退款请求：" + createRequest);
+        Refund refund = wxPayConfig.getRefundService().create(createRequest);
+        System.out.println("退款申请结果：" + refund);
+
+        return refund;
+    }
+
+
+
+
+
+
+    /**
+     * 部分退款回调
+     */
+    @Override
+    public boolean refundPartCallback(RefundNotification refundNotification) {
+        System.out.println("---------------------------微信退款回调（开始）-------------------------------");
+        // 获取订单信息
+        String orderNumber = refundNotification.getOutTradeNo();
+        Order order = getOrderInfoByOrderNumber(orderNumber);
+
+        // 生成退款记录
+        createRefundRecord(refundNotification);
+
+        // 解析出订单明细id
+        String outRefundNo = refundNotification.getOutRefundNo();
+        String orderItemId = RefundUtils.parseRefundNoToItemId(outRefundNo);
+
+        boolean isGeneral = orderService.isGeneralGood(order.getOrderType());
+        if (!isGeneral) {
+            // 更新服务类订单待处理记录
+            UpdateWrapper<PendingServiceOrder> updateWrapper = new UpdateWrapper<>();
+            updateWrapper.eq("orderItemId", orderItemId).set("orderItemStatus", OrderStatusConstant.PAYMENT_REFUNDED);
+            boolean update = pendingServiceOrderService.update(updateWrapper);
+            ThrowUtils.throwIf(!update, ErrorCode.OPERATION_ERROR, "服务类订单待处理记录状态更新失败");
+        } else {
+            // 恢复商品库存
+            OrderItems orderItems = orderItemService.getById(orderItemId);
+            Long id = orderItems.getGoodSnapshot().getId();
+            Good good = goodService.getById(id);
+            ThrowUtils.throwIf(good == null, ErrorCode.OPERATION_ERROR, "当前商品不存在");
+            good.setInventory(good.getInventory() + orderItems.getQuantity());
+            boolean update = goodService.updateById(good);
+            ThrowUtils.throwIf(!update, ErrorCode.OPERATION_ERROR, "商品库存恢复失败");
+        }
+        return true;
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    /**
+     * 判断当前订单明细是否已退款
+     */
+    public void checkOrderItemStatus(String orderItemsId) {
+        QueryWrapper<PendingServiceOrder> pendingServiceOrderQueryWrapper = new QueryWrapper<>();
+        pendingServiceOrderQueryWrapper.eq("orderItemId", orderItemsId);
+        PendingServiceOrder pendingServiceOrder = pendingServiceOrderService.getOne(pendingServiceOrderQueryWrapper);
+        ThrowUtils.throwIf(pendingServiceOrder == null || !pendingServiceOrder.getOrderItemStatus()
+                .equals(OrderStatusConstant.PENDING_SHIPMENT), ErrorCode.OPERATION_ERROR, "服务类订单待处理记录不存在或者当前订单明细状态错误");
+
+    }
+
+
+
+
+
+    /**
+     * 计算部分退款金额
+     */
+    private BigDecimal getPartRefundAmount(Order order, BigDecimal amount) {
 
         BigDecimal refundAmount;
         CouponSnapshot couponSnapshot = order.getCouponSnapshot();
@@ -297,80 +393,84 @@ public class WeChatServiceImpl implements WeChatService {
                 refundAmount = amount.subtract(itemCouponRefund);
             }
         }
-
         refundAmount = refundAmount.movePointRight(2).setScale(0, RoundingMode.HALF_UP);
-        amountReq.setRefund(refundAmount.longValue());
+        return refundAmount;
-        amountReq.setTotal(order.getTotalAmount().movePointRight(2).longValue());
-        amountReq.setCurrency("CNY");
-        createRequest.setAmount(amountReq);
-        // 申请退款
-        System.out.println("退款请求：" + createRequest);
-        Refund refund = wxPayConfig.getRefundService().create(createRequest);
-        System.out.println("退款申请结果：" + refund);
-
-        return refund;
     }
 
 
+
     /**
-     * 获取退款回调信息
+     * 更新服务类商品订单待处理记录
      */
-    @Override
+    private void updatePendingServiceOrder(String orderNumber, String orderStatus) {
-    public RefundNotification getRefundInfo(HttpServletRequest request) {
-        NotificationParser notificationParser = getNotificationParser(request);
-        return notificationParser.parse(requestParam, RefundNotification.class);
-    }
-
-
-    /**
-     * 全额退款回调
-     */
-    @Override
-    @Transactional(rollbackFor = Exception.class)
-    public synchronized boolean refundCallback(RefundNotification refundNotification) {
-        System.out.println("---------------------------微信退款回调（开始）-------------------------------");
-        // 获取订单信息
-        String orderIdByString = refundNotification.getOutTradeNo();
-        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
-        queryWrapper.eq("orderNumber", orderIdByString);
-        Order order = orderService.getOne(queryWrapper);
-        if (order == null) {
-            log.error("订单不存在");
-            throw new BusinessException(ErrorCode.NOT_FOUND_ERROR, "订单不存在，订单号：" + orderIdByString);
-        }
-
-        // 修改订单状态
-        order.setOrderStatus(OrderStatusConstant.PAYMENT_REFUNDED);
-        order.setUpdateTime(DateUtil.date());
-        boolean update = orderService.updateById(order);
-        ThrowUtils.throwIf(!update, ErrorCode.OPERATION_ERROR, "订单状态修改失败");
-
-        // 生成退款记录
-        RefundRecord refundRecord = new RefundRecord();
-        refundRecord.setOutTradeNo(refundNotification.getOutTradeNo());
-        refundRecord.setOutRefundNo(refundNotification.getOutRefundNo());
-        refundRecord.setRefundAmount(order.getTotalAmount());
-
-        boolean save = refundRecordService.save(refundRecord);
-        ThrowUtils.throwIf(!save, ErrorCode.OPERATION_ERROR, "退款记录生成失败");
-
-
-        GoodTypeEnum orderTypeEnum = GoodTypeEnum.getEnumByValue(order.getOrderType());
-        if (GoodTypeEnum.SERVICE.equals(orderTypeEnum)) {
-            // 更新服务类订单待处理记录
         QueryWrapper<PendingServiceOrder> orderQueryWrapper = new QueryWrapper<>();
-            orderQueryWrapper.eq("orderNumber", order.getOrderNumber());
+        orderQueryWrapper.eq("orderNumber", orderNumber);
         List<PendingServiceOrder> pendingServiceOrderList = pendingServiceOrderService.list(orderQueryWrapper);
         for (PendingServiceOrder pendingServiceOrder : pendingServiceOrderList) {
-                pendingServiceOrder.setOrderItemStatus(OrderStatusConstant.PAYMENT_REFUNDED);
+            pendingServiceOrder.setOrderItemStatus(orderStatus);
         }
         boolean result = pendingServiceOrderService.updateBatchById(pendingServiceOrderList);
         ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "服务类订单待处理记录批量更新失败");
-        } else {
+    }
 
-            // 恢复商品库存
+
+
+
+
+
+    /**
+     * 根据订单号获取订单信息
+     */
+    private Order getOrderInfoByOrderNumber(String orderNumber) {
+        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("orderNumber", orderNumber);
+        Order order = orderService.getOne(queryWrapper);
+        ThrowUtils.throwIf(order == null, ErrorCode.OPERATION_ERROR, "订单不存在");
+        return order;
+    }
+
+
+
+
+
+
+    /**
+     * 生成退款记录
+     */
+    private void createRefundRecord(RefundNotification refundNotification) {
+        RefundRecord refundRecord = new RefundRecord();
+        refundRecord.setOutTradeNo(refundNotification.getOutTradeNo());
+        refundRecord.setOutRefundNo(refundNotification.getOutRefundNo());
+        refundRecord.setRefundAmount(BigDecimal.valueOf(refundNotification.getAmount().getRefund()));
+
+        boolean save = refundRecordService.save(refundRecord);
+        ThrowUtils.throwIf(!save, ErrorCode.OPERATION_ERROR, "退款记录生成失败");
+    }
+
+
+
+
+
+
+    /**
+     * 修改订单状态
+     */
+    private void modifyOrderStatus(Order order, String orderStatus) {
+        order.setOrderStatus(orderStatus);
+        order.setUpdateTime(DateUtil.date());
+        boolean update = orderService.updateById(order);
+        ThrowUtils.throwIf(!update, ErrorCode.OPERATION_ERROR, "订单状态修改失败");
+    }
+
+
+
+
+    /**
+     * 恢复商品库存
+     */
+    private void recoverGoodInventory(String orderId) {
         QueryWrapper<OrderItems> orderItemsQueryWrapper = new QueryWrapper<>();
-            orderItemsQueryWrapper.eq("orderId", order.getId());
+        orderItemsQueryWrapper.eq("orderId", orderId);
         List<OrderItems> orderItemsList = orderItemService.list(orderItemsQueryWrapper);
         // 获取商品id列表
         List<Long> goodIds = orderItemsList.stream().map(orderItems -> {
@@ -402,66 +502,32 @@ public class WeChatServiceImpl implements WeChatService {
         }
         boolean updateBatch = goodService.updateBatchById(goodList);
         ThrowUtils.throwIf(!updateBatch, ErrorCode.SYSTEM_ERROR, "商品库存恢复失败");
-
-            System.out.println("---------------------------微信退款回调（结束）-------------------------------");
     }
 
 
-        return true;
-    }
 
 
 
 
     /**
-     * 部分退款回调
+     * 获取支付回调信息
      */
     @Override
-    public boolean refundPartCallback(RefundNotification refundNotification) {
+    public Transaction getTransactionInfo(HttpServletRequest request) {
-        System.out.println("---------------------------微信退款回调（开始）-------------------------------");
+        NotificationParser notificationParser = getNotificationParser(request);
-        // 获取订单信息
+        return notificationParser.parse(requestParam, Transaction.class);
-        String orderIdByString = refundNotification.getOutTradeNo();
-        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
-        queryWrapper.eq("orderNumber", orderIdByString);
-        Order order = orderService.getOne(queryWrapper);
-        if (order == null) {
-            log.error("订单不存在");
-            throw new BusinessException(ErrorCode.NOT_FOUND_ERROR, "订单不存在，订单号：" + orderIdByString);
     }
 
-        // 生成退款记录
-        RefundRecord refundRecord = new RefundRecord();
-        refundRecord.setOutTradeNo(refundNotification.getOutTradeNo());
-        refundRecord.setOutRefundNo(refundNotification.getOutRefundNo());
-        refundRecord.setRefundAmount(order.getTotalAmount());
-
-        boolean save = refundRecordService.save(refundRecord);
-        ThrowUtils.throwIf(!save, ErrorCode.OPERATION_ERROR, "退款记录生成失败");
 
 
-        String outRefundNo = refundNotification.getOutRefundNo();
+    /**
-        String orderItemId = RefundUtils.parseRefundNoToItemId(outRefundNo);
+     * 获取退款回调信息
-
+     */
-        GoodTypeEnum orderTypeEnum = GoodTypeEnum.getEnumByValue(order.getOrderType());
+    @Override
-        if (GoodTypeEnum.SERVICE.equals(orderTypeEnum)) {
+    public RefundNotification getRefundInfo(HttpServletRequest request) {
-            // 更新服务类订单待处理记录
+        NotificationParser notificationParser = getNotificationParser(request);
-            UpdateWrapper<PendingServiceOrder> updateWrapper = new UpdateWrapper<>();
+        return notificationParser.parse(requestParam, RefundNotification.class);
-            updateWrapper.eq("orderItemId", orderItemId).set("orderItemStatus", OrderStatusConstant.PAYMENT_REFUNDED);
-            boolean update = pendingServiceOrderService.update(updateWrapper);
-            ThrowUtils.throwIf(!update, ErrorCode.OPERATION_ERROR, "服务类订单待处理记录状态更新失败");
-        } else {
-            // 恢复商品库存
-            OrderItems orderItems = orderItemService.getById(orderItemId);
-            Long id = orderItems.getGoodSnapshot().getId();
-            Good good = goodService.getById(id);
-            ThrowUtils.throwIf(good == null, ErrorCode.OPERATION_ERROR, "当前商品不存在");
-            good.setInventory(good.getInventory() + orderItems.getQuantity());
-            boolean update = goodService.updateById(good);
-            ThrowUtils.throwIf(!update, ErrorCode.OPERATION_ERROR, "商品库存恢复失败");
     }
-        return true;
-    }
-
 
 //
 //    @Override