OrderJob.java
12.5 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
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.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.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.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
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);
//如果都填充完成为 1.25,如果只填写4个,则为1。 这里面的方法是否是要改成,只要对应的跟单,质检任何一个格子填写了数据,就算上完成就加一。
List<OrderInfoResultVO> orderInfoResultVOS = orderBaseInfoService.wrapperOrderResultList(false, ordersDOS);
if (CollectionUtils.isNotEmpty(orderInfoResultVOS)) {
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"));
}
/**
* 每隔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"));
}
}