feat: 对接erp

fs-service-system/src/main/java/com/fs/erp/constant/AfterSalesOrderStatusEnum.java

@@ -0,0 +1,118 @@
+package com.fs.erp.constant;
+
+/**
+ * 平台单据状态枚举
+ *
+ * 定义售后单据在不同阶段的状态常量
+ */
+public enum AfterSalesOrderStatusEnum {
+
+    /**
+     * 买家已经申请，等待卖家同意
+     */
+    WAIT_SELLER_AGREE(0, "WAIT_SELLER_AGREE", "买家已经申请，等待卖家同意"),
+
+    /**
+     * 卖家已经同意，等待买家退货
+     */
+    WAIT_BUYER_RETURN_GOODS(1, "WAIT_BUYER_RETURN_GOODS", "卖家已经同意，等待买家退货"),
+
+    /**
+     * 买家已经退货，等待卖家确认收货
+     */
+    WAIT_SELLER_CONFIRM_GOODS(2, "WAIT_SELLER_CONFIRM_GOODS", "买家已经退货，等待卖家确认收货"),
+
+    /**
+     * 卖家拒绝售后
+     */
+    SELLER_REFUSE_BUYER(3, "SELLER_REFUSE_BUYER", "卖家拒绝售后"),
+
+    /**
+     * 等待卖家发货
+     */
+    WAIT_SELLER_DELIVER_GOODS(4, "WAIT_SELLER_DELIVER_GOODS", "等待卖家发货"),
+
+    /**
+     * 补发卖家发货
+     */
+    REISSUE_SELLER_DELIVERY(5, "REISSUE_SELLER_DELIVERY", "补发卖家发货"),
+
+    /**
+     * 售后关闭(售后单未确认前填写该状态erp的售后单自动作废)
+     */
+    CLOSED(6, "CLOSED", "售后关闭"),
+
+    /**
+     * 退款成功
+     * 补发、换货售后单确认时需在系统中手动确认
+     * 注意：抖音、拼多多、淘系等线上平台换货单据，通过接口修改状态为SUCCESS且发出的快递单号是空，
+     * 平台会判定为换货单超时未处理，会被平台强制退款，线上售后类型会变为普通退货
+     */
+    SUCCESS(7, "SUCCESS", "退款成功"),
+    CONFIRM(10, "CONFIRM", "确认");
+
+    private final Integer index;
+    private final String code;
+    private final String description;
+
+    AfterSalesOrderStatusEnum(Integer index, String code, String description) {
+        this.index = index;
+        this.code = code;
+        this.description = description;
+    }
+
+    public String getCode() {
+        return code;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public Integer getIndex() {
+        return index;
+    }
+
+    /**
+     * 根据状态码获取枚举实例
+     *
+     * @param code 状态码
+     * @return 对应的枚举实例，如果未找到则返回null
+     */
+    public static AfterSalesOrderStatusEnum getByCode(String code) {
+        if (code == null) {
+            return null;
+        }
+
+        for (AfterSalesOrderStatusEnum status : AfterSalesOrderStatusEnum.values()) {
+            if (status.getCode().equals(code)) {
+                return status;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 根据状态码获取枚举实例
+     *
+     * @param index 状态码
+     * @return 对应的枚举实例，如果未找到则返回null
+     */
+    public static AfterSalesOrderStatusEnum getByIndex(Integer index) {
+        if (index == null) {
+            return null;
+        }
+
+        for (AfterSalesOrderStatusEnum status : AfterSalesOrderStatusEnum.values()) {
+            if (status.getIndex().equals(index)) {
+                return status;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public String toString() {
+        return this.code;
+    }
+}

fs-service-system/src/main/java/com/fs/erp/constant/TradeStatus.java

@@ -0,0 +1,98 @@
+package com.fs.erp.constant;
+
+/**
+ * 交易状态枚举
+ * 用于表示交易过程中的各种状态
+ */
+public enum TradeStatus {
+    /**
+     * 买家未收到货
+     */
+    BUYER_NOT_RECEIVED("BUYER_NOT_RECEIVED", "买家未收到货"),
+
+    /**
+     * 买家已收到货
+     */
+    BUYER_RECEIVED("BUYER_RECEIVED", "买家已收到货"),
+
+    /**
+     * 买家已退货
+     */
+    BUYER_RETURNED_GOODS("BUYER_RETURNED_GOODS", "买家已退货"),
+
+    /**
+     * 卖家已收到退货
+     */
+    SELLER_RECEIVED("SELLER_RECEIVED", "卖家已收到退货");
+
+    /**
+     * 状态编码
+     */
+    private final String code;
+
+    /**
+     * 状态描述
+     */
+    private final String description;
+
+    TradeStatus(String code, String description) {
+        this.code = code;
+        this.description = description;
+    }
+
+    public String getCode() {
+        return code;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    /**
+     * 根据状态编码获取对应的枚举实例
+     *
+     * @param code 状态编码
+     * @return 对应的枚举实例，如果未找到则返回null
+     */
+    public static TradeStatus getByCode(String code) {
+        if (code == null) {
+            return null;
+        }
+
+        for (TradeStatus status : values()) {
+            if (status.getCode().equals(code)) {
+                return status;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 判断当前状态是否可以更新为目标状态
+     *
+     * @param target 目标状态
+     * @return 是否可以更新
+     */
+    public boolean canUpdateTo(TradeStatus target) {
+        if (target == null) {
+            return false;
+        }
+
+        switch (this) {
+            case BUYER_NOT_RECEIVED:
+                // 未收到货可以更新为已收到货或买家退货
+                return target == BUYER_RECEIVED || target == BUYER_RETURNED_GOODS;
+            case BUYER_RECEIVED:
+                // 已收到货可以更新为买家退货
+                return target == BUYER_RETURNED_GOODS;
+            case BUYER_RETURNED_GOODS:
+                // 买家已退货可以更新为卖家已收到退货
+                return target == SELLER_RECEIVED;
+            case SELLER_RECEIVED:
+                // 卖家已收到退货不可再更新
+                return false;
+            default:
+                return false;
+        }
+    }
+}

fs-service-system/src/main/java/com/fs/erp/domain/FsJstAftersalePush.java

@@ -24,16 +24,28 @@ public class FsJstAftersalePush {
      * 订单号
      */
     private String orderId;
+    /**
+     * 售后id
+     */
+    private String afterSaleId;
 
     /**
-     * 0推单 1确认
+     * 平台单据状态：
+     * 0 WAIT_SELLER_AGREE:买家已经申请，等待卖家同意,
+     * 1 WAIT_BUYER_RETURN_GOODS:卖家已经同意，等待买家退货,
+     * 2 WAIT_SELLER_CONFIRM_GOODS:买家已经退货，等待卖家确认收货,
+     * 3 SELLER_REFUSE_BUYER:卖家拒绝售后,
+     * 4 WAIT_SELLER_DELIVER_GOODS：等待卖家发货，
+     * 5 REISSUE_SELLER_DELIVERY：补发卖家发货，
+     * 6 CLOSED:售后关闭(售后单未确认前填写该状态erp的售后单自动作废),
+     * 7 SUCCESS:退款成功；可更新，补发、换货售后单确认时需在系统中手动确认；抖音、拼多多、淘系等线上平台换货换货单据，通过接口修改状态为SUCCESS且发出的快递单号是空，平台会判定为换货单超时未处理，会被平台强制退款，线上售后类型会变为普通退货
      */
     private String type;
 
     /**
      * 任务状态：0-待处理，1-成功，2-失败，3-正在处理，4-已取消
      */
-    private Byte taskStatus;
+    private Integer taskStatus;
 
     /**
      * 重试次数，默认为 0

fs-service-system/src/main/java/com/fs/erp/dto/AfterSaleConfirmRequestDTO.java

@@ -28,11 +28,6 @@ public class AfterSaleConfirmRequestDTO implements Serializable {
      */
     private List<Long> asIds;
 
-    /**
-     * 售后单id
-     */
-    private Long number;
-
     /**
      * 换货售后单是否强制确认
      */

fs-service-system/src/main/java/com/fs/erp/dto/RefundItemDTO.java

@@ -19,7 +19,7 @@ import java.math.BigDecimal;
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
-class RefundItemDTO implements Serializable {
+public class RefundItemDTO implements Serializable {
 
     private static final long serialVersionUID = -1L;
 

fs-service-system/src/main/java/com/fs/erp/mapper/FsJstAftersalePushMapper.java

@@ -51,4 +51,33 @@ public interface FsJstAftersalePushMapper {
     @Update("UPDATE fs_jst_aftersale_push SET task_status = #{taskStatus}, " +
             "last_execute_time = now() WHERE id = #{id}")
     int updateStatus(@Param("id") Long id, @Param("taskStatus") Byte taskStatus);
+
+    @Select("SELECT t1.*\n" +
+            "FROM fs_jst_aftersale_push t1\n" +
+            "WHERE t1.task_status = 0 and t1.retry_count<3\n" +
+            "  AND (\n" +
+            "      NOT EXISTS (\n" +
+            "          SELECT 1\n" +
+            "          FROM fs_jst_aftersale_push t_prev\n" +
+            "          WHERE t_prev.order_id = t1.order_id\n" +
+            "            AND t_prev.type < t1.type\n" +
+            "      )\n" +
+            "      OR\n" +
+            "      NOT EXISTS (\n" +
+            "          SELECT 1\n" +
+            "          FROM fs_jst_aftersale_push t_prev\n" +
+            "          WHERE t_prev.order_id = t1.order_id\n" +
+            "            AND t_prev.type < t1.type\n" +
+            "            AND t_prev.task_status != 1" +
+            "      )\n" +
+            "  )\n" +
+            "  AND NOT EXISTS (\n" +
+            "      SELECT 1\n" +
+            "      FROM fs_jst_aftersale_push t3\n" +
+            "      WHERE t3.order_id = t1.order_id\n" +
+            "        AND t3.type = t1.type\n" +
+            "        AND t3.task_status = 3" +
+            "  )\n" +
+            "ORDER BY t1.order_id, CAST(t1.type AS UNSIGNED), t1.create_time")
+    List<FsJstAftersalePush> queryPenddingData();
 }

fs-service-system/src/main/java/com/fs/erp/service/FsJstAftersalePushService.java

@@ -0,0 +1,5 @@
+package com.fs.erp.service;
+
+public interface FsJstAftersalePushService {
+    void pushJst();
+}

fs-service-system/src/main/java/com/fs/erp/service/impl/FsJstAftersalePushServiceImpl.java

@@ -0,0 +1,171 @@
+package com.fs.erp.service.impl;
+
+import cn.hutool.json.JSONUtil;
+import com.alibaba.fastjson.JSON;
+import com.fs.common.utils.ExceptionUtil;
+import com.fs.erp.constant.AfterSalesOrderStatusEnum;
+import com.fs.erp.constant.TradeStatus;
+import com.fs.erp.domain.ErpOrderItem;
+import com.fs.erp.domain.FsJstAftersalePush;
+import com.fs.erp.dto.*;
+import com.fs.erp.http.JstErpHttpService;
+import com.fs.erp.mapper.FsJstAftersalePushMapper;
+import com.fs.erp.service.FsJstAftersalePushService;
+import com.fs.express.enums.TaskStatusEnum;
+import com.fs.store.domain.FsStoreAfterSales;
+import com.fs.store.domain.FsStoreOrder;
+import com.fs.store.domain.FsStoreOrderItem;
+import com.fs.store.dto.FsStoreCartDTO;
+import com.fs.store.mapper.FsStoreAfterSalesMapper;
+import com.fs.store.mapper.FsStoreOrderMapper;
+import com.fs.store.service.IFsStoreOrderItemService;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang.StringUtils;
+import org.apache.http.util.Asserts;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+@Slf4j
+@Service
+public class FsJstAftersalePushServiceImpl implements FsJstAftersalePushService {
+
+    @Autowired
+    private FsJstAftersalePushMapper fsJstAftersalePushMapper;
+
+    @Autowired
+    private JstErpHttpService jstErpHttpService;
+
+    @Autowired
+    private FsStoreOrderMapper fsStoreOrderMapper;
+
+    @Autowired
+    private IFsStoreOrderItemService storeOrderItemService;
+
+    @Autowired
+    private FsStoreAfterSalesMapper fsStoreAfterSalesMapper;
+
+    @Value("${jst.shop_code}")
+    private String shopId;
+    @Override
+    public void pushJst() {
+        List<FsJstAftersalePush> fsJstAftersalePushes = fsJstAftersalePushMapper.queryPenddingData();
+
+        for (FsJstAftersalePush item : fsJstAftersalePushes) {
+            item.setTaskStatus(TaskStatusEnum.PROCESSING.getCode());
+            int update = fsJstAftersalePushMapper.update(item);
+            if(update <= 0){
+                log.info("获取记录{} 锁失败!",item.getId());
+                continue;
+            }
+
+            FsStoreOrder fsStoreOrder = fsStoreOrderMapper.selectFsStoreOrderByOrderCode(item.getOrderId());
+
+            item.setRetryCount(item.getRetryCount()+1);
+
+            if(fsStoreOrder == null){
+                item.setErrorMessage("该订单未找到!");
+                item.setTaskStatus(TaskStatusEnum.FAILED.getCode());
+                log.info("该订单未找到!");
+                fsJstAftersalePushMapper.update(item);
+                continue;
+            }
+            Asserts.notNull(fsStoreOrder,"该订单未找到!");
+            RefundOrderDTO dto;
+            dto = getAfterSaleDTO(item, fsStoreOrder);
+            // 买家已经申请，等待卖家同意
+            if(StringUtils.equals(AfterSalesOrderStatusEnum.WAIT_SELLER_AGREE.getIndex().toString()
+                    ,item.getType())){
+
+            // 买家已经退货，等待卖家确认收货
+            } else if(StringUtils.equals(AfterSalesOrderStatusEnum.WAIT_SELLER_CONFIRM_GOODS.getIndex().toString(),
+                    item.getType())){
+                // 查询售后单 同步快递单号过去
+                FsStoreAfterSales fsStoreAfterSales = fsStoreAfterSalesMapper.selectFsStoreAfterSalesById(item.getId());
+                dto.setLogisticsCompany(fsStoreAfterSales.getDeliverySn());
+                dto.setLId(fsStoreAfterSales.getDeliveryId());
+
+            // 售后关闭
+            } else if(StringUtils.equals(AfterSalesOrderStatusEnum.CLOSED.getIndex().toString(),item.getType())) {
+
+            // 退款成功
+            } else if(StringUtils.equals(AfterSalesOrderStatusEnum.SUCCESS.getIndex().toString(),item.getType())) {
+
+            // 确认
+            }
+
+
+            if(!StringUtils.equals(AfterSalesOrderStatusEnum.CONFIRM.getIndex().toString(),item.getType())) {
+                try{
+                    CommonResponse<AfterSaleResponseDTO> response = jstErpHttpService.aftersaleUpload(dto);
+                    item.setParams(JSON.toJSONString(dto));
+                    item.setResult(JSON.toJSONString(response));
+                    item.setTaskStatus(TaskStatusEnum.SUCCESS.getCode());
+                }catch (Exception e) {
+                    item.setErrorMessage(ExceptionUtil.getExceptionMessage(e));
+                    item.setTaskStatus(TaskStatusEnum.FAILED.getCode());
+                }
+
+            // 如果是确认类型
+            } else{
+                AfterSaleConfirmRequestDTO requestDTO = new AfterSaleConfirmRequestDTO();
+
+                requestDTO.setAsIds(Collections.singletonList(Long.valueOf(item.getAfterSaleId())));
+                requestDTO.setExchangeForce(true);
+                requestDTO.setConfirmRefund(true);
+
+                try{
+                    CommonResponse<AssetProcessResultDTO> response = jstErpHttpService.aftersaleConfirm(requestDTO);
+                    item.setParams(JSON.toJSONString(dto));
+                    item.setResult(JSON.toJSONString(response));
+                    item.setTaskStatus(TaskStatusEnum.SUCCESS.getCode());
+                }catch (Exception e){
+                    item.setErrorMessage(ExceptionUtil.getExceptionMessage(e));
+                    item.setTaskStatus(TaskStatusEnum.FAILED.getCode());
+                }
+            }
+
+            fsJstAftersalePushMapper.update(item);
+        }
+    }
+
+    private RefundOrderDTO getAfterSaleDTO(FsJstAftersalePush item, FsStoreOrder fsStoreOrder) {
+        RefundOrderDTO dto = new RefundOrderDTO();
+        AfterSalesOrderStatusEnum statusEnum = AfterSalesOrderStatusEnum.getByIndex(Integer.valueOf(item.getType()));
+
+        dto.setShopStatus(statusEnum.getCode());
+        dto.setQuestionType("可更新");
+        dto.setOuterAsId(item.getAfterSaleId());
+        dto.setRemark("用户退款");
+        dto.setType("其他");
+
+        dto.setShopId(Long.parseLong(shopId));
+        dto.setTotalAmount(fsStoreOrder.getTotalPrice());
+        dto.setSoId(item.getOrderId());
+        dto.setRefund(fsStoreOrder.getPayMoney());
+
+
+        FsStoreOrderItem itemMap=new FsStoreOrderItem();
+        itemMap.setOrderId(fsStoreOrder.getId());
+        List<FsStoreOrderItem> orderItems=storeOrderItemService.selectFsStoreOrderItemList(itemMap);
+        List<RefundItemDTO> refundItemDTOS=new ArrayList<>();
+
+        for(FsStoreOrderItem orderItem: orderItems) {
+            FsStoreCartDTO cartDTO = JSONUtil.toBean(orderItem.getJsonInfo(), FsStoreCartDTO.class);
+
+            RefundItemDTO itemDTO = new RefundItemDTO();
+            itemDTO.setSkuId(cartDTO.getBarCode());
+            itemDTO.setQty(cartDTO.getNum());
+            itemDTO.setAmount(cartDTO.getPrice());
+            itemDTO.setType("退货");
+            refundItemDTOS.add(itemDTO);
+        }
+        dto.setItems(refundItemDTOS);
+        return dto;
+    }
+}

fs-service-system/src/main/java/com/fs/erp/service/impl/JSTErpOrderServiceImpl.java

@@ -1,11 +1,14 @@
 package com.fs.erp.service.impl;
 
+import com.fs.erp.constant.AfterSalesOrderStatusEnum;
 import com.fs.erp.constant.OrderStatusEnum;
 import com.fs.erp.domain.*;
 import com.fs.erp.dto.*;
 import com.fs.erp.http.JstErpHttpService;
+import com.fs.erp.mapper.FsJstAftersalePushMapper;
 import com.fs.erp.service.IErpOrderService;
 import com.fs.erp.utils.SignUtil;
+import com.fs.express.enums.TaskStatusEnum;
 import com.fs.store.domain.FsStoreOrder;
 import com.fs.store.service.IFsStoreOrderService;
 import lombok.extern.slf4j.Slf4j;
@@ -19,10 +22,7 @@ import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
 
 import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 import java.util.stream.Collectors;
 
 @Slf4j
@@ -34,6 +34,9 @@ public class JSTErpOrderServiceImpl implements IErpOrderService {
     @Autowired
     private IFsStoreOrderService fsStoreOrderService;
 
+    @Autowired
+    private FsJstAftersalePushMapper fsJstAftersalePushMapper;
+
     @Override
     public ErpOrderResponse addOrder(ErpOrder order) {
         ErpOrderPayment erpOrderPayment = order.getPayments().get(0);
@@ -75,7 +78,7 @@ public class JSTErpOrderServiceImpl implements IErpOrderService {
         List<OrderItemDTO> itemDTOList = new ArrayList<>();
         for (ErpOrderItem detail : details) {
             OrderItemDTO orderItemDTO = new OrderItemDTO();
-            orderItemDTO.setSkuId("105220");
+            orderItemDTO.setSkuId(detail.getItem_code());
             orderItemDTO.setShopSkuId(detail.getItem_code());
             orderItemDTO.setName(detail.getItem_code());
             orderItemDTO.setAmount(Double.valueOf(detail.getPrice()));
@@ -238,14 +241,30 @@ public class JSTErpOrderServiceImpl implements IErpOrderService {
     public BaseResponse refundUpdate(ErpRefundUpdateRequest param) {
 
         FsStoreOrder fsStoreOrder = fsStoreOrderService.selectFsStoreOrderByOrderCode(param.getTid());
-        // 如果是发货前退款，直接走取消订单流程
-        // 如果是发货后退款，走售后流程
-        OrderCancelRequestDTO requestDTO = new OrderCancelRequestDTO();
-        requestDTO.setOIds(Collections.singletonList(Integer.valueOf(fsStoreOrder.getExtendOrderId())));
-        requestDTO.setCancelType("用户退款");
-        requestDTO.setRemark("用户退款");
 
-        jstErpHttpService.cancel(requestDTO);
+        Set<Integer> statusSet = new HashSet<>();
+        statusSet.add(2);
+        statusSet.add(3);
+
+        // 发货后退款
+        if(statusSet.contains(fsStoreOrder.getStatus())){
+            FsJstAftersalePush fsJstAftersalePush = new FsJstAftersalePush();
+            fsJstAftersalePush.setOrderId(fsStoreOrder.getOrderCode());
+            fsJstAftersalePush.setType(String.valueOf(AfterSalesOrderStatusEnum.WAIT_SELLER_AGREE.getIndex()));
+            fsJstAftersalePush.setTaskStatus(TaskStatusEnum.PENDING.getCode());
+            fsJstAftersalePush.setRetryCount(0);
+            fsJstAftersalePushMapper.insert(fsJstAftersalePush);
+        } else {
+            // 如果是发货前退款，直接走取消订单流程
+            // 如果是发货后退款，走售后流程
+            OrderCancelRequestDTO requestDTO = new OrderCancelRequestDTO();
+            requestDTO.setOIds(Collections.singletonList(Integer.valueOf(fsStoreOrder.getExtendOrderId())));
+            requestDTO.setCancelType("用户退款");
+            requestDTO.setRemark("用户退款");
+
+            jstErpHttpService.cancel(requestDTO);
+        }
+
 
         BaseResponse baseResponse = new BaseResponse();
         baseResponse.setSuccess(true);
@@ -253,3 +272,4 @@ public class JSTErpOrderServiceImpl implements IErpOrderService {
         return baseResponse;
     }
 }
+

fs-service-system/src/main/java/com/fs/store/service/IFsStoreAfterSalesService.java

@@ -8,6 +8,8 @@ import com.fs.store.domain.FsStoreAfterSales;
 import com.fs.store.param.*;
 import com.fs.store.vo.FsStoreAfterSalesQueryVO;
 import com.fs.store.vo.FsStoreAfterSalesVO;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
 
 /**
  * 售后记录Service接口
@@ -78,6 +80,9 @@ public interface IFsStoreAfterSalesService
 
     R refundMoney(FsStoreAfterSalesRefundParam param);
 
+    @Transactional(rollbackFor = Throwable.class,propagation = Propagation.REQUIRED)
+    R refundStoreMoney(FsStoreAfterSalesRefundParam param);
+
     R cancel(FsStoreAfterSalesCancelParam fsStoreAfterSales) throws ParseException;
 
     Integer selectFsStoreAfterSalesCount(long userId, int salesStatus);

fs-service-system/src/main/java/com/fs/store/service/impl/FsStoreAfterSalesServiceImpl.java

@@ -10,7 +10,6 @@ import java.util.*;
 
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.util.IdUtil;
-import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.json.JSONUtil;
 import com.alibaba.fastjson.JSONObject;
 import com.fs.common.annotation.DataScope;
@@ -20,10 +19,15 @@ import com.fs.common.exception.CustomException;
 import com.fs.common.utils.DateUtils;
 import com.fs.common.utils.StringUtils;
 import com.fs.company.service.ICompanyService;
+import com.fs.erp.constant.AfterSalesOrderStatusEnum;
+import com.fs.erp.constant.ErpTypeConstant;
+import com.fs.erp.domain.FsJstAftersalePush;
 import com.fs.erp.dto.BaseResponse;
 import com.fs.erp.dto.ErpRefundUpdateRequest;
+import com.fs.erp.mapper.FsJstAftersalePushMapper;
 import com.fs.erp.service.IErpOrderService;
 import com.fs.erp.utils.ErpContextHolder;
+import com.fs.express.enums.TaskStatusEnum;
 import com.fs.huifuPay.domain.HuiFuRefundResult;
 import com.fs.huifuPay.dto.*;
 import com.fs.huifuPay.sdk.opps.core.request.V2TradePaymentScanpayRefundRequest;
@@ -51,7 +55,9 @@ import com.hc.openapi.tool.fastjson.JSON;
 import lombok.Synchronized;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.aop.framework.AopContext;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.stereotype.Service;
 import com.fs.store.mapper.FsStoreAfterSalesMapper;
 import org.springframework.transaction.annotation.Propagation;
@@ -65,6 +71,7 @@ import org.springframework.transaction.interceptor.TransactionAspectSupport;
  * @date 2022-03-15
  */
 @Service
+@EnableAspectJAutoProxy(proxyTargetClass = true,exposeProxy = true)
 public class FsStoreAfterSalesServiceImpl implements IFsStoreAfterSalesService
 {
     Logger logger= LoggerFactory.getLogger(getClass());
@@ -111,6 +118,8 @@ public class FsStoreAfterSalesServiceImpl implements IFsStoreAfterSalesService
 
     @Autowired
     private FsWarehousesMapper fsWarehousesMapper;
+    @Autowired
+    private FsJstAftersalePushMapper fsJstAftersalePushMapper;
 
 
     /**
@@ -333,9 +342,8 @@ public class FsStoreAfterSalesServiceImpl implements IFsStoreAfterSalesService
     }
 
     @Override
-    @Transactional
-    @Synchronized
     @RepeatSubmit
+    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
     public R revoke(long userId, Long id) throws ParseException {
         FsStoreAfterSales storeAfterSales = fsStoreAfterSalesMapper.selectFsStoreAfterSalesById(id);
         if (storeAfterSales == null) {
@@ -383,20 +391,21 @@ public class FsStoreAfterSalesServiceImpl implements IFsStoreAfterSalesService
             }
         }
         fsStoreAfterSalesMapper.updateFsStoreAfterSales(storeAfterSales);
+
+        // erp撤销售后单
+        // 如果当前订单是属于jst erp
+        if(StringUtils.isNotBlank(order.getStoreHouseCode())){
+            String erp = fsWarehousesMapper.selectErpByCode(order.getStoreHouseCode());
+            if(StringUtils.equals(erp, ErpTypeConstant.JST_ERP)){
+                FsJstAftersalePush fsJstAftersalePush = new FsJstAftersalePush();
+                fsJstAftersalePush.setOrderId(order.getOrderCode());
+                fsJstAftersalePush.setTaskStatus(TaskStatusEnum.PENDING.getCode());
+                fsJstAftersalePush.setType(String.valueOf(AfterSalesOrderStatusEnum.CLOSED.getIndex()));
+                fsJstAftersalePush.setRetryCount(0);
+                fsJstAftersalePushMapper.insert(fsJstAftersalePush);
+            }
+        }
         return R.ok();
-//        //更新OMS
-//        ErpRefundUpdateRequest request=new ErpRefundUpdateRequest();
-//        request.setTid(order.getOrderCode());
-//        request.setOid(order.getOrderCode());
-//        request.setRefund_state(0);
-//        BaseResponse response= erpOrderService.refundUpdate(request);
-//        if(response.getSuccess()){
-//            return R.ok();
-//        }
-//        else{
-//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-//            return R.error(response.getErrorDesc());
-//        }
     }
 
     @Override
@@ -412,6 +421,7 @@ public class FsStoreAfterSalesServiceImpl implements IFsStoreAfterSalesService
     }
 
     @Override
+    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
     public R addDelivery(FsStoreAfterSalesDeliveryParam param) {
         FsStoreAfterSales storeAfterSales = fsStoreAfterSalesMapper.selectFsStoreAfterSalesById(param.getSalesId());
         if (storeAfterSales == null) {
@@ -434,6 +444,20 @@ public class FsStoreAfterSalesServiceImpl implements IFsStoreAfterSalesService
         storeAfterSalesStatus.setOperator(user.getNickname());
         afterSalesStatusService.insertFsStoreAfterSalesStatus(storeAfterSalesStatus);
         fsStoreAfterSalesMapper.updateFsStoreAfterSales(storeAfterSales);
+        FsStoreOrder order = fsStoreOrderService.selectFsStoreOrderByOrderCode(storeAfterSales.getOrderCode());
+
+        // 如果当前订单是属于jst erp
+        if(order != null && StringUtils.isNotBlank(order.getStoreHouseCode())){
+            String erp = fsWarehousesMapper.selectErpByCode(order.getStoreHouseCode());
+            if(StringUtils.equals(erp, ErpTypeConstant.JST_ERP)){
+                FsJstAftersalePush fsJstAftersalePush = new FsJstAftersalePush();
+                fsJstAftersalePush.setOrderId(order.getOrderCode());
+                fsJstAftersalePush.setTaskStatus(TaskStatusEnum.PENDING.getCode());
+                fsJstAftersalePush.setType(String.valueOf(AfterSalesOrderStatusEnum.WAIT_SELLER_CONFIRM_GOODS.getIndex()));
+                fsJstAftersalePush.setRetryCount(0);
+                fsJstAftersalePushMapper.insert(fsJstAftersalePush);
+            }
+        }
         return R.ok();
     }
 
@@ -552,10 +576,12 @@ public class FsStoreAfterSalesServiceImpl implements IFsStoreAfterSalesService
 
     @Override
     public synchronized R refundMoney(FsStoreAfterSalesRefundParam param) {
-       return refundStoreMoney(param);
+        IFsStoreAfterSalesService fsStoreAfterSalesService = (IFsStoreAfterSalesService) AopContext.currentProxy();
+        return fsStoreAfterSalesService.refundStoreMoney(param);
     }
-    @Transactional
-    R refundStoreMoney(FsStoreAfterSalesRefundParam param){
+    @Override
+    @Transactional(rollbackFor = Throwable.class,propagation = Propagation.REQUIRED)
+    public R refundStoreMoney(FsStoreAfterSalesRefundParam param){
         FsStoreAfterSales storeAfterSales = fsStoreAfterSalesMapper.selectFsStoreAfterSalesById(param.getSalesId());
         if (storeAfterSales == null) {
             throw new CustomException("未查询到售后订单信息");
@@ -682,6 +708,27 @@ public class FsStoreAfterSalesServiceImpl implements IFsStoreAfterSalesService
         if(order.getTuiUserId()!=null&&order.getTuiUserId()>0){
             userService.subTuiMoney(order);
         }
+
+        // 财务审核通过，同步到jst erp
+        if(StringUtils.isNotBlank(order.getStoreHouseCode())){
+            String erp = fsWarehousesMapper.selectErpByCode(order.getStoreHouseCode());
+            if(StringUtils.equals(erp, ErpTypeConstant.JST_ERP)){
+                FsJstAftersalePush fsJstAftersalePush = new FsJstAftersalePush();
+                fsJstAftersalePush.setOrderId(order.getOrderCode());
+                fsJstAftersalePush.setTaskStatus(TaskStatusEnum.PENDING.getCode());
+                fsJstAftersalePush.setType(String.valueOf(AfterSalesOrderStatusEnum.SUCCESS.getIndex()));
+                fsJstAftersalePush.setRetryCount(0);
+                fsJstAftersalePushMapper.insert(fsJstAftersalePush);
+
+                // 售后单改成已确认
+                FsJstAftersalePush aftersaleConfirm = new FsJstAftersalePush();
+                aftersaleConfirm.setOrderId(order.getOrderCode());
+                aftersaleConfirm.setTaskStatus(TaskStatusEnum.PENDING.getCode());
+                aftersaleConfirm.setType(String.valueOf(AfterSalesOrderStatusEnum.CONFIRM.getIndex()));
+                aftersaleConfirm.setRetryCount(0);
+                fsJstAftersalePushMapper.insert(aftersaleConfirm);
+            }
+        }
         return R.ok();
     }
 
@@ -709,29 +756,37 @@ public class FsStoreAfterSalesServiceImpl implements IFsStoreAfterSalesService
         storeAfterSalesStatus.setChangeTime(Timestamp.valueOf(LocalDateTime.now()));
         storeAfterSalesStatus.setOperator(param.getOperator());
         afterSalesStatusService.insertFsStoreAfterSalesStatus(storeAfterSalesStatus);
-        //创建新的OMS订单
-        if (storeAfterSales.getOrderStatus().equals(OrderInfoEnum.STATUS_1.getValue()) ) {
-            if(StringUtils.isNotEmpty(order.getExtendOrderId())){
-                //更新订单code
-                String orderSn = IdUtil.getSnowflake(0, 0).nextIdStr();
-                FsStoreOrder orderMap=new FsStoreOrder();
-                orderMap.setId(order.getId());
-                orderMap.setOrderCode(orderSn);
-                orderService.updateFsStoreOrder(orderMap);
-                storeAfterSales.setOrderCode(orderSn);
-                orderItemService.updateFsStoreOrderCode(order.getId(),orderSn);
-                //生成新的订单
-                orderService.createOmsOrder(order.getId());
+
+        if(StringUtils.isNotBlank(order.getStoreHouseCode())) {
+            String erp = fsWarehousesMapper.selectErpByCode(order.getStoreHouseCode());
+            if (StringUtils.equals(erp, ErpTypeConstant.JST_ERP)) {
+                FsJstAftersalePush fsJstAftersalePush = new FsJstAftersalePush();
+                fsJstAftersalePush.setOrderId(order.getOrderCode());
+                fsJstAftersalePush.setTaskStatus(TaskStatusEnum.PENDING.getCode());
+                fsJstAftersalePush.setType(String.valueOf(AfterSalesOrderStatusEnum.CLOSED.getIndex()));
+                fsJstAftersalePush.setRetryCount(0);
+                fsJstAftersalePushMapper.insert(fsJstAftersalePush);
+            } else {
+                //创建新的OMS订单
+                if (storeAfterSales.getOrderStatus().equals(OrderInfoEnum.STATUS_1.getValue()) ) {
+                    if(StringUtils.isNotEmpty(order.getExtendOrderId())){
+                        //更新订单code
+                        String orderSn = IdUtil.getSnowflake(0, 0).nextIdStr();
+                        FsStoreOrder orderMap=new FsStoreOrder();
+                        orderMap.setId(order.getId());
+                        orderMap.setOrderCode(orderSn);
+                        orderService.updateFsStoreOrder(orderMap);
+                        storeAfterSales.setOrderCode(orderSn);
+                        orderItemService.updateFsStoreOrderCode(order.getId(),orderSn);
+                        //生成新的订单
+                        orderService.createOmsOrder(order.getId());
+                    }
+                }
             }
         }
+
         fsStoreAfterSalesMapper.updateFsStoreAfterSales(storeAfterSales);
         return R.ok();
-
-//        ErpRefundUpdateRequest request=new ErpRefundUpdateRequest();
-//        request.setTid(order.getOrderCode());
-//        request.setOid(order.getOrderCode());
-//        request.setRefund_state(0);
-//        erpOrderService.refundUpdate(request);
     }
 
     @Override

fs-user-app/src/main/java/com/fs/app/controller/StoreAfterSalesController.java

@@ -72,8 +72,6 @@ public class StoreAfterSalesController extends  AppBaseController {
         return storeAfterSalesService.addDelivery(param);
     }
 
-
-
     @Login
     @GetMapping("/getAfterSalesList")
     @ApiOperation(value = "获取售后列表", notes = "获取售后列表")