1

zhangc

2025-04-16 2a0f422815c0379e6d4bf795a2eac435da9b3df2

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
132
133
134
135
136
137
138
139
140
141
142
143
package com.zy.asrs.task;
 
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.core.common.Cools;
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.OrderDetlMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.task.core.ReturnT;
import com.zy.asrs.task.handler.OrderSyncHandler;
import com.zy.common.entity.Parameter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
 
import java.util.List;
 
/**
 * Created by vincent on 2020/7/7
 */
@Slf4j
@Component
public class OrderSyncScheduler {
 
    @Autowired
    private OrderSyncHandler orderSyncHandler;
    @Autowired
    private OrderService orderService;
 
 
    @Autowired
    private OrderLogService orderLogService;
 
    @Autowired
    private OrderDetlLogService orderDetlLogService;
 
 
    @Autowired
    private ApiLogService apiLogService;
 
    @Autowired
    private AgvLocDetlService agvLocDetlService;
 
    @Autowired
    private OrderDetlService orderDetlService;
 
    @Autowired
    private OrderDetlMapper orderDetlMapper;
 
    @Autowired
    private DocTypeService docTypeService;
 
    @Autowired
    private AgvWrkDetlService agvWrkDetlService;
 
    private Integer page = 1;
 
    private Integer size = 200;
 
    @Scheduled(cron = "0 0 1 * * ? ")
    public void clearApiLog() {
        try {
            apiLogService.clearWeekBefore();
        } catch (Exception e) {
            log.error("第三方接口日志自动清除失败（范围：一周之前", e);
        }
    }
 
    //@Scheduled(cron = "0/5 * * * * ? ")
    @Scheduled(fixedDelay = 600000)
    //@Async("orderThreadPool")
    public void completeAndReport() {
        String erpReport = Parameter.get().getErpReport();
        if (!Cools.isEmpty(erpReport) && erpReport.equals("true")) {
            List<Order> orders = orderService.selectComplete();
            for (Order order : orders) {
                //如果是调拨单则进行判断
                if (order.getDocType() == 33) {
                    //查询库存中是否存在该订单的物料信息，存在则不处理该订单
                    List<OrderDetl> orderDetlList = orderDetlService.selectByOrderId(order.getId());
                    Boolean flag = false;
                    for (OrderDetl orderDetl : orderDetlList) {
                        List<AgvLocDetl> agvLocDetls = agvLocDetlService.selectList(new EntityWrapper<AgvLocDetl>().eq("matnr", orderDetl.getMatnr()).eq("three_code", orderDetl.getThreeCode()));
                        boolean agvWrkDetlExist = agvWrkDetlService.selectCount(new EntityWrapper<AgvWrkDetl>().like("order_no", order.getOrderNo())) < 1;
                        if (!Cools.isEmpty(agvLocDetls) && agvWrkDetlExist) {
                            //只要有一项订单明细存在，则标识为true，跳过该订单
                            flag = true;
                        }
                    }
                    if (flag) {
                        continue;
                    }
                }
                ReturnT<String> result = orderSyncHandler.start(order);
                if (!result.isSuccess()) {
                    //log.error("单据[orderNo={}]上报erp失败", order.getOrderNo());
                }
            }
        }
    }
 
    //@Scheduled(cron = "* 0/5 * * * ? ")
    //@Scheduled(cron = "0/30 * * * * ? ")
    @Scheduled(fixedDelay = 30000)
    //@Async("orderThreadPool")
    public synchronized void reportOrder() {
        DocType docType = docTypeService.selectOne(new EntityWrapper<DocType>().eq("doc_name", "银座采购入库单"));
        if (docType != null) {
            List<String> reportDetl = orderDetlMapper.getReportDetl(docType.getDocId());
            reportDetl.forEach(orderNo -> {
                orderSyncHandler.timelyStart(orderService.selectByNo(orderNo));
            });
        }
    }
 
 
    /*
    定时查询状态为2.作业中的单据，检查是否完成
     */
    //@Scheduled(cron = "0 */1 * * * ? ")
    @Scheduled(fixedDelay = 120000)
    public void completeOrder() {
        try {
            Page<Order> settle = orderService.selectPage(new Page<Order>(page, size), new EntityWrapper<Order>().eq("settle", 2));
            if (settle != null) {
                List<Order> orderList = settle.getRecords();
                if (orderList == null || orderList.isEmpty()) {
                    log.info("轮询完毕，{},{}", page, settle.getTotal());
                    page = 1;
                    return;
                }
                orderList.forEach(order -> {
                    orderService.checkComplete2(order.getOrderNo());
                });
            }
        } finally {
            page++;
        }
    }
 
 
}