admin1/jiangchengfeiyi-houduan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

更新了服务类订单模块

Browse Source
This commit is contained in:
chen-xin-zhi 2025-02-13 21:34:21 +08:00
parent b4dadea685
commit 6a269c5dc1
5 changed files with 389 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/main/java/com/cultural/heritage/controller/good/CategoryController.java
View File

@ -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获取商品删除的条件
QueryWrapper<Good> queryWrapper = categoryService.getDeleteQueryWrapper(id);
Category category = categoryService.getCategoryById(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);
return ResultUtils.success(true, "类别删除成功");
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "类别删除失败");
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 -> {
// 根据类别id获取商品删除的条件
QueryWrapper<Good> queryWrapper = categoryService.getDeleteQueryWrapper(id);
List<Good> goodList = goodService.list(queryWrapper);
// 如果该类别下有商品，就删除
if (!CollectionUtils.isEmpty(goodList)) {
boolean isSuccess = goodService.removeBatchByIds(goodList);
ThrowUtils.throwIf(!isSuccess, ErrorCode.OPERATION_ERROR);
}
// 删除当前类别
boolean result = categoryService.removeById(id);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR);
});
// 批量删除当前类别下的所有商品
List<Category> categoryList = commonService.getListByIds(idList, categoryService);
List<String> typeNameList = categoryList.stream().map(Category::getTypeName).toList();
QueryWrapper<Good> queryWrapper = new QueryWrapper<>();
queryWrapper.in("type", typeNameList);
List<Good> goodList = goodService.list(queryWrapper);
// 如果该类别下有商品，就删除
if (!goodList.isEmpty()) {
boolean result = goodService.removeBatchByIds(goodList);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "商品批量删除失败");
}
// 批量删除当前类别
boolean remove = categoryService.removeBatchByIds(categoryList);
ThrowUtils.throwIf(!remove, ErrorCode.OPERATION_ERROR, "类别批量删除失败");
return ResultUtils.success(true, "批量删除类别成功");
}

19
src/main/java/com/cultural/heritage/controller/order/OrderController.java
View File

@ -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 {
}

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

@ -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;

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

@ -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, "服务类订单待处理记录批量生成失败");
}
/**
* 扣减常规类商品库存
*/

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

