Junjie
3 天以前 3e793a6d2173889f4d006f2c8174f3eec4992745
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
package com.zy.asrs.task;
 
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.WrkMastService;
import com.zy.core.enums.WrkStsType;
import com.zy.core.task.MainProcessTaskSubmitter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.Date;
import java.util.List;
 
@Component
@Slf4j
public class WrkMastScheduler {
 
    private static final long MIN_SUBMIT_INTERVAL_MS = 0L;
    private static final String WRK_MAST_FINALIZE_LANE_PREFIX = "wrk-mast-finalize-";
 
    private final WrkMastService wrkMastService;
    private final LocMastService locMastService;
    private final MainProcessTaskSubmitter mainProcessTaskSubmitter;
    private final WrkMastFinalizeProcessor wrkMastFinalizeProcessor;
 
    public WrkMastScheduler(WrkMastService wrkMastService,
                            LocMastService locMastService,
                            MainProcessTaskSubmitter mainProcessTaskSubmitter,
                            WrkMastFinalizeProcessor wrkMastFinalizeProcessor) {
        this.wrkMastService = wrkMastService;
        this.locMastService = locMastService;
        this.mainProcessTaskSubmitter = mainProcessTaskSubmitter;
        this.wrkMastFinalizeProcessor = wrkMastFinalizeProcessor;
    }
 
    @Scheduled(cron = "0/1 * * * * ? ")
    public void executeIn() {
        submitByWrkNo(new QueryWrapper<WrkMast>().eq("wrk_sts", WrkStsType.COMPLETE_INBOUND.sts),
                "executeIn",
                wrkMastFinalizeProcessor::processCompleteInbound);
    }
 
    @Scheduled(cron = "0/1 * * * * ? ")
    public void executeOut() {
        submitByWrkNo(new QueryWrapper<WrkMast>().eq("wrk_sts", WrkStsType.COMPLETE_OUTBOUND.sts),
                "executeOut",
                wrkMastFinalizeProcessor::processCompleteOutbound);
    }
 
    @Scheduled(cron = "0/1 * * * * ? ")
    public void executeLocMove() {
        submitByWrkNo(new QueryWrapper<WrkMast>().eq("wrk_sts", WrkStsType.COMPLETE_LOC_MOVE.sts),
                "executeLocMove",
                wrkMastFinalizeProcessor::processCompleteLocMove);
    }
 
    @Scheduled(cron = "0/1 * * * * ? ")
    public void executeCrnMove() {
        submitByWrkNo(new QueryWrapper<WrkMast>().eq("wrk_sts", WrkStsType.COMPLETE_CRN_MOVE.sts),
                "executeCrnMove",
                wrkMastFinalizeProcessor::processCompleteCrnMove);
    }
 
    @Scheduled(cron = "0/1 * * * * ? ")
    public void executeCancelTask() {
        submitByWrkNo(new QueryWrapper<WrkMast>().in("mk", "taskCancel", "taskForceCancel"),
                "executeCancelTask",
                wrkMastFinalizeProcessor::processCancelTask);
    }
 
    @Scheduled(cron = "0/1 * * * * ? ")
    @Transactional
    public void processOutStationRun(){
        List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>().eq("wrk_sts", WrkStsType.STATION_RUN.sts));
        if (wrkMasts.isEmpty()) {
            return;
        }
 
        for (WrkMast wrkMast : wrkMasts) {
            String locNo = wrkMast.getSourceLocNo();
            LocMast locMast = locMastService.queryByLoc(locNo);
            if (locMast == null) {
                log.info("[workNo={}]库位不存在", wrkMast.getWrkNo());
                continue;
            }
 
            if (locMast.getLocSts().equals("O")) {
                continue;
            }
 
            if (!locMast.getLocSts().equals("R")) {
                log.info("[workNo={}]库位状态不处于R", wrkMast.getWrkNo());
                continue;
            }
 
            locMast.setLocSts("O");
            locMast.setBarcode("");
            locMast.setModiTime(new Date());
            boolean result = locMastService.updateById(locMast);
            if (!result) {
                log.info("[workNo={}]库位状态O更新失败", wrkMast.getWrkNo());
            }
        }
    }
 
    private void submitByWrkNo(QueryWrapper<WrkMast> queryWrapper, String taskNamePrefix, WrkNoHandler handler) {
        List<WrkMast> wrkMasts = wrkMastService.list(queryWrapper);
        if (wrkMasts.isEmpty()) {
            return;
        }
        for (WrkMast wrkMast : wrkMasts) {
            if (wrkMast == null || wrkMast.getWrkNo() == null || wrkMast.getWrkNo() <= 0) {
                log.error("WrkMastScheduler提交任务跳过,工作档为空或工作号非法。taskNamePrefix={}, wrkMast={}", taskNamePrefix, wrkMast);
                continue;
            }
            Integer wrkNo = wrkMast.getWrkNo();
            boolean submitted = mainProcessTaskSubmitter.submitKeyedSerialTask(
                    WRK_MAST_FINALIZE_LANE_PREFIX,
                    wrkNo,
                    taskNamePrefix + "-" + wrkNo,
                    MIN_SUBMIT_INTERVAL_MS,
                    () -> handler.handle(wrkNo)
            );
            if (!submitted) {
                log.error("WrkMastScheduler提交单任务处理失败。taskNamePrefix={}, wrkNo={}, lanePrefix={}",
                        taskNamePrefix, wrkNo, WRK_MAST_FINALIZE_LANE_PREFIX);
            }
        }
    }
 
    @FunctionalInterface
    private interface WrkNoHandler {
        void handle(Integer wrkNo);
    }
}