backend/java-mall
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

用户提交取消订单流程修改

Browse Source
This commit is contained in:
Jack 2025-12-08 17:08:08 +08:00
parent 992f25a224
commit eb8fb4a4e9
2 changed files with 126 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
mall-shop/src/main/java/com/suisung/mall/shop/order/service/ShopOrderBaseService.java
View File

@ -459,20 +459,20 @@ public interface ShopOrderBaseService extends IBaseService<ShopOrderBase> {
* *
* @param order_id * @param order_id
* @param shopOrderInfo * @param shopOrderInfo
* @param check_paid_flag * @param checkPaidState 订单是否未支付，默认值 true
* @return * @return
*/ */
boolean cancel(String order_id, ShopOrderInfo shopOrderInfo, boolean check_paid_flag); boolean cancel(String order_id, ShopOrderInfo shopOrderInfo, boolean checkPaidState);
/** /**
* 取消订单 * 取消订单
* *
* @param order_ids * @param order_ids
* @param order_rows * @param order_rows
* @param check_paid_flag * @param isNotPaid 订单是否未支付，默认值 true
* @return * @return
*/ */
boolean cancel(List<String> order_ids, List<Map> order_rows, boolean check_paid_flag); boolean cancel(List<String> order_ids, List<Map> order_rows, boolean isNotPaid);
void exportFile(HttpServletResponse response, ShopOrderBase shopOrderBase, List<String> order_ids); void exportFile(HttpServletResponse response, ShopOrderBase shopOrderBase, List<String> order_ids);

210
mall-shop/src/main/java/com/suisung/mall/shop/order/service/impl/ShopOrderBaseServiceImpl.java
View File

@ -1087,7 +1087,7 @@ public class ShopOrderBaseServiceImpl extends BaseServiceImpl<ShopOrderBaseMappe
} }
base_row.put("if_lock", base_row.get("order_lock_status")); base_row.put("if_lock", base_row.get("order_lock_status"));
base_row.put("if_buyer_cancel", ifCancel(order_state_id, order_is_paid)); base_row.put("if_buyer_cancel", isOrderCancelable(order_state_id, order_is_paid));
base_row.put("if_logistics", ifLogistics(order_state_id)); base_row.put("if_logistics", ifLogistics(order_state_id));
base_row.put("if_receive", ifReceive(order_state_id)); base_row.put("if_receive", ifReceive(order_state_id));
@ -4127,114 +4127,137 @@ public class ShopOrderBaseServiceImpl extends BaseServiceImpl<ShopOrderBaseMappe
* 取消订单 * 取消订单
* 流程：订单状态；积分、众宝、库存、礼包、优惠券 有就统统退还 * 流程：订单状态；积分、众宝、库存、礼包、优惠券 有就统统退还
* *
* @param order_ids 订单id * @param orderIds 订单id列表
* @param order_rows 订单数据 * @param orderRows 订单数据
* @param check_paid_flag 默认值 true * @param checkPaidState 实付检查订单支付状态，默认值 true
*/ */
@Transactional @Transactional
public boolean cancel(List<String> order_ids, List<Map> order_rows, boolean check_paid_flag) { public boolean cancel(List<String> orderIds, List<Map> orderRows, boolean checkPaidState) {
List<String> cancel_id_row = new ArrayList<>(order_ids.size()); List<String> cancelIdRow = new ArrayList<>(orderIds.size());
// 检测数据是否合法,过滤允许修改的数据 // 检测数据是否合法,过滤允许修改的数据
if (CollUtil.isEmpty(order_ids)) { if (CollUtil.isEmpty(orderIds)) {
throw new ApiException(I18nUtil._("请选择需要取消的订单")); throw new ApiException(I18nUtil._("请选择需要取消的订单"));
} }
if (CollUtil.isEmpty(order_rows)) { if (CollUtil.isEmpty(orderRows)) {
order_rows = Convert.toList(Map.class, shopOrderInfoService.gets(order_ids)); orderRows = Convert.toList(Map.class, shopOrderInfoService.gets(orderIds));
} }
for (String order_id : order_ids) { // 筛选可取消的订单
Optional<Map> orderOpl = order_rows.stream().filter(s -> ObjectUtil.equal(order_id, Convert.toStr(s.get("order_id")))).findFirst(); for (String orderId : orderIds) {
Map order = orderOpl.orElseGet(HashMap::new); Optional<Map> orderOpt = orderRows.stream()
.filter(s -> ObjectUtil.equal(orderId, Convert.toStr(s.get("order_id"))))
.findFirst();
Map order = orderOpt.orElseGet(HashMap::new);
// 订单状态(LIST):2011-待订单审核;2013-待财务审核;2020-待配货/待出库审核;2030-待发货;2040-已发货/待收货确认;2060-已完成/已签收;2070-已取消/已作废; // 订单状态(LIST):2011-待订单审核;2013-待财务审核;2020-待配货/待出库审核;2030-待发货;2040-已发货/待收货确认;2060-已完成/已签收;2070-已取消/已作废;
Integer order_state_id = (Integer) order.get("order_state_id"); Integer orderStateId = (Integer) order.get("order_state_id");
// 付款状态(ENUM):3010-未付款;3011-付款待审核;3012-部分付款;3013-已付款 // 付款状态(ENUM):3010-未付款;3011-付款待审核;3012-部分付款;3013-已付款
Integer order_is_paid = (Integer) order.get("order_is_paid"); Integer orderIsPaid = (Integer) order.get("order_is_paid");
// 要检查订单付款状态
if (check_paid_flag) { // 根据是否检查支付状态来判断订单是否可取消
if (ifCancel(order_state_id, order_is_paid)) { if (checkPaidState) {
// 未付款，未配送的订单才能取消订单 // 检查订单是否可以取消（未付款且处于特定状态）
cancel_id_row.add(order_id); if (isOrderCancelable(orderStateId, orderIsPaid)) {
cancelIdRow.add(orderId);
} else {
// 订单已支付，检查是否允许退款
boolean isOrderDenyReturn = shopOrderReturnService.isOrderDenyReturn(orderId);
if (!isOrderDenyReturn) {
// 支付的订单允许退款，立即发起退款流程，再由商家审核
CommonResult refundResult = shopOrderReturnService.addRemainingItems(orderId, false, "用户取消订单");
if (refundResult == null || refundResult.getStatus() != 200) {
logger.error("提交订单审核失败！");
return false;
}
return true;
}
} }
} else { } else {
// 不检查订单付款状态 // 不检查订单付款状态，直接加入可取消列表
cancel_id_row.add(order_id); cancelIdRow.add(orderId);
} }
} }
if (CollUtil.isEmpty(cancel_id_row)) { if (CollUtil.isEmpty(cancelIdRow)) {
throw new ApiException(I18nUtil._("无符合取消条件的订单！")); throw new ApiException(I18nUtil._("无符合取消条件的订单！"));
} }
order_ids = cancel_id_row; orderIds = cancelIdRow;
// 更新订单主表状态为已取消
ShopOrderBase orderBase = new ShopOrderBase(); ShopOrderBase orderBase = new ShopOrderBase();
orderBase.setOrder_state_id(StateCode.ORDER_STATE_CANCEL); orderBase.setOrder_state_id(StateCode.ORDER_STATE_CANCEL);
QueryWrapper<ShopOrderBase> baseQueryWrapper = new QueryWrapper<>(); QueryWrapper<ShopOrderBase> baseQueryWrapper = new QueryWrapper<>();
baseQueryWrapper.in("order_id", order_ids); baseQueryWrapper.in("order_id", orderIds);
baseQueryWrapper.ne("order_state_id", StateCode.ORDER_STATE_CANCEL); // 2070-已取消 baseQueryWrapper.ne("order_state_id", StateCode.ORDER_STATE_CANCEL); // 2070-已取消
if (!edit(orderBase, baseQueryWrapper)) {// 批量更改状态 if (!edit(orderBase, baseQueryWrapper)) { // 批量更改状态
throw new ApiException(ResultCode.FAILED); throw new ApiException(ResultCode.FAILED);
} }
// 更新订单信息表状态为已取消
ShopOrderInfo shopOrderInfo = new ShopOrderInfo(); ShopOrderInfo shopOrderInfo = new ShopOrderInfo();
shopOrderInfo.setOrder_state_id(StateCode.ORDER_STATE_CANCEL); shopOrderInfo.setOrder_state_id(StateCode.ORDER_STATE_CANCEL);
QueryWrapper<ShopOrderInfo> infoQueryWrapper = new QueryWrapper<>(); QueryWrapper<ShopOrderInfo> infoQueryWrapper = new QueryWrapper<>();
infoQueryWrapper.in("order_id", cancel_id_row); infoQueryWrapper.in("order_id", cancelIdRow);
infoQueryWrapper.ne("order_state_id", StateCode.ORDER_STATE_CANCEL); infoQueryWrapper.ne("order_state_id", StateCode.ORDER_STATE_CANCEL);
if (!shopOrderInfoService.edit(shopOrderInfo, infoQueryWrapper)) { if (!shopOrderInfoService.edit(shopOrderInfo, infoQueryWrapper)) {
throw new ApiException(String.format("订单:%s 取消状态有误!", CollUtil.join(cancel_id_row, ","))); throw new ApiException(String.format("订单:%s 取消状态有误!", CollUtil.join(cancelIdRow, ",")));
} }
// 积分退还 order_resource_ext1 默认为积分。 // 积分退还 order_resource_ext1 默认为积分。
List<ShopOrderData> order_data_rows = shopOrderDataService.gets(order_ids); List<ShopOrderData> orderDataRows = shopOrderDataService.gets(orderIds);
for (ShopOrderData order_data_row : order_data_rows) { for (ShopOrderData orderDataRow : orderDataRows) {
String orderId = order_data_row.getOrder_id(); String orderId = orderDataRow.getOrder_id();
Optional<Map> orderOpl = order_rows.stream().filter(s -> ObjectUtil.equal(orderId, Convert.toStr(s.get("order_id")))).findFirst(); Optional<Map> orderOpt = orderRows.stream()
Map order = orderOpl.orElseGet(HashMap::new); .filter(s -> ObjectUtil.equal(orderId, Convert.toStr(s.get("order_id"))))
.findFirst();
Map order = orderOpt.orElseGet(HashMap::new);
Integer buyer_user_id = (Integer) order.get("buyer_user_id"); Integer buyerUserId = (Integer) order.get("buyer_user_id");
BigDecimal order_resource_ext1 = order_data_row.getOrder_resource_ext1();// 积分 BigDecimal orderResourceExt1 = orderDataRow.getOrder_resource_ext1(); // 积分
BigDecimal order_resource_ext2 = order_data_row.getOrder_resource_ext2();// 众宝 BigDecimal orderResourceExt2 = orderDataRow.getOrder_resource_ext2(); // 众宝
if (ObjectUtil.compare(order_resource_ext1, BigDecimal.ZERO) > 0 && CheckUtil.isNotEmpty(buyer_user_id)) { // 退还积分
Integer store_id = (Integer) order.get("store_id"); if (ObjectUtil.compare(orderResourceExt1, BigDecimal.ZERO) > 0 && CheckUtil.isNotEmpty(buyerUserId)) {
Integer storeId = (Integer) order.get("store_id");
// 扣除积分 // 扣除积分
String desc = String.format("%s 积分退还，订单号 %s", order_resource_ext1, order_data_row.getOrder_id()); String desc = String.format("%s 积分退还，订单号 %s", orderResourceExt1, orderDataRow.getOrder_id());
if (!payService.points(buyer_user_id, order_resource_ext1, PointsType.POINTS_TYPE_CONSUME_RETRUN, desc, store_id, null, order_data_row.getOrder_id())) { if (!payService.points(buyerUserId, orderResourceExt1, PointsType.POINTS_TYPE_CONSUME_RETRUN, desc, storeId, null, orderDataRow.getOrder_id())) {
throw new ApiException(I18nUtil._("积分操作失败！")); throw new ApiException(I18nUtil._("积分操作失败！"));
} }
} }
// 程序没有编写完成，缺失众宝积分退回功能 // 程序没有编写完成，缺失众宝积分退回功能
//if (ObjectUtil.compare(order_resource_ext2, BigDecimal.ZERO) > 0 && CheckUtil.isNotEmpty(buyer_user_id)) { // if (ObjectUtil.compare(orderResourceExt2, BigDecimal.ZERO) > 0 && CheckUtil.isNotEmpty(buyerUserId)) {
// String desc = String.format("%s 众宝退还", order_resource_ext2); // String desc = String.format("%s 众宝退还", orderResourceExt2);
// todo shopUserPointsHistoryService.sp(buyer_user_id,order_resource_ext2,SpType.SP_TYPE_CONSUME_RETRUN, desc); // todo shopUserPointsHistoryService.sp(buyerUserId, orderResourceExt2, SpType.SP_TYPE_CONSUME_RETRUN, desc);
//} // }
} }
// 限购商品数量退还 // 限购商品数量退还
QueryWrapper<ShopOrderItem> itemQueryWrapper = new QueryWrapper<>(); QueryWrapper<ShopOrderItem> itemQueryWrapper = new QueryWrapper<>();
itemQueryWrapper.in("order_id", order_ids); itemQueryWrapper.in("order_id", orderIds);
List<ShopOrderItem> order_item_rows = shopOrderItemService.find(itemQueryWrapper); List<ShopOrderItem> orderItemRows = shopOrderItemService.find(itemQueryWrapper);
for (ShopOrderItem order_item_row : order_item_rows) {
for (ShopOrderItem orderItemRow : orderItemRows) {
// 退还用户购买数量限制
QueryWrapper<ShopUserProductBuy> buyQueryWrapper = new QueryWrapper<>(); QueryWrapper<ShopUserProductBuy> buyQueryWrapper = new QueryWrapper<>();
buyQueryWrapper.eq("product_id", order_item_row.getProduct_id()); buyQueryWrapper.eq("product_id", orderItemRow.getProduct_id());
buyQueryWrapper.eq("item_id", order_item_row.getItem_id()); buyQueryWrapper.eq("item_id", orderItemRow.getItem_id());
buyQueryWrapper.eq("user_id", order_item_row.getBuyer_id()); buyQueryWrapper.eq("user_id", orderItemRow.getBuyer_id());
List<ShopUserProductBuy> productBuyList = shopUserProductBuyService.find(buyQueryWrapper); List<ShopUserProductBuy> productBuyList = shopUserProductBuyService.find(buyQueryWrapper);
Integer order_item_quantity = order_item_row.getOrder_item_quantity(); Integer orderItemQuantity = orderItemRow.getOrder_item_quantity();
if (CollUtil.isNotEmpty(productBuyList)) { if (CollUtil.isNotEmpty(productBuyList)) {
// 减少用户的已购买数量
for (ShopUserProductBuy productBuy : productBuyList) { for (ShopUserProductBuy productBuy : productBuyList) {
productBuy.setProduct_buy_num(productBuy.getProduct_buy_num() - order_item_quantity); productBuy.setProduct_buy_num(productBuy.getProduct_buy_num() - orderItemQuantity);
} }
if (!shopUserProductBuyService.saveOrUpdate(productBuyList)) { if (!shopUserProductBuyService.saveOrUpdate(productBuyList)) {
@ -4242,29 +4265,29 @@ public class ShopOrderBaseServiceImpl extends BaseServiceImpl<ShopOrderBaseMappe
} }
} }
// start 释放冻结库存 // 释放冻结库存
// order_item_inventory_lock: 库存锁定(ENUM):1001-下单锁定;1002-支付锁定; // order_item_inventory_lock: 库存锁定(ENUM):1001-下单锁定;1002-支付锁定;
Integer order_item_inventory_lock = order_item_row.getOrder_item_inventory_lock(); Integer orderItemInventoryLock = orderItemRow.getOrder_item_inventory_lock();
if (ObjectUtil.equal(order_item_inventory_lock, 1001) || ObjectUtil.equal(order_item_inventory_lock, 1002)) { if (ObjectUtil.equal(orderItemInventoryLock, 1001) || ObjectUtil.equal(orderItemInventoryLock, 1002)) {
Long item_id = order_item_row.getItem_id(); Long itemId = orderItemRow.getItem_id();
ShopProductItem shopProductItem = shopProductItemService.get(item_id); ShopProductItem shopProductItem = shopProductItemService.get(itemId);
if (shopProductItem != null && CheckUtil.isNotEmpty(shopProductItem.getItem_src_id())) { if (shopProductItem != null && CheckUtil.isNotEmpty(shopProductItem.getItem_src_id())) {
shopProductItem.setItem_quantity_frozen(shopProductItem.getItem_quantity_frozen() - order_item_quantity); shopProductItem.setItem_quantity_frozen(shopProductItem.getItem_quantity_frozen() - orderItemQuantity);
if (!shopProductItemService.edit(shopProductItem)) { if (!shopProductItemService.edit(shopProductItem)) {
throw new ApiException(String.format(I18nUtil._("释放: %s 冻结库存失败!"), order_item_row.getItem_id())); throw new ApiException(String.format(I18nUtil._("释放: %s 冻结库存失败!"), orderItemRow.getItem_id()));
} }
log.debug("释放库存Item_src_id:{},数量：{}", shopProductItem.getItem_src_id(), order_item_quantity); log.debug("释放库存Item_src_id:{},数量：{}", shopProductItem.getItem_src_id(), orderItemQuantity);
// RMK 第三方数据同步相关：redis 给这个商品加上对应的库存 // RMK 第三方数据同步相关：redis 给这个商品加上对应的库存
// Map<String, Integer> stockDeltaMap = new HashMap<>(); // Map<String, Integer> stockDeltaMap = new HashMap<>();
// stockDeltaMap.put(shopProductItem.getItem_src_id() + "-" + order_item_row.getOrder_id(), order_item_quantity); // stockDeltaMap.put(shopProductItem.getItem_src_id() + "-" + orderItemRow.getOrder_id(), orderItemQuantity);
// syncThirdDataService.incrProductStockToRedis(stockDeltaMap); // syncThirdDataService.incrProductStockToRedis(stockDeltaMap);
} }
} }
// 退还礼包活动 // 退还礼包活动
if (order_item_row.getActivity_type_id().equals(StateCode.ACTIVITY_TYPE_GIFTPACK)) { if (orderItemRow.getActivity_type_id().equals(StateCode.ACTIVITY_TYPE_GIFTPACK)) {
QueryWrapper<ShopStoreActivityCode> queryWrapper = new QueryWrapper<>(); QueryWrapper<ShopStoreActivityCode> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("exchange_code", order_item_row.getActivity_code()); queryWrapper.eq("exchange_code", orderItemRow.getActivity_code());
ShopStoreActivityCode shopStoreActivityCode = shopStoreActivityCodeService.findOne(queryWrapper); ShopStoreActivityCode shopStoreActivityCode = shopStoreActivityCodeService.findOne(queryWrapper);
shopStoreActivityCode.setUser_id(0); shopStoreActivityCode.setUser_id(0);
shopStoreActivityCode.setOrder_id(""); shopStoreActivityCode.setOrder_id("");
@ -4277,18 +4300,21 @@ public class ShopOrderBaseServiceImpl extends BaseServiceImpl<ShopOrderBaseMappe
// 退还优惠券 // 退还优惠券
QueryWrapper<ShopUserVoucher> voucherQueryWrapper = new QueryWrapper<>(); QueryWrapper<ShopUserVoucher> voucherQueryWrapper = new QueryWrapper<>();
voucherQueryWrapper.in("order_id", order_ids); voucherQueryWrapper.in("order_id", orderIds);
List<ShopUserVoucher> userVouchers = shopUserVoucherService.find(voucherQueryWrapper); List<ShopUserVoucher> userVouchers = shopUserVoucherService.find(voucherQueryWrapper);
if (CollUtil.isNotEmpty(userVouchers)) { if (CollUtil.isNotEmpty(userVouchers)) {
userVouchers = userVouchers.stream().map(userVoucher -> userVoucher.setVoucher_state_id(StateCode.VOUCHER_STATE_UNUSED)).collect(Collectors.toList()); // 将已使用的优惠券状态重置为未使用
userVouchers = userVouchers.stream()
.map(userVoucher -> userVoucher.setVoucher_state_id(StateCode.VOUCHER_STATE_UNUSED))
.collect(Collectors.toList());
if (!shopUserVoucherService.edit(userVouchers)) { if (!shopUserVoucherService.edit(userVouchers)) {
throw new ApiException(I18nUtil._("退还优惠券失败！")); throw new ApiException(I18nUtil._("退还优惠券失败！"));
} }
} }
// 取消拼团 // 取消拼团活动
for (String order_id : order_ids) { for (String orderId : orderIds) {
cancelActivity(order_id); cancelActivity(orderId);
} }
return true; return true;
@ -5227,7 +5253,7 @@ public class ShopOrderBaseServiceImpl extends BaseServiceImpl<ShopOrderBaseMappe
} }
/** /**
* 取消订单 * 用户C端发起取消订单操作（2025年改进：支付前后都可以取消订单）
* *
* @param order_id * @param order_id
* @return * @return
@ -5250,7 +5276,8 @@ public class ShopOrderBaseServiceImpl extends BaseServiceImpl<ShopOrderBaseMappe
List<ShopOrderInfo> shopOrderInfos = shopOrderInfoService.gets(order_ids); List<ShopOrderInfo> shopOrderInfos = shopOrderInfoService.gets(order_ids);
List<Map> rows = Convert.toList(Map.class, shopOrderInfos); List<Map> rows = Convert.toList(Map.class, shopOrderInfos);
// 检查登录用户和订单店铺是否有权限操作取消动作 // 检查登录用户和订单店铺是否有权限操作取消动作
if (CheckUtil.checkDataRights(user_id, rows, "buyer_user_id") || CheckUtil.checkDataRights(Convert.toInt(user.getStore_id()), rows, "store_id")) { if (CheckUtil.checkDataRights(user_id, rows, "buyer_user_id")
|| CheckUtil.checkDataRights(Convert.toInt(user.getStore_id()), rows, "store_id")) {
cancel(order_ids, rows, true); cancel(order_ids, rows, true);
} else { } else {
throw new ApiException(ResultCode.FORBIDDEN); throw new ApiException(ResultCode.FORBIDDEN);
@ -5267,12 +5294,12 @@ public class ShopOrderBaseServiceImpl extends BaseServiceImpl<ShopOrderBaseMappe
* *
* @param order_id * @param order_id
* @param shopOrderInfo * @param shopOrderInfo
* @param check_paid_flag 默认true * @param checkPaidState 是否检查订单支付状态？ 默认true
* @return * @return
*/ */
@Override @Override
@Transactional @Transactional
public boolean cancel(String order_id, ShopOrderInfo shopOrderInfo, boolean check_paid_flag) { public boolean cancel(String order_id, ShopOrderInfo shopOrderInfo, boolean checkPaidState) {
// 检测数据是否合法,过滤允许修改的数据 // 检测数据是否合法,过滤允许修改的数据
if (StrUtil.isBlank(order_id)) { if (StrUtil.isBlank(order_id)) {
throw new ApiException(I18nUtil._("请选择需要取消的订单！")); throw new ApiException(I18nUtil._("请选择需要取消的订单！"));
@ -5285,7 +5312,7 @@ public class ShopOrderBaseServiceImpl extends BaseServiceImpl<ShopOrderBaseMappe
Integer order_state_id = shopOrderInfo.getOrder_state_id(); Integer order_state_id = shopOrderInfo.getOrder_state_id();
Integer order_is_paid = shopOrderInfo.getOrder_is_paid(); Integer order_is_paid = shopOrderInfo.getOrder_is_paid();
if (check_paid_flag && !ifCancel(order_state_id, order_is_paid)) { if (checkPaidState && !isOrderCancelable(order_state_id, order_is_paid)) {
throw new ApiException(I18nUtil._("无符合取消条件的订单！")); throw new ApiException(I18nUtil._("无符合取消条件的订单！"));
} }
@ -5315,7 +5342,6 @@ public class ShopOrderBaseServiceImpl extends BaseServiceImpl<ShopOrderBaseMappe
// 取消顺丰同城配送订单 // 取消顺丰同城配送订单
// === 7. 特殊场景：顺丰同城配送、且全单退的时候，才触发顺丰同城订单取消 === // === 7. 特殊场景：顺丰同城配送、且全单退的时候，才触发顺丰同城订单取消 ===
if (shopOrderInfo.getDelivery_type_id() != null if (shopOrderInfo.getDelivery_type_id() != null
&& StateCode.DELIVERY_TYPE_SAME_CITY == shopOrderInfo.getDelivery_type_id().intValue()) { && StateCode.DELIVERY_TYPE_SAME_CITY == shopOrderInfo.getDelivery_type_id().intValue()) {
try { try {
@ -5329,7 +5355,6 @@ public class ShopOrderBaseServiceImpl extends BaseServiceImpl<ShopOrderBaseMappe
} }
} catch (Exception e) { } catch (Exception e) {
log.error("顺丰同城取消订单异常，orderId: {}", order_id, e); log.error("顺丰同城取消订单异常，orderId: {}", order_id, e);
// 可以考虑添加补偿机制或异步重试
} }
} }
@ -8373,7 +8398,7 @@ public class ShopOrderBaseServiceImpl extends BaseServiceImpl<ShopOrderBaseMappe
Integer payment_type_id = Convert.toInt(order_info_row.get("payment_type_id")); Integer payment_type_id = Convert.toInt(order_info_row.get("payment_type_id"));
Integer order_is_paid = Convert.toInt(order_info_row.get("order_is_paid")); Integer order_is_paid = Convert.toInt(order_info_row.get("order_is_paid"));
order_info_row.put("if_buyer_cancel", ifCancel(order_state_id, order_is_paid)); order_info_row.put("if_buyer_cancel", isOrderCancelable(order_state_id, order_is_paid));
order_info_row.put("if_logistics", ifLogistics(order_state_id)); order_info_row.put("if_logistics", ifLogistics(order_state_id));
order_info_row.put("order_shipping_fee", order_data_row.get("order_shipping_fee")); order_info_row.put("order_shipping_fee", order_data_row.get("order_shipping_fee"));
order_info_row.put("order_payment_name", shopBaseStateCodeService.getText(payment_type_id, null)); order_info_row.put("order_payment_name", shopBaseStateCodeService.getText(payment_type_id, null));
@ -8408,17 +8433,26 @@ public class ShopOrderBaseServiceImpl extends BaseServiceImpl<ShopOrderBaseMappe
} }
/** /**
* 检查是否可以取消？ * 检查订单是否可以取消
* 只有未付款且处于特定状态的订单才能取消
* *
* @param order_state_id 订单状态 * @param orderStateId 订单状态ID
* @param order_is_paid * @param orderIsPaid 订单付款状态
* @return boolean true-可，false-不可 * @return boolean true-可以取消，false-不可以取消
*/ */
private boolean ifCancel(Integer order_state_id, Integer order_is_paid) { private boolean isOrderCancelable(Integer orderStateId, Integer orderIsPaid) {
// 订单状态：2010-待付款;2011-待订单审核;2013-待财务审核;2020-待配货;2030-待发货 // 可以取消订单的状态列表：待付款、待审核、待财务审核、待配货、待发货
List<Integer> order_states = Arrays.asList(StateCode.ORDER_STATE_WAIT_PAY, StateCode.ORDER_STATE_WAIT_REVIEW, StateCode.ORDER_STATE_WAIT_FINANCE_REVIEW, StateCode.ORDER_STATE_PICKING, StateCode.ORDER_STATE_WAIT_SHIPPING); List<Integer> cancelableStates = Arrays.asList(
// 3010-未付款，未付款的订单才能取消 StateCode.ORDER_STATE_WAIT_PAY,
return order_states.contains(order_state_id) && ObjectUtil.equal(order_is_paid, StateCode.ORDER_PAID_STATE_NO); StateCode.ORDER_STATE_WAIT_REVIEW,
StateCode.ORDER_STATE_WAIT_FINANCE_REVIEW,
StateCode.ORDER_STATE_PICKING,
StateCode.ORDER_STATE_WAIT_SHIPPING
);
// 订单必须处于可取消状态且未付款才能取消
return cancelableStates.contains(orderStateId) &&
ObjectUtil.equal(orderIsPaid, StateCode.ORDER_PAID_STATE_NO);
} }
// QueryWrapper<ShopOrderInfo> queryWrapper, // QueryWrapper<ShopOrderInfo> queryWrapper,