@ -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();
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, "订单不存在，订单号：" + transaction.getOutTradeNo());
}
String orderNumber = transaction.getOutTradeNo();
Order order = getOrderInfoByOrderNumber(orderNumber);
// 修改订单状态
order.setOrderStatus(OrderStatusConstant.PENDING_SHIPMENT);
order.setUpdateTime(DateUtil.date());
boolean update = orderService.updateById(order);
ThrowUtils.throwIf(!update, ErrorCode.OPERATION_ERROR, "订单状态修改失败");
modifyOrderStatus(order, OrderStatusConstant.PENDING_SHIPMENT);
// 生成服务类订单待处理记录
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, "服务类订单待处理记录批量生成失败");
boolean isGeneral = orderService.isGeneralGood(order.getOrderType());
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<>();
pendingServiceOrderQueryWrapper.eq("orderItemId", orderItemsId);
PendingServiceOrder pendingServiceOrder = pendingServiceOrderService.getOne(pendingServiceOrderQueryWrapper);
ThrowUtils.throwIf(pendingServiceOrder == null || !pendingServiceOrder.getOrderItemStatus().equals(OrderStatusConstant.PENDING_SHIPMENT), ErrorCode.OPERATION_ERROR, "服务类订单待处理记录不存在或者当前订单明细状态错误");
checkOrderItemStatus(orderItemsId);
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,21 +393,133 @@ public class WeChatServiceImpl implements WeChatService {
refundAmount = amount.subtract(itemCouponRefund);
}
}
refundAmount = refundAmount.movePointRight(2).setScale(0, RoundingMode.HALF_UP);
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;
return refundAmount;
}
/**
* 更新服务类商品订单待处理记录
*/
private void updatePendingServiceOrder(String orderNumber, String orderStatus) {
QueryWrapper<PendingServiceOrder> orderQueryWrapper = new QueryWrapper<>();
orderQueryWrapper.eq("orderNumber", orderNumber);
List<PendingServiceOrder> pendingServiceOrderList = pendingServiceOrderService.list(orderQueryWrapper);
for (PendingServiceOrder pendingServiceOrder : pendingServiceOrderList) {
pendingServiceOrder.setOrderItemStatus(orderStatus);
}
boolean result = pendingServiceOrderService.updateBatchById(pendingServiceOrderList);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "服务类订单待处理记录批量更新失败");
}
/**
* 根据订单号获取订单信息
*/
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", orderId);
List<OrderItems> orderItemsList = orderItemService.list(orderItemsQueryWrapper);
// 获取商品id列表
List<Long> goodIds = orderItemsList.stream().map(orderItems -> {
GoodSnapshot goodSnapshot = orderItems.getGoodSnapshot();
return goodSnapshot.getId();
}).toList();
QueryWrapper<Good> goodQueryWrapper = new QueryWrapper<>();
goodQueryWrapper.in("id", goodIds);
// 获取商品列表
List<Good> goodList = goodService.list(goodQueryWrapper);
// 封装为map集合（键：商品id, 值：库存量）,用来存储购买的商品id对应的购买数量
Map<Long, Integer> map = new HashMap<>();
for (OrderItems orderItems : orderItemsList) {
GoodSnapshot goodSnapshot = orderItems.getGoodSnapshot();
Long goodId = goodSnapshot.getId();
Integer quantity = orderItems.getQuantity();
map.put(goodId, quantity);
}
// 批量更新商品库存
for (Good good : goodList) {
Long goodId = good.getId();
// 已经下单购买的数量
Integer quantity = map.get(goodId);
// 原有的库存
Integer inventory = good.getInventory();
good.setInventory(quantity + inventory);
good.setUpdateTime(DateUtil.date());
}
boolean updateBatch = goodService.updateBatchById(goodList);
ThrowUtils.throwIf(!updateBatch, ErrorCode.SYSTEM_ERROR, "商品库存恢复失败");
}
/**
* 获取支付回调信息
*/
@Override
public Transaction getTransactionInfo(HttpServletRequest request) {
NotificationParser notificationParser = getNotificationParser(request);
return notificationParser.parse(requestParam, Transaction.class);
}
/**
* 获取退款回调信息
*/
@ -321,148 +529,6 @@ public class WeChatServiceImpl implements WeChatService {
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());
List<PendingServiceOrder> pendingServiceOrderList = pendingServiceOrderService.list(orderQueryWrapper);
for (PendingServiceOrder pendingServiceOrder : pendingServiceOrderList) {
pendingServiceOrder.setOrderItemStatus(OrderStatusConstant.PAYMENT_REFUNDED);
}
boolean result = pendingServiceOrderService.updateBatchById(pendingServiceOrderList);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "服务类订单待处理记录批量更新失败");
} else {
// 恢复商品库存
QueryWrapper<OrderItems> orderItemsQueryWrapper = new QueryWrapper<>();
orderItemsQueryWrapper.eq("orderId", order.getId());
List<OrderItems> orderItemsList = orderItemService.list(orderItemsQueryWrapper);
// 获取商品id列表
List<Long> goodIds = orderItemsList.stream().map(orderItems -> {
GoodSnapshot goodSnapshot = orderItems.getGoodSnapshot();
return goodSnapshot.getId();
}).toList();
QueryWrapper<Good> goodQueryWrapper = new QueryWrapper<>();
goodQueryWrapper.in("id", goodIds);
// 获取商品列表
List<Good> goodList = goodService.list(goodQueryWrapper);
// 封装为map集合（键：商品id, 值：库存量）,用来存储购买的商品id对应的购买数量
Map<Long, Integer> map = new HashMap<>();
for (OrderItems orderItems : orderItemsList) {
GoodSnapshot goodSnapshot = orderItems.getGoodSnapshot();
Long goodId = goodSnapshot.getId();
Integer quantity = orderItems.getQuantity();
map.put(goodId, quantity);
}
// 批量更新商品库存
for (Good good : goodList) {
Long goodId = good.getId();
// 已经下单购买的数量
Integer quantity = map.get(goodId);
// 原有的库存
Integer inventory = good.getInventory();
good.setInventory(quantity + inventory);
good.setUpdateTime(DateUtil.date());
}
boolean updateBatch = goodService.updateBatchById(goodList);
ThrowUtils.throwIf(!updateBatch, ErrorCode.SYSTEM_ERROR, "商品库存恢复失败");
System.out.println("---------------------------微信退款回调（结束）-------------------------------");
}
return true;
}
/**
* 部分退款回调
*/
@Override
public boolean refundPartCallback(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);
}
// 生成退款记录
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());
if (GoodTypeEnum.SERVICE.equals(orderTypeEnum)) {
// 更新服务类订单待处理记录
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;
}
//
// @Override
// public boolean sendSubscribeMessage(String openid, String templateId) {