#
Junjie
2024-09-20 053e6028bd20e599aea103401137816c6296a9ef
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
package com.zy.asrs.wms.asrs.timer;
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.plugins.IgnoreStrategy;
import com.baomidou.mybatisplus.core.plugins.InterceptorIgnoreHelper;
import com.zy.asrs.framework.common.DateUtils;
import com.zy.asrs.framework.exception.CoolException;
import com.zy.asrs.wms.asrs.entity.*;
import com.zy.asrs.wms.asrs.entity.enums.OrderSettleType;
import com.zy.asrs.wms.asrs.service.*;
import com.zy.asrs.wms.system.entity.Dict;
import com.zy.asrs.wms.system.service.DictService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
 
import java.util.Date;
import java.util.List;
 
@Component
public class TaskLogTimer {
 
    @Autowired
    private TaskService taskService;
    @Autowired
    private TaskDetlService taskDetlService;
    @Autowired
    private TaskDetlFieldService taskDetlFieldService;
    @Autowired
    private TaskLogService taskLogService;
    @Autowired
    private TaskDetlLogService taskDetlLogService;
    @Autowired
    private TaskDetlFieldLogService taskDetlFieldLogService;
    @Autowired
    private OrderService orderService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private DictService dictService;
 
    @Scheduled(cron = "0/3 * * * * ? ")
    @Transactional
    public void inExecute() {
        InterceptorIgnoreHelper.handle(IgnoreStrategy.builder().tenantLine(true).build());
        try {
            //获取入库完成任务
            List<Task> list = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getTaskSts, 100));
            if (list.isEmpty()) {
                return;
            }
 
