入库流程修改

skyouc

6 天以前 b2dbc07e7d3c3f336a0090b7457c89c6895d5e40

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
package com.zy.asrs.task;
 
import com.core.common.Cools;
import com.zy.asrs.entity.Order;
import com.zy.asrs.service.ApiLogService;
import com.zy.asrs.service.OrderService;
import com.zy.asrs.task.core.ReturnT;
import com.zy.asrs.task.handler.OrderSyncHandler;
import com.zy.asrs.utils.OrderInAndOutUtil;
import com.zy.common.entity.Parameter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
 
import java.util.List;
 
/**
 * updated by IX in 2024/12/17
 */
@Slf4j
@Component
public class OrderSyncScheduler {
 
    @Autowired
    private OrderSyncHandler orderSyncHandler;
    @Autowired
    private OrderService orderService;
    @Autowired
    private ApiLogService apiLogService;
 
    @Value("${erp.switch.ErpReportOld}")
    private boolean ErpReportOld;
 
    @Scheduled(cron = "0 0 1 * * ? ")
    public void clearApiLog() {
        try {
            apiLogService.clearWeekBefore();
        } catch (Exception e) {
            log.error("第三方接口日志自动清除失败（范围：一周之前", e);
        }
    }
 
    @Scheduled(cron = "0 1 * * * ? ")
    @Async("orderThreadPool")
    public void completeAndReportOrderIssuedOnceMore() {
        List<Order> orderList = orderService.selectComplete99();
        for (Order order : orderList) {
            try {
                ReturnT<String> result = orderSyncHandler.startOrderIssuedOnceMore(order);
                if (!result.isSuccess()) {
                    log.error("单据[orderNo={}]再次转执行表失败:{}", order.getOrderNo(),result.getMsg());
                }
            } catch (Exception e){
                log.error(e.getMessage());
                log.error("单据[orderNo={}]再次转执行表失败", order.getOrderNo());
            }
        }
    }
 
    /**
     * 上报单据转执行单据
     * @author Ryan
     * @date 2026/1/5 14:07
     */
    @Scheduled(cron = "0/30 * * * * ? ")
    @Async("orderThreadPool")
    public void completeAndReportOrderIssued() {
//        String erpReport = Parameter.get().getErpReport();
//        if (!Cools.isEmpty(erpReport) && erpReport.equals("true")) {
            List<Order> orderList = orderService.selectComplete1();
//            List<Order> orderList = orderService.selectList(new EntityWrapper<Order>().eq("settle", 1L).eq("status", 1).orderBy("create_time", true));
            for (Order order : orderList) {
                try {
                    ReturnT<String> result = orderSyncHandler.startOrderIssued(order);
                    if (!result.isSuccess()) {
                        log.error("单据[orderNo={}]转执行表失败", order.getOrderNo());
                    }
                } catch (Exception e){
                    log.error(e.getMessage());
                    log.error("单据[orderNo={}]转执行表失败", order.getOrderNo());
                }
            }
//        }
    }
 
//    @Scheduled(cron = "0/5 * * * * ? ")
    @Async("orderThreadPool")
    public void completeAndReportOrderInAndOutUtil() {
//        String erpReport = Parameter.get().getErpReport();
//        if (!Cools.isEmpty(erpReport) && erpReport.equals("true")) {
            List<Order> orders = OrderInAndOutUtil.selectComplete(null);
            for (Order order : orders) {
                try {
                    ReturnT<String> result = orderSyncHandler.startOrderInAndOutUtil(order);
                    if (!result.isSuccess()) {
                        log.error("单据[orderNo={}]转上报表失败", order.getOrderNo());
                    }
                } catch (Exception e){
                    log.error(e.getMessage());
                    log.error("单据[orderNo={}]转上报表失败", order.getOrderNo());
                }
            }
//        }
    }
 
//    @Scheduled(cron = "0/30 * * * * ? ")
    @Async("orderThreadPool")
    public void completeAndReportOrderReport() {
        if (!ErpReportOld){
            return;
        }
        String erpReport = Parameter.get().getErpReport();
        if (!Cools.isEmpty(erpReport) && erpReport.equals("true")) {
            List<Order> orders = orderService.selectComplete();
            for (Order order : orders) {
                try {
                    ReturnT<String> result = orderSyncHandler.startOrderReport(order);
                    if (!result.isSuccess()) {
                        log.error("单据[orderNo={}]上报erp失败", order.getOrderNo());
                    }
                } catch (Exception e) {
                    log.error(e.getMessage());
                    log.error("单据[orderNo={}]上报erp失败", order.getOrderNo());
                }
            }
        }
    }
}