OrderJob.java
15.7 KB
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
package com.order.erp.job;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.order.erp.common.constant.Constant;
import com.order.erp.common.utils.DateUtils;
import com.order.erp.common.utils.TransactionHelper;
import com.order.erp.domain.ApplyStatusEnum;
import com.order.erp.domain.OrderStatusEnum;
import com.order.erp.domain.dto.BaseDO;
import com.order.erp.domain.dto.order.*;
import com.order.erp.domain.vo.order.OrderInfoResultVO;
import com.order.erp.mapper.order.OrderBaseInfoMapper;
import com.order.erp.service.order.*;
import lombok.extern.slf4j.Slf4j;
import org.joda.time.DateTime;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author: xms
* @description: TODO
* @date: 2023/6/25 10:35
* @version: 1.0
*/
@Slf4j
@Component
public class OrderJob {
@Resource
private OrderBaseInfoService orderBaseInfoService;
@Resource
private OrderProfitAnalysisService profitAnalysisService;
@Resource
private OrderCompletionReportService reportService;
@Resource
private OrderTrackStageService trackStageService;
@Resource
private OrderInspectionStageService inspectionStageService;
@Resource
private TransactionHelper transactionHelper;
/**
* 每隔5分执行一次
*/
@Scheduled(cron = "0 */10 * * * ?")
// @Scheduled(cron = "*/5 * * * * ?")
public void checkCompleteExecute() {
log.info("执行开始时间：{}", DateTime.now().toString("yyyy-MM-dd HH:mm:ss"));
LambdaQueryWrapper<OrderBaseInfoDO> queryWrapper = new LambdaQueryWrapper<OrderBaseInfoDO>()
.eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
//这里如果要改的话,就改成不是扫三个月的,而是全部扫一遍。
.ge(OrderBaseInfoDO::getCreateTime, DateUtils.format(DateTime.now().minusMonths(Constant.ONE).toDate(), DateUtils.DATE_TIME))
.le(OrderBaseInfoDO::getCreateTime, DateUtils.format(DateTime.now().toDate(), DateUtils.DATE_TIME))
.ne(OrderBaseInfoDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
List<OrderBaseInfoDO> ordersDOS = orderBaseInfoService.list(queryWrapper);
List<OrderInfoResultVO> orderInfoResultVOS = orderBaseInfoService.wrapperOrderResultList(false, ordersDOS);
//遍历一下这个集合的数据,如果尾期尾期验货结果为PASS,pass 2ND,PASS 3ND,FAIL RELEASE就为订单完成。
Set<String> validResults = new HashSet<>(Arrays.asList("PASS", "PASS 2ND", "PASS 3RD", "FAIL RELEASE"));
List<OrderInfoResultVO> filteredOrders = orderInfoResultVOS.stream()
.filter(order -> order.getInspectionStageInfo() != null &&
validResults.contains(order.getInspectionStageInfo().getEndCheckResult()))
.collect(Collectors.toList());
if (CollectionUtils.isNotEmpty(filteredOrders)) {
Set<Long> orderIds = filteredOrders.stream().map(OrderInfoResultVO::getId).collect(Collectors.toSet());
//不再使用上述的方式,
if (CollectionUtils.isNotEmpty(orderIds)) {
LambdaUpdateWrapper<OrderBaseInfoDO> orderBaseUpdateWrapper = new LambdaUpdateWrapper<OrderBaseInfoDO>()
.in(OrderBaseInfoDO::getId, orderIds).set(OrderBaseInfoDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
LambdaUpdateWrapper<OrderCompletionReportDO> reportUpdateWrapper = new LambdaUpdateWrapper<OrderCompletionReportDO>()
.in(OrderCompletionReportDO::getOrderId, orderIds).set(OrderCompletionReportDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
LambdaUpdateWrapper<OrderProfitAnalysisDO> profitUpdateWrapper = new LambdaUpdateWrapper<OrderProfitAnalysisDO>()
.in(OrderProfitAnalysisDO::getOrderId, orderIds).set(OrderProfitAnalysisDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
LambdaUpdateWrapper<OrderTrackStageDO> trackUpdateWrapper = new LambdaUpdateWrapper<OrderTrackStageDO>()
.in(OrderTrackStageDO::getOrderId, orderIds).set(OrderTrackStageDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
LambdaUpdateWrapper<OrderInspectionStageDO> inspectUpdateWrapper = new LambdaUpdateWrapper<OrderInspectionStageDO>()
.in(OrderInspectionStageDO::getOrderId, orderIds).set(OrderInspectionStageDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
transactionHelper.run(() -> {
orderBaseInfoService.update(orderBaseUpdateWrapper);
reportService.update(reportUpdateWrapper);
profitAnalysisService.update(profitUpdateWrapper);
trackStageService.update(trackUpdateWrapper);
inspectionStageService.update(inspectUpdateWrapper);
});
}
}
log.info("执行结束时间：{}", DateTime.now().toString("yyyy-MM-dd HH:mm:ss"));
}
/**
* 每隔5分执行一次
*/
// @Scheduled(cron = "*/5 * * * * ?")
public void checkChargeOrderCount() {
log.info("执行开始时间：{}", DateTime.now().toString("yyyy-MM-dd HH:mm:ss"));
// orderBaseInfoService.checkChargeOrderCount(null);
log.info("执行结束时间：{}", DateTime.now().toString("yyyy-MM-dd HH:mm:ss"));
}
// 以下两个定时任务都是一次性的。
//写一个扫描全部订单。只要有一栏填写了数据,就相当于完成了。 只扫描一次。 每五分钟扫描一次,只要有一栏填写了数据,就相当于完成了。 在填充接口中,设置只要填充了一栏就算上订单完成。
// @Scheduled(cron = "0 3 3 4 1 ?", zone = "Asia/Shanghai")
//这里扫描全部未完成的订单。重新设置订单完成的状态。
public void checkFinish() {
log.info("执行开始时间：{}", DateTime.now().toString("yyyy-MM-dd HH:mm:ss"));
LambdaQueryWrapper<OrderBaseInfoDO> queryWrapper = new LambdaQueryWrapper<OrderBaseInfoDO>()
.eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
.ne(OrderBaseInfoDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
List<OrderBaseInfoDO> ordersDOS = orderBaseInfoService.list(queryWrapper);
List<OrderInfoResultVO> orderInfoResultVOS = orderBaseInfoService.wrapperOrderResultList(false, ordersDOS);
if (CollectionUtils.isNotEmpty(orderInfoResultVOS)) {
//这里设置为>=的目的是,填充五个的话,就为5,填充4的的话就为4,除4,要么为1要么为1.25。这种情况都算订单完成。
Set<Long> orderIds = orderInfoResultVOS.stream().filter(x -> Objects.nonNull(x.getSchedule()) && Constant.ONE <= x.getSchedule()).map(OrderInfoResultVO::getId).collect(Collectors.toSet());
if (CollectionUtils.isNotEmpty(orderIds)) {
LambdaUpdateWrapper<OrderBaseInfoDO> orderBaseUpdateWrapper = new LambdaUpdateWrapper<OrderBaseInfoDO>()
.in(OrderBaseInfoDO::getId, orderIds).set(OrderBaseInfoDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
LambdaUpdateWrapper<OrderCompletionReportDO> reportUpdateWrapper = new LambdaUpdateWrapper<OrderCompletionReportDO>()
.in(OrderCompletionReportDO::getOrderId, orderIds).set(OrderCompletionReportDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
LambdaUpdateWrapper<OrderProfitAnalysisDO> profitUpdateWrapper = new LambdaUpdateWrapper<OrderProfitAnalysisDO>()
.in(OrderProfitAnalysisDO::getOrderId, orderIds).set(OrderProfitAnalysisDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
LambdaUpdateWrapper<OrderTrackStageDO> trackUpdateWrapper = new LambdaUpdateWrapper<OrderTrackStageDO>()
.in(OrderTrackStageDO::getOrderId, orderIds).set(OrderTrackStageDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
LambdaUpdateWrapper<OrderInspectionStageDO> inspectUpdateWrapper = new LambdaUpdateWrapper<OrderInspectionStageDO>()
.in(OrderInspectionStageDO::getOrderId, orderIds).set(OrderInspectionStageDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus());
transactionHelper.run(() -> {
orderBaseInfoService.update(orderBaseUpdateWrapper);
reportService.update(reportUpdateWrapper);
profitAnalysisService.update(profitUpdateWrapper);
trackStageService.update(trackUpdateWrapper);
inspectionStageService.update(inspectUpdateWrapper);
});
}
}
log.info("执行结束时间：{}", DateTime.now().toString("yyyy-MM-dd HH:mm:ss"));
}
//处理跟单和质检中的状态。
// @Scheduled(cron = "0 3 4 4 1 ?", zone = "Asia/Shanghai")
public void checkTrackInfoAndInspectionInfoStatus() {
log.info("执行开始时间：{}", DateTime.now().toString("yyyy-MM-dd HH:mm:ss"));
List<OrderTrackStageDO> orderTrackStageDOS = trackStageService.list(new LambdaQueryWrapper<OrderTrackStageDO>().eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN).ne(OrderTrackStageDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus()));
List<OrderInspectionStageDO> orderInspectionStageDOS = inspectionStageService.list(new LambdaQueryWrapper<OrderInspectionStageDO>().eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN).ne(OrderInspectionStageDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus()));
Set<Long> trackOrderIds = orderTrackStageDOS.stream()
.map(OrderTrackStageDO::getOrderId)
.filter(orderId -> orderId != null) // 防止 orderId 为空
.collect(Collectors.toSet());
Set<Long> inspectionOrderIds = orderInspectionStageDOS.stream()
.map(OrderInspectionStageDO::getOrderId)
.filter(orderId -> orderId != null) // 防止 orderId 为空
.collect(Collectors.toSet());
//得到交集。
Set<Long> commonOrderIds = trackOrderIds.stream()
.filter(inspectionOrderIds::contains)
.collect(Collectors.toSet());
Map<Long,OrderTrackStageDO> orderTrackStageMap = orderTrackStageDOS.stream()
.filter(order -> order.getOrderId() != null)
.collect(Collectors.toMap(
OrderTrackStageDO::getOrderId,
order-> order,
(existing, replacement) -> existing // 处理 key 冲突时，保留现有值
));
Map<Long, OrderInspectionStageDO> orderInspectionStageMap = orderInspectionStageDOS.stream()
.filter(order -> order.getOrderId() != null)
.collect(Collectors.toMap(
OrderInspectionStageDO::getOrderId,
order ->order,
(existing, replacement) -> existing // 处理 key 冲突时，保留现有值
));
List<OrderInspectionStageDO> orderInspectionList = commonOrderIds.stream().map(order -> {
OrderInspectionStageDO inspectionStageDO = orderInspectionStageMap.get(order);
OrderTrackStageDO trackStageDO = orderTrackStageMap.get(order);
if (Objects.nonNull(inspectionStageDO) && Objects.nonNull(trackStageDO)) {
Integer trackStageDOOrderStatus = trackStageDO.getOrderStatus();
Integer inspectionStageDOOrderStatus = inspectionStageDO.getOrderStatus();
if (Objects.nonNull(trackStageDOOrderStatus) && Objects.nonNull(inspectionStageDOOrderStatus)
&& OrderStatusEnum.TRACK_ING.getStatus().equals(trackStageDOOrderStatus)
&& OrderStatusEnum.INSPECT_ING.getStatus().equals(inspectionStageDOOrderStatus)) {
//由于跟单和质检,一个订单你操作了跟单或者质检后,然后在操作一次质检或者跟单,在首页统计中跟单和质检就会计算两次,相当于多计算了一次,重复了。所以这里需要去重。
inspectionStageDO.setOrderStatus(OrderStatusEnum.INSPECT_PASS.getStatus());
return inspectionStageDO;
}
}
return null;
}).filter(Objects::nonNull).collect(Collectors.toList());
if(CollectionUtils.isNotEmpty(orderInspectionList)){
inspectionStageService.updateBatchById(orderInspectionList);
}
log.info("执行结束时间：{}", DateTime.now().toString("yyyy-MM-dd HH:mm:ss"));
}
//重新扫描一遍,扫描规则为:不扫描所有表,只扫描25年的数据,如果尾期验货为PASS,PASS 2DN,PASS 3ND,或者为FAIL RELEASE,那么它就设置为订单完成状态。并且,如果这个订单设置为订单完成状态。去看看这些订单是否存在相同的
//project_no和inner_no,如果存在就进行也设置为订单完成。
//这里需要改成某个时间段只执行一次。
//@Scheduled(cron = "0 */5 * * * ?")
public void orderStatusFinishCheck() {
LocalDate localDate = LocalDate.of(2023, 10, 1);
//查询2023年末之后的基础订单订单。
List<OrderBaseInfoDO> orderBaseInfoDOS = orderBaseInfoService.list(new LambdaQueryWrapper<OrderBaseInfoDO>().eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
.ge(OrderBaseInfoDO::getCreateTime, localDate));
List<Long> orderIds = orderBaseInfoDOS.stream().map(orderBaseInfoDO -> orderBaseInfoDO.getId()).collect(Collectors.toList());
//先把状态设置为跟单中。(因为现在很多虚假的订单完成状态,所以现在把这些订单设置为跟单中,然后重新扫描过滤。)
orderBaseInfoDOS.forEach(orderBaseInfoDO ->
orderBaseInfoDO.setOrderStatus(OrderStatusEnum.TRACK_ING.getStatus()));
orderBaseInfoService.updateBatchById(orderBaseInfoDOS);
//查询质检信息。
List<OrderInspectionStageDO> inspectionStageDOList = inspectionStageService.list(new LambdaQueryWrapper<OrderInspectionStageDO>().eq(BaseDO::getEnableFlag,Constant.ENABLE_TEN).in(OrderInspectionStageDO::getOrderId,orderIds));
Set<String> validResults = new HashSet<>(Arrays.asList("PASS", "PASS 2ND", "PASS 3RD", "FAIL RELEASE"));
List<OrderInspectionStageDO> filteredList = inspectionStageDOList.stream()
.filter(order -> order.getEndCheckResult() != null && validResults.contains(order.getEndCheckResult()))
.collect(Collectors.toList());
List<OrderBaseInfoDO> orderBaseInfoDOList = orderBaseInfoService.listByIds(filteredList.stream().map(OrderInspectionStageDO::getOrderId).collect(Collectors.toList()));
Set<String> uniqueCombinations=orderBaseInfoDOList.stream().map(order -> order.getProjectNo()+"-"+order.getInnerNo()).collect(Collectors.toSet());
List<OrderBaseInfoDO> finishStatusOrderBaseinfoList = orderBaseInfoDOS.stream().filter(order -> {
String combination = order.getProjectNo() + "-" + order.getInnerNo();
return uniqueCombinations.contains(combination);
})
.collect(Collectors.toList());
finishStatusOrderBaseinfoList.forEach(orderBaseInfoDO -> orderBaseInfoDO.setOrderStatus(OrderStatusEnum.ORDER_FINISH.getStatus()));
orderBaseInfoService.updateBatchById(finishStatusOrderBaseinfoList);
}
}