feat(order): 实现商家取消订单触发自动退款并同步状态

- HBOrderService中新增市民请集合订单取消时售后单处理逻辑
- 计算退款商品剩余数量并创建对应退款单，推送海博售后单
- XSBRefundOrderService新增商家取消退款标记，实现跳过关闭状态检查直接完成
- 退款详情接口增加订单、退款单、门店存在性校验及日志优化
- 新增对商家取消订单退款的统一处理流程，包括退款单创建和售后单同步
- 退款完成时同步海博订单状态为关闭，仅整单退款时更新状态
- 订单状态恢复逻辑完善，支持退款结束时恢复订单原状态并同步海博
- 规范订单查询用户属性类型，支持传入0查询全部用户属性
- OmsOrder新增prevHbOrderStatus字段记录退款前订单状态，便于状态恢复
- OMS层增强订单状态回调处理，忽略商家取消后非关闭状态回调
- 完善日志及异常处理，保证推送和状态变更流程稳定可靠

yami-shop-bean/src/main/java/com/yami/shop/bean/vo/xsb/RefundOrderPushVo.java

@@ -158,6 +158,11 @@ public class RefundOrderPushVo {
      */
     private Integer channelType;
 
+    /**
+     * 是否商家取消订单触发的退款（true时跳过CLOSE状态检查，直接创建状态70的退款单）
+     */
+    private Boolean merchantCancel;
+
     @Override
     public String toString() {
         return "RefundOrderPushVo{" +

yami-shop-platform/src/main/java/com/yami/shop/platform/controller/smqjh/XSBRefundOrderController.java

@@ -14,6 +14,7 @@ import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import java.util.Map;
 import java.util.UUID;
 
 /**
@@ -63,5 +64,16 @@ public class XSBRefundOrderController {
         return  xsbRefundOrderService.cancel(orderRefundCancelVo,string);
     }
 
+    /**
+     * 变更海博订单状态（OMS恢复订单状态时调用）
+     */
+    @PostMapping("/changeHbOrderStatus")
+    public R<String> changeHbOrderStatus(@RequestBody Map<String, Object> params) {
+        String orderNumber = (String) params.get("orderNumber");
+        Integer status = (Integer) params.get("status");
+        log.info("接收变更海博订单状态请求, orderNumber: {}, status: {}", orderNumber, status);
+        return xsbRefundOrderService.changeHbOrderStatus(orderNumber, status);
+    }
+
 
 }

yami-shop-service/src/main/java/com/yami/shop/service/hb/impl/HBOrderService.java

@@ -181,6 +181,11 @@ public class HBOrderService implements IHBOrderService {
         Integer operatorType = bodyJson.getInteger("operatorType");
         String channelOrderId = bodyJson.getString("channelOrderId");
         Order order = orderMapper.getOrderAndOrderItemByOrderNumber(channelOrderId);
+        if (order == null) {
+            log.error("海博订单状态回调-订单不存在，channelOrderId: {}", channelOrderId);
+            return;
+        }
+        boolean isSmqjhOrder = Objects.equals(order.getOrderType(), 4);
         //如果是已送达直接完成并且通知海博
         order.setHbOrderStatus(operatorType);
         if (operatorType == 70 && order.getDvyType() == 3) {
@@ -192,7 +197,7 @@ public class HBOrderService implements IHBOrderService {
         if (operatorType == 60) {
             log.info("取消订单{}", channelOrderId);
             changeOrderStatus(channelOrderId, 60);
-            if (!order.getOrderType().equals(4)) {
+            if (!isSmqjhOrder) {
                 //创建退款单
                 OrderRefundParam orderRefundParam = new OrderRefundParam();
                 orderRefundParam.setOrderNumber(order.getOrderNumber());
@@ -217,11 +222,8 @@ public class HBOrderService implements IHBOrderService {
                             .eq(OrderRefund::getOrderItemId, orderItem.getOrderItemId()));
 
                     if (ObjectUtil.isNotEmpty(orderRefundList)) {
-                        // 计算该订单项已退款的总数量(通过退款单查询退款商品)
-                        List<OrderRefundSkuVo> orderRefundSkuVos = orderRefundSkuMapper.selectByRefundId(orderItem.getOrderItemId());
-                        Integer totalRefundedCount = orderRefundSkuVos.stream()
-                                .mapToInt(OrderRefundSkuVo::getProductCount)
-                                .sum();
+                        // 计算该订单项已退款的总数量（按退款单ID查询退款商品）
+                        Integer totalRefundedCount = calculateTotalRefundedCount(orderRefundList, orderItem.getOrderItemId());
 
                         // 计算剩余可退款数量
                         Integer remainingCount = orderItem.getProdCount() - totalRefundedCount;
@@ -266,6 +268,85 @@ public class HBOrderService implements IHBOrderService {
                 }
                 OrderRefund orderRefund = orderService.applyAgain(orderRefundParam, ReturnMoneyStsType.SUCCESS.value());
                 orderRefundService.createRefundOrder(order.getOrderNumber(), orderRefund.getRefundSn());
+            } else {
+                // ========== 市民请集合订单：商家取消时处理售后单 + 创建退款单通知海博 ==========
+                try {
+                    log.info("市民请集合订单取消，处理退款单并通知海博，订单号: {}", channelOrderId);
+
+                    // Issue 4: 有进行中的售后单 → 改为退款完成(70)，而非驳回
+                    OrderRefund ongoingRefund = orderRefundService.getOne(new LambdaQueryWrapper<OrderRefund>()
+                            .eq(OrderRefund::getOrderNumber, order.getOrderNumber())
+                            .notIn(OrderRefund::getReturnMoneySts, Arrays.asList(30, 40, 70)));
+                    log.info("市民请集合-进行中售后单数据:{}", JSONObject.toJSONString(ongoingRefund));
+                    if (ObjectUtil.isNotEmpty(ongoingRefund)) {
+                        ongoingRefund.setReturnMoneySts(ReturnMoneyStsType.SUCCESS.value());
+                        orderRefundService.updateById(ongoingRefund);
+                        // 退款单状态同步到海博
+                        orderRefundService.changeStatus(ongoingRefund.getRefundSn(), ReturnMoneyStsType.SUCCESS.value());
+                        // 生成流程记录
+                        orderRefundService.addOrderRefundRecord(ongoingRefund.getRefundId(), 30, 10, "商家取消订单，系统自动完成退款。");
+                    }
+
+                    // Issue 3: 计算剩余商品并创建退款单通知海博
+                    OrderRefundParam smqjhRefundParam = new OrderRefundParam();
+                    smqjhRefundParam.setOrderNumber(order.getOrderNumber());
+                    smqjhRefundParam.setApplyType(1);
+                    smqjhRefundParam.setRefundType(1);
+                    smqjhRefundParam.setIsReceiver(false);
+                    smqjhRefundParam.setBuyerReason("17");
+                    smqjhRefundParam.setBuyerDesc(bodyJson.getString("reason"));
+                    smqjhRefundParam.setBuyerMobile(order.getUserMobile());
+                    smqjhRefundParam.setGoodsNum(order.getProductNums());
+                    smqjhRefundParam.setRefundAmount(order.getActualTotal());
+                    smqjhRefundParam.setPhotoFiles("");
+
+                    List<OrderItem> smqjhOrderItems = orderItemMapper.getListByOrderNumber(order.getOrderNumber());
+                    List<OrderRefundSku> smqjhRefundSkuList = new ArrayList<>();
+                    for (OrderItem orderItem : smqjhOrderItems) {
+                        // 查询该订单项的所有退款记录
+                        List<OrderRefund> orderRefundList = orderRefundService.list(new LambdaQueryWrapper<OrderRefund>()
+                                .eq(OrderRefund::getOrderNumber, order.getOrderNumber())
+                                .eq(OrderRefund::getReturnMoneySts, 70)
+                                .eq(OrderRefund::getOrderItemId, orderItem.getOrderItemId()));
+
+                        if (ObjectUtil.isNotEmpty(orderRefundList)) {
+                            // 计算该订单项已退款的总数量（按退款单ID查询退款商品）
+                            Integer totalRefundedCount = calculateTotalRefundedCount(orderRefundList, orderItem.getOrderItemId());
+                            Integer remainingCount = orderItem.getProdCount() - totalRefundedCount;
+                            if (remainingCount > 0) {
+                                OrderRefundSku orderRefundSku = new OrderRefundSku();
+                                orderRefundSku.setOrderItemId(orderItem.getOrderItemId());
+                                orderRefundSku.setSkuId(orderItem.getSkuId());
+                                orderRefundSku.setProductCount(remainingCount);
+                                orderRefundSku.setSkuPrice(orderItem.getPrice());
+                                smqjhRefundSkuList.add(orderRefundSku);
+                            }
+                        } else {
+                            OrderRefundSku orderRefundSku = new OrderRefundSku();
+                            orderRefundSku.setOrderItemId(orderItem.getOrderItemId());
+                            orderRefundSku.setSkuId(orderItem.getSkuId());
+                            orderRefundSku.setProductCount(orderItem.getProdCount());
+                            orderRefundSku.setSkuPrice(orderItem.getPrice());
+                            smqjhRefundSkuList.add(orderRefundSku);
+                        }
+                    }
+
+                    if (ObjectUtil.isNotEmpty(smqjhRefundSkuList)) {
+                        smqjhRefundParam.setOrderRefundSkuList(smqjhRefundSkuList);
+                        // 更新订单退款状态，避免applyAgain检查报错
+                        order.setRefundStatus(4); // DISAGREE
+                        orderMapper.updateById(order);
+
+                        OrderRefund newRefund = orderService.applyAgain(smqjhRefundParam, ReturnMoneyStsType.SUCCESS.value());
+                        // 标记handler为已处理，避免海博回调details时重复退款（实际退款由smqjh-oms处理）
+                        newRefund.setHandler(true);
+                        orderRefundService.updateById(newRefund);
+                        // 通知海博创建售后单
+                        orderRefundService.createRefundOrder(order.getOrderNumber(), newRefund.getRefundSn());
+                    }
+                } catch (Exception e) {
+                    log.error("市民请集合订单取消-星闪豹侧处理售后单异常，订单号: {}，异常: {}", channelOrderId, e.getMessage(), e);
+                }
             }
         }
         //成功直接通知海博
@@ -274,11 +355,18 @@ public class HBOrderService implements IHBOrderService {
         }
 
         //TODO 市民请集合海博状态通知
-        if (order.getOrderType().equals(4)) {
-            Map<Object, Object> map = new LinkedTreeMap<>();
-            map.put("orderNumber", channelOrderId);
-            map.put("hbOrderStatus", operatorType);
-            HttpUtil.post(smqjhUtil.getOmsBaseUrl() + "/api/v1/xsb/order/updateHbOrderStatus", map);
+        if (isSmqjhOrder) {
+            try {
+                Map<Object, Object> map = new LinkedTreeMap<>();
+                map.put("orderNumber", channelOrderId);
+                map.put("hbOrderStatus", operatorType);
+                String syncResult = HttpUtil.post(smqjhUtil.getOmsBaseUrl() + "/api/v1/xsb/order/updateHbOrderStatus", map);
+                log.info("市民请集合-推送OMS订单状态结果，orderNumber: {}, operatorType: {}, result: {}",
+                        channelOrderId, operatorType, syncResult);
+            } catch (Exception e) {
+                log.error("市民请集合-推送OMS订单状态失败，orderNumber: {}, operatorType: {}",
+                        channelOrderId, operatorType, e);
+            }
         }
     }
 
@@ -566,4 +654,31 @@ public class HBOrderService implements IHBOrderService {
         return HBR.success(createOrderRequest);
     }
 
+    /**
+     * 统计某个订单项在给定退款单集合中的已退款数量
+     */
+    private Integer calculateTotalRefundedCount(List<OrderRefund> orderRefundList, Long orderItemId) {
+        if (ObjectUtil.isEmpty(orderRefundList)) {
+            return 0;
+        }
+        int totalRefundedCount = 0;
+        for (OrderRefund refund : orderRefundList) {
+            if (refund == null || refund.getRefundId() == null) {
+                continue;
+            }
+            List<OrderRefundSkuVo> orderRefundSkuVos = orderRefundSkuMapper.selectByRefundId(refund.getRefundId());
+            if (ObjectUtil.isEmpty(orderRefundSkuVos)) {
+                continue;
+            }
+            totalRefundedCount += orderRefundSkuVos.stream()
+                    .filter(Objects::nonNull)
+                    .filter(item -> Objects.equals(item.getOrderItemId(), orderItemId))
+                    .map(OrderRefundSkuVo::getProductCount)
+                    .filter(Objects::nonNull)
+                    .mapToInt(Integer::intValue)
+                    .sum();
+        }
+        return totalRefundedCount;
+    }
+
 }

yami-shop-service/src/main/java/com/yami/shop/service/impl/OrderRefundServiceImpl.java

@@ -1051,15 +1051,28 @@ public class OrderRefundServiceImpl extends ServiceImpl<OrderRefundMapper, Order
             JSONObject bodyStr = hBRequest.getJSONObject("body");
             log.info("退款订单信息，body：{}", bodyStr);
             String channelOrderId = bodyStr.getString("channelOrderId");
+            String afterSaleOrder = bodyStr.getString("afterSaleOrder");
             Order order = orderMapper.getOrderByOrderNumber(channelOrderId);
-            OrderRefund orderRefund = orderRefundMapper.selectOne(new LambdaQueryWrapper<OrderRefund>().eq(OrderRefund::getRefundSn, bodyStr.getString("afterSaleOrder")));
+            if (order == null) {
+                log.error("海博退款详情：订单不存在，channelOrderId={}", channelOrderId);
+                return HBR.error("订单不存在：" + channelOrderId);
+            }
+            OrderRefund orderRefund = orderRefundMapper.selectOne(new LambdaQueryWrapper<OrderRefund>().eq(OrderRefund::getRefundSn, afterSaleOrder));
+            if (orderRefund == null) {
+                log.error("海博退款详情：退款单不存在，afterSaleOrder={}", afterSaleOrder);
+                return HBR.error("退款单不存在：" + afterSaleOrder);
+            }
             ShopDetail shopDetailByShopId = shopDetailService.getShopDetailByShopId(orderRefund.getShopId());
+            if (shopDetailByShopId == null) {
+                log.error("海博退款详情：门店不存在，shopId={}", orderRefund.getShopId());
+                return HBR.error("门店不存在：" + orderRefund.getShopId());
+            }
 
             thirdPartyRefundRequest.setChannelOrderId(channelOrderId);
             thirdPartyRefundRequest.setOutStationNo(shopDetailByShopId.getHbStationNo());
             thirdPartyRefundRequest.setAfterSaleOrder(orderRefund.getRefundSn());
             thirdPartyRefundRequest.setSaleType(1);//售前售后标 1:售前 2:售后
-            if (order.getHbOrderStatus().equals(OrderStatus.SUCCESS.value())) {
+            if (Objects.equals(order.getHbOrderStatus(), OrderStatus.SUCCESS.value())) {
                 thirdPartyRefundRequest.setSaleType(2);
             }
             thirdPartyRefundRequest.setReason(orderRefund.getBuyerReason());
@@ -1078,12 +1091,16 @@ public class OrderRefundServiceImpl extends ServiceImpl<OrderRefundMapper, Order
             thirdPartyRefundRequest.setPickAddress(orderRefund.getBuyerMobile());
             thirdPartyRefundRequest.setRefundType(orderRefund.getRefundType());
             thirdPartyRefundRequest.setMoney((long) (orderRefund.getRefundAmount() == null ? 0 : orderRefund.getRefundAmount() * 100));
-            thirdPartyRefundRequest.setTimestamp(orderRefund.getApplyTime().getTime());
+            thirdPartyRefundRequest.setTimestamp(orderRefund.getApplyTime() != null ? orderRefund.getApplyTime().getTime() : System.currentTimeMillis());
             thirdPartyRefundRequest.setRefundSource(1);
 
             List<ProductRequest> productRequests = new ArrayList<>();
             orderRefundSkuMapper.selectList(new LambdaQueryWrapper<OrderRefundSku>().eq(OrderRefundSku::getOrderRefundId, orderRefund.getRefundId())).forEach(orderRefundSku -> {
                 Sku sku = skuService.getById(orderRefundSku.getSkuId());
+                if (sku == null) {
+                    log.error("海博退款详情：SKU不存在，skuId={}, orderRefundId={}", orderRefundSku.getSkuId(), orderRefund.getRefundId());
+                    return; // skip this sku
+                }
                 ProductRequest productRequest = new ProductRequest();
                 productRequest.setSkuName(sku.getSkuName());
                 productRequest.setSkuId(orderRefundSku.getSkuId());
@@ -1107,7 +1124,7 @@ public class OrderRefundServiceImpl extends ServiceImpl<OrderRefundMapper, Order
             // 返回退款单信息
             log.info("退款订单状态：{}", orderRefund.getReturnMoneySts());
             //TODO 退款单完成处理积分
-            if (orderRefund.getReturnMoneySts().equals(70)) {
+            if (Objects.equals(orderRefund.getReturnMoneySts(), 70)) {
                 //推送商家审核状态后 同步退款单状态
                 changeStatus(orderRefund.getRefundSn(), orderRefund.getReturnMoneySts());
                 if (ChannelType.SMQJH.value().equals(orderRefund.getChannelType())) {
@@ -1122,19 +1139,19 @@ public class OrderRefundServiceImpl extends ServiceImpl<OrderRefundMapper, Order
                             if (result == null) {
                                 log.error("【详情】推送市民请集合积分处理返回失败1：");
                             }
-                            if (!SMQJHResultCode.SUCCESS.getCode().equals(result.getCode())) {
+                            if (result != null && !SMQJHResultCode.SUCCESS.getCode().equals(result.getCode())) {
                                 log.error("【详情】推送市民请集合积分处理返回失败2：" + result.getMsg());
                             }
                         }
                     } catch (Exception e) {
-                        log.error("【详情】推送市民请集合积分报错：" + e.getMessage() + "{}", e);
+                        log.error("【详情】推送市民请集合积分报错：" + e.getMessage(), e);
                     }
                 } else {
                     orderService.returnRefund(orderRefund.getOrderNumber());
                 }
             }
         } catch (Exception e) {
-            log.error("海博退款订单查询异常：{}", e);
+            log.error("海博退款订单查询异常，请求参数：{}，异常信息：", hBRequest, e);
             return HBR.error("未知异常");
         }
 

yami-shop-service/src/main/java/com/yami/shop/service/xsb/XSBRefundOrderService.java

@@ -24,4 +24,12 @@ public interface XSBRefundOrderService {
      * @return
      */
     R<String> cancel(OrderRefundCancelVo orderRefundCancelVo,String logId);
+
+    /**
+     * 变更海博订单状态
+     * @param orderNumber 订单编号
+     * @param status 目标状态
+     * @return
+     */
+    R<String> changeHbOrderStatus(String orderNumber, Integer status);
 }

yami-shop-service/src/main/java/com/yami/shop/service/xsb/impl/XSBRefundOrderServiceImpl.java

@@ -21,6 +21,7 @@ import com.yami.shop.common.util.RefundSnUtils;
 import com.yami.shop.dao.*;
 import com.yami.shop.service.OrderRefundService;
 import com.yami.shop.service.OrderService;
+import com.yami.shop.service.hb.IHBOrderService;
 import com.yami.shop.service.xsb.XSBRefundOrderService;
 import com.yami.shop.utils.CullenUtils;
 import lombok.AllArgsConstructor;
@@ -68,6 +69,9 @@ public class XSBRefundOrderServiceImpl implements XSBRefundOrderService {
     @Autowired
     private RefundDeliveryMapper refundDeliveryMapper;
 
+    @Autowired
+    private IHBOrderService hbOrderService;
+
 
 
 
@@ -109,6 +113,13 @@ public class XSBRefundOrderServiceImpl implements XSBRefundOrderService {
             return R.FAIL("渠道推送申请退款：当前订单还未付款，无法申请");
         }
 
+        // 商家取消订单触发的退款，跳过常规校验，直接创建状态70的退款单
+        boolean isMerchantCancel = Boolean.TRUE.equals(refundOrderPushVo.getMerchantCancel());
+        if (isMerchantCancel) {
+            log.info("【"+logId+"】"+"商家取消订单触发退款，跳过常规校验，直接创建退款单");
+            return createMerchantCancelRefund(refundOrderPushVo, order, orderRefundSkuList, logId);
+        }
+
         if (Objects.equals(order.getHbOrderStatus(), OrderStatus.CLOSE.value())) {
             return R.FAIL("渠道推送申请退款：当前订单已失败，不允许退款");
         }
@@ -240,6 +251,18 @@ public class XSBRefundOrderServiceImpl implements XSBRefundOrderService {
         log.info("【"+logId+"】"+"渠道推送申请退款：创建海博退款单，生成海博退款单信息{}", orderRefund);
         orderRefundService.createRefundOrder(orderRefund.getOrderNumber(), orderRefund.getRefundSn());
 
+        // Only entire-order refunds sync Haibo order status to CLOSE(60).
+        if (Objects.equals(refundOrderPushVo.getRefundType(), RefundType.ALL.value())) {
+            try {
+                hbOrderService.changeOrderStatus(order.getOrderNumber(), OrderStatus.CLOSE.value());
+                log.info("[{}] refund apply: entire-order refund, sync Haibo status to 60", logId);
+            } catch (Exception e) {
+                log.error("[{}] refund apply: failed to sync Haibo status to 60", logId, e);
+            }
+        } else {
+            log.info("[{}] refund apply: partial refund, keep Haibo order status unchanged", logId);
+        }
+
         return R.SUCCESS(newOrderRefund.getRefundSn());
     }
 
@@ -358,6 +381,24 @@ public class XSBRefundOrderServiceImpl implements XSBRefundOrderService {
         return R.SUCCESS("撤销成功");
     }
 
+    /**
+     * 变更海博订单状态
+     * @param orderNumber 订单编号
+     * @param status 目标状态
+     * @return
+     */
+    @Override
+    public R<String> changeHbOrderStatus(String orderNumber, Integer status) {
+        try {
+            hbOrderService.changeOrderStatus(orderNumber, status);
+            log.info("变更海博订单状态成功, orderNumber: {}, status: {}", orderNumber, status);
+            return R.SUCCESS("变更成功");
+        } catch (Exception e) {
+            log.error("变更海博订单状态失败, orderNumber: {}, status: {}, error: {}", orderNumber, status, e.getMessage());
+            return R.FAIL("变更失败: " + e.getMessage());
+        }
+    }
+
     /**
      * 参数校验
      * @param refundOrderPushVo
@@ -409,6 +450,59 @@ public class XSBRefundOrderServiceImpl implements XSBRefundOrderService {
     }
 
 
+    /**
+     * 商家取消订单触发的退款：跳过常规校验，直接创建状态为70(退款完成)的退款单
+     */
+    private R<String> createMerchantCancelRefund(RefundOrderPushVo refundOrderPushVo, Order order,
+                                                  List<OrderRefundSku> orderRefundSkuList, String logId) {
+        OrderRefund newOrderRefund = new OrderRefund();
+        newOrderRefund.setShopId(refundOrderPushVo.getThirdShopId());
+        newOrderRefund.setUserId(refundOrderPushVo.getMemberId().toString());
+        newOrderRefund.setOrderId(order.getOrderId());
+        newOrderRefund.setOrderNumber(order.getOrderNumber());
+        newOrderRefund.setRefundSn(RefundSnUtils.generate());
+        newOrderRefund.setRefundType(refundOrderPushVo.getRefundType());
+        newOrderRefund.setRefundAmount(refundOrderPushVo.getRefundAmount().setScale(2, RoundingMode.HALF_UP).doubleValue());
+        if (Objects.equals(RefundType.ALL.value(), refundOrderPushVo.getRefundType())) {
+            newOrderRefund.setOrderItemId(0L);
+        }
+        newOrderRefund.setRefundTotalMoney(refundOrderPushVo.getRefundTotalMoney());
+        newOrderRefund.setGoodsNum(refundOrderPushVo.getGoodsNum());
+        newOrderRefund.setApplyType(refundOrderPushVo.getApplyType());
+        newOrderRefund.setIsReceiver(false);
+        newOrderRefund.setBuyerReason(refundOrderPushVo.getBuyerReason());
+        newOrderRefund.setBuyerDesc(refundOrderPushVo.getBuyerDesc());
+        newOrderRefund.setBuyerMobile(refundOrderPushVo.getBuyerMobile());
+        newOrderRefund.setPhotoFiles(refundOrderPushVo.getPhotoFiles());
+        newOrderRefund.setReturnMoneySts(ReturnMoneyStsType.SUCCESS.value()); // 70:直接退款完成
+        newOrderRefund.setApplyTime(new Date());
+        newOrderRefund.setUpdateTime(new Date());
+        newOrderRefund.setFreightAmount(refundOrderPushVo.getFreightAmount() != null
+                ? refundOrderPushVo.getFreightAmount().setScale(2, RoundingMode.HALF_UP).doubleValue() : 0d);
+        newOrderRefund.setOffsetPoints(0L);
+        newOrderRefund.setChannelType(refundOrderPushVo.getChannelType());
+
+        log.info("【"+logId+"】"+"商家取消-添加退款信息："+JSONObject.toJSONString(newOrderRefund));
+        OrderRefund orderRefund = orderRefundService.applyRefund(newOrderRefund);
+        if (!orderRefundSkuList.isEmpty()) {
+            orderRefundSkuList.forEach(c -> {
+                c.setOrderRefundId(orderRefund.getRefundId());
+                orderRefundSkuMapper.insert(c);
+            });
+        }
+
+        // 生成退款记录
+        addOrderRefundRecord(orderRefund.getRefundId(), 1, 1, "商家取消订单");
+        addOrderRefundRecord(orderRefund.getRefundId(), 30, 10, "商家取消订单，系统自动完成退款。");
+
+        // 创建海博退款单
+        log.info("【"+logId+"】"+"商家取消-创建海博退款单，退款单信息{}", orderRefund);
+        orderRefundService.createRefundOrder(orderRefund.getOrderNumber(), orderRefund.getRefundSn());
+
+        return R.SUCCESS(newOrderRefund.getRefundSn());
+    }
+
+
     /**
      * 保存日志
      * @param refundId