            for (Task task : list) {
                Long hostId = task.getHostId();
 
                //保存任务历史档
                TaskLog taskLog = new TaskLog();
                taskLog.sync(task);
                taskLog.setId(null);
                if (!taskLogService.save(taskLog)) {
                    throw new CoolException("保存任务历史档失败");
                }
 
                //删除任务历史档案
                if (!taskService.removeById(task.getId())) {
                    throw new CoolException("删除任务档失败");
                }
 
                //保存任务明细历史档
                List<TaskDetl> taskDetls = taskDetlService.getTaskDetlByTaskId(task.getId());
                if (taskDetls.isEmpty()) {
                    throw new CoolException("任务明细不存在");
                }
                for (TaskDetl taskDetl : taskDetls) {
                    TaskDetlLog taskDetlLog = new TaskDetlLog();
                    taskDetlLog.sync(taskDetl);
                    taskDetlLog.setId(null);
                    taskDetlLog.setTaskId(taskLog.getId());
                    if (!taskDetlLogService.save(taskDetlLog)) {
                        throw new CoolException("保存任务明细历史档失败");
                    }
 
                    //保存明细扩展字段历史档
                    List<TaskDetlField> detlFields = taskDetlFieldService.list(new LambdaQueryWrapper<TaskDetlField>().eq(TaskDetlField::getDetlId, taskDetl.getId()).eq(TaskDetlField::getHostId, hostId));
                    for (TaskDetlField detlField : detlFields) {
                        //明细扩展字段数据保存至历史档
                        TaskDetlFieldLog taskDetlFieldLog = new TaskDetlFieldLog();
                        taskDetlFieldLog.sync(detlField);
                        taskDetlFieldLog.setId(null);
                        taskDetlFieldLog.setDetlId(taskDetlLog.getId());
                        if (!taskDetlFieldLogService.save(taskDetlFieldLog)) {
                            throw new CoolException("明细扩展字段转历史档案失败");
                        }
 
                        //删除明细扩展
                        boolean removeField = taskDetlFieldService.removeById(detlField.getId());
                        if (!removeField) {
                            throw new CoolException("删除明细扩展失败");
                        }
                    }
 
                    //删除明细
                    boolean removeDetl = taskDetlService.removeById(taskDetl.getId());
                    if (!removeDetl) {
                        throw new CoolException("明细删除失败");
                    }
                }
 
                //更新订单信息
                for (TaskDetl taskDetl : taskDetls) {
                    if (taskDetl.getDetlId() == null) {
                        continue;
                    }
 
                    OrderDetl orderDetl = orderDetlService.getById(taskDetl.getDetlId());
                    if (orderDetl == null) {
                        throw new CoolException("订单明细不存在");
                    }
 
                    orderDetl.setWorkQty(orderDetl.getWorkQty() - taskDetl.getAnfme());//工作中数量减少
                    orderDetl.setQty(orderDetl.getQty() + taskDetl.getAnfme());//已完成数量增加
                    orderDetl.setUpdateTime(new Date());
                    if (!orderDetlService.updateById(orderDetl)) {
                        throw new CoolException("更新订单明细失败");
                    }
 
                    //检测订单是否完成
                    boolean checkOrderComplete = orderService.checkOrderComplete(orderDetl.getOrderId());
                    if (checkOrderComplete) {
                        //订单已经完成
                        Order order = orderService.getById(orderDetl.getOrderId());
                        if (order == null) {
                            throw new CoolException("订单不存在");
                        }
 
                        order.setOrderSettle(OrderSettleType.COMPLETE.val());
                        order.setUpdateTime(new Date());
                        if (!orderService.updateById(order)) {
                            throw new CoolException("订单更新失败");
                        }
                    }
                }
 
 
            }
 
        } catch (Exception e) {
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        } finally {
            InterceptorIgnoreHelper.clearIgnoreStrategy();
        }
    }
 
    @Scheduled(cron = "0/3 * * * * ? ")
    @Transactional
    public void outExecute() {
        InterceptorIgnoreHelper.handle(IgnoreStrategy.builder().tenantLine(true).build());
        try {
            //获取出库完成任务
            List<Task> list = taskService.list(new LambdaQueryWrapper<Task>()
                    .eq(Task::getTaskSts, 200)
                    .in(Task::getTaskType, 101, 53, 57));
            if (list.isEmpty()) {
                return;
            }
 
            Dict dict = dictService.getOne(new LambdaQueryWrapper<Dict>().eq(Dict::getFlag, "taskLogDiffDays").eq(Dict::getStatus, 1));
            if(dict == null) {
                return;
            }
            for (Task task : list) {
                int diff = DateUtils.diff(task.getCreateTime(), new Date());
                int taskLogDiffDays = Integer.parseInt(dict.getValue());
                if (diff < taskLogDiffDays) {
                    continue;
                }
 
                Long hostId = task.getHostId();
 
                //保存任务历史档
                TaskLog taskLog = new TaskLog();
                taskLog.sync(task);
                taskLog.setId(null);
                if (!taskLogService.save(taskLog)) {
                    throw new CoolException("保存任务历史档失败");
                }
 
                //删除任务历史档案
                if (!taskService.removeById(task.getId())) {
                    throw new CoolException("删除任务档失败");
                }
 
                //保存任务明细历史档
                List<TaskDetl> taskDetls = taskDetlService.getTaskDetlByTaskId(task.getId());
                if (taskDetls.isEmpty()) {
                    throw new CoolException("任务明细不存在");
                }
                for (TaskDetl taskDetl : taskDetls) {
                    TaskDetlLog taskDetlLog = new TaskDetlLog();
                    taskDetlLog.sync(taskDetl);
                    taskDetlLog.setId(null);
                    taskDetlLog.setTaskId(taskLog.getId());
                    if (!taskDetlLogService.save(taskDetlLog)) {
                        throw new CoolException("保存任务明细历史档失败");
                    }
 
                    //保存明细扩展字段历史档
                    List<TaskDetlField> detlFields = taskDetlFieldService.list(new LambdaQueryWrapper<TaskDetlField>().eq(TaskDetlField::getDetlId, taskDetl.getId()).eq(TaskDetlField::getHostId, hostId));
                    for (TaskDetlField detlField : detlFields) {
                        //明细扩展字段数据保存至历史档
                        TaskDetlFieldLog taskDetlFieldLog = new TaskDetlFieldLog();
                        taskDetlFieldLog.sync(detlField);
                        taskDetlFieldLog.setId(null);
                        taskDetlFieldLog.setDetlId(taskDetlLog.getId());
                        if (!taskDetlFieldLogService.save(taskDetlFieldLog)) {
                            throw new CoolException("明细扩展字段转历史档案失败");
                        }
 
                        //删除明细扩展
                        boolean removeField = taskDetlFieldService.removeById(detlField.getId());
                        if (!removeField) {
                            throw new CoolException("删除明细扩展失败");
                        }
                    }
 
                    //删除明细
                    boolean removeDetl = taskDetlService.removeById(taskDetl.getId());
                    if (!removeDetl) {
                        throw new CoolException("明细删除失败");
                    }
                }
 
                //更新订单信息
                for (TaskDetl taskDetl : taskDetls) {
                    if (taskDetl.getDetlId() == null) {
                        continue;
                    }
 
                    OrderDetl orderDetl = orderDetlService.getById(taskDetl.getDetlId());
                    if (orderDetl == null) {
                        throw new CoolException("订单明细不存在");
                    }
 
                    orderDetl.setWorkQty(orderDetl.getWorkQty() - taskDetl.getAnfme());//工作中数量减少
                    orderDetl.setQty(orderDetl.getQty() + taskDetl.getAnfme());//已完成数量增加
                    orderDetl.setUpdateTime(new Date());
                    if (!orderDetlService.updateById(orderDetl)) {
                        throw new CoolException("更新订单明细失败");
                    }
 
                    //检测订单是否完成
                    boolean checkOrderComplete = orderService.checkOrderComplete(orderDetl.getOrderId());
                    if (checkOrderComplete) {
                        //订单已经完成
                        Order order = orderService.getById(orderDetl.getOrderId());
                        if (order == null) {
                            throw new CoolException("订单不存在");
                        }
 
                        order.setOrderSettle(OrderSettleType.COMPLETE.val());
                        order.setUpdateTime(new Date());
                        if (!orderService.updateById(order)) {
                            throw new CoolException("订单更新失败");
                        }
                    }
                }
 
 
            }
        } catch (Exception e) {
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        } finally {
            InterceptorIgnoreHelper.clearIgnoreStrategy();
        }
    }
 
}