OrderOverTimeEventJob.java
21.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
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
package com.order.erp.job;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.order.erp.common.constant.Constant;
import com.order.erp.common.utils.EmailSendUtils;
import com.order.erp.common.utils.StringUtils;
import com.order.erp.common.utils.TransactionHelper;
import com.order.erp.domain.EmailTemplateEnum;
import com.order.erp.domain.OrderEventEnum;
import com.order.erp.domain.OrderStatusEnum;
import com.order.erp.domain.dto.BaseDO;
import com.order.erp.domain.dto.order.OrderBaseInfoDO;
import com.order.erp.domain.dto.order.OrderInspectionStageDO;
import com.order.erp.domain.dto.order.OrderTrackStageDO;
import com.order.erp.domain.dto.order.ReceiveEmailMappingDO;
import com.order.erp.domain.email.OrderProductEmailVO;
import com.order.erp.domain.vo.order.OrderEventJobVO;
import com.order.erp.domain.vo.order.ReceiveEmailConfigItemVO;
import com.order.erp.service.order.*;
import freemarker.template.TemplateException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import javax.mail.MessagingException;
import java.io.File;
import java.io.IOException;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import static com.order.erp.domain.EmailTemplateEnum.BIG_SAMPLE_TEMPLATE;
/**
* @author: xms
* @description: TODO
* @date: 2023/6/25 10:35
* @version: 1.0
*/
@Slf4j
@Component
public class OrderOverTimeEventJob {
@Resource
private OrderBaseInfoService orderBaseInfoService;
@Resource
private OrderProfitAnalysisService profitAnalysisService;
@Resource
private OrderCompletionReportService reportService;
@Resource
private OrderTrackStageService trackStageService;
@Resource
private OrderInspectionStageService inspectionStageService;
@Resource
private TransactionHelper transactionHelper;
@Resource
private EmailSendUtils emailSendUtils;
@Resource
private ReceiveEmailMappingService receiveEmailMappingService;
/**
* 凌晨1点执行，一天一次
*/
@Scheduled(cron = "0 0 1 * * ?")
public void checkOverTimeExecute() {
/*首先判断字符串。如果没有ok并且次数达到了三次(统计fail是否存在三次),就提醒。
* 如果有ok,取出ok前的日期,得到日期,那这个日期与HOD日期进行判断*/
List<OrderBaseInfoDO> orderBaseInfoList = orderBaseInfoService.list(new LambdaQueryWrapper<OrderBaseInfoDO>()
.eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
.ne(OrderBaseInfoDO::getOrderStatus, OrderStatusEnum.ORDER_FINISH.getStatus()));
Set<Long> orderList = orderBaseInfoList.stream().map(OrderBaseInfoDO::getId).collect(Collectors.toSet());
Map<Long, OrderBaseInfoDO> baseInfoDOMap = orderBaseInfoList.stream().collect(Collectors.toMap(OrderBaseInfoDO::getId, Function.identity(), (x, y) -> x));
List<OrderInspectionStageDO> orderInspectionStageList = inspectionStageService.listByIds(orderList);
Map<Long, OrderInspectionStageDO> inspectionStageDOMap = orderInspectionStageList.stream().collect(Collectors.toMap(OrderInspectionStageDO::getOrderId, Function.identity(), (x, y) -> x));
List<OrderTrackStageDO> orderTrackStageList = trackStageService.listByIds(orderList);
OrderProductEmailVO orderProductEmailVO = new OrderProductEmailVO();
System.out.println("1111111111111111111111111");
//只有跟单信息不为空时,才会有时间和状态。
if (CollectionUtils.isNotEmpty(orderTrackStageList)) {
System.out.println("orderId" + baseInfoDOMap);
System.out.println("order Base Info" + inspectionStageDOMap);
orderTrackStageList.stream().forEach(x -> {
System.out.println("orderId" + x.getOrderId());
System.out.println("order Base Info" + baseInfoDOMap.get(x.getOrderId()));
if (StringUtils.isBlank(baseInfoDOMap.get(x.getOrderId()).getOrderHodTime())) {
// return ServerResult.fail("HODTime不能为空");
}
if (baseInfoDOMap.get(x.getOrderId()).getId() == x.getOrderId()) {
orderProductEmailVO.setBaseInfo(baseInfoDOMap.get(x.getOrderId()));
try {
System.out.println("222222222222222222222");
test(EmailTemplateEnum.AITEX_SGS_TEST_TEMPLATE, x.getPpConfirmResult(), orderProductEmailVO);
System.out.println("2333333333333333333333");
} catch (MessagingException e) {
throw new RuntimeException(e);
} catch (TemplateException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
test(EmailTemplateEnum.CONFIRM_SAMPLE_TEMPLATE, x.getShippmentSampleConfirmResult(), orderProductEmailVO);
} catch (MessagingException e) {
throw new RuntimeException(e);
} catch (TemplateException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
test(EmailTemplateEnum.AITEX_SGS_TEST_TEMPLATE, x.getAitexTestFinishResult(), orderProductEmailVO);
} catch (MessagingException e) {
throw new RuntimeException(e);
} catch (TemplateException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
test(EmailTemplateEnum.AITEX_SGS_TEST_TEMPLATE, x.getSgsTestFinishResult(), orderProductEmailVO);
} catch (MessagingException e) {
throw new RuntimeException(e);
} catch (TemplateException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
test(EmailTemplateEnum.OTHER_SAMPLE_TEMPLATE, x.getEsoSampleSendTime(), orderProductEmailVO);
} catch (MessagingException e) {
throw new RuntimeException(e);
} catch (TemplateException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
test(EmailTemplateEnum.BARCODE_ARRIVAL_TEMPLATE, x.getLatestArrivalTime(), orderProductEmailVO);
} catch (MessagingException e) {
throw new RuntimeException(e);
} catch (TemplateException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
test(EmailTemplateEnum.LATEST_DC_TEMPLATE, x.getLatestBkTime(), orderProductEmailVO);
} catch (MessagingException e) {
throw new RuntimeException(e);
} catch (TemplateException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
if (baseInfoDOMap.get(x.getOrderId()).getId() == x.getOrderId() &&
baseInfoDOMap.get(x.getOrderId()).getId() == inspectionStageDOMap.get(x.getOrderId()).getOrderId()) {
orderProductEmailVO.setInspectionStageInfo(inspectionStageDOMap.get(x.getOrderId()));
orderProductEmailVO.setBaseInfo(baseInfoDOMap.get(x.getOrderId()));
//尾期验货日期。尾期放这里写是因为尾期验货日期需要从inspectionStageDOMap中获取。
try {
test(EmailTemplateEnum.END_CHECK_DATE_TEMPLATE, inspectionStageDOMap.get(x.getOrderId()).getEndCheckApplyTime(), orderProductEmailVO);
} catch (MessagingException e) {
throw new RuntimeException(e);
} catch (TemplateException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
/*加上中期验货报告和尾期验货报告的发送,因为他需要发送inspectionStageDOMap实体类中的数据*/
//todo
}
}
);
}
}
// 写一下检测方法。
/*@param event 代表的含义,这个是对应的枚举类型。
*@param str 代表的含义,这个是状态日期。
*@param orderProductEmailVO 代表的含义,这个邮件要发送的内容。
* */
//todo 还需要判断其他时间,不能单独只判断po时间。
public void test(EmailTemplateEnum eventEnum, String str, OrderProductEmailVO orderProductEmailVO) throws MessagingException, TemplateException, IOException {
//获取邮件收件人。
System.out.println("22222222222222222222--1111111111111");
List<List<String>> emails = getEmails(eventEnum, orderProductEmailVO);
if (StringUtils.isNotBlank(str)) {
//如果为确认样确认,或者AITEX/SGS测试判断是否存在ok。
if (eventEnum.getTitle().equals(EmailTemplateEnum.CONFIRM_SAMPLE_TEMPLATE.getTitle()) ||
eventEnum.getTitle().equals(EmailTemplateEnum.AITEX_SGS_TEST_TEMPLATE.getTitle()) ||
eventEnum.getTitle().equals(BIG_SAMPLE_TEMPLATE.getTitle())) {
System.out.println("2222222222-22222222222222");
//不包含ok并且三次输入机会都为fail了
if (!str.contains("ok") && org.apache.commons.lang3.StringUtils.countMatches(str, "fail") == 3) {
//直接发邮件。
for (List email : emails) {
emailSendUtils.sendEmail(eventEnum, email, orderProductEmailVO);
}
//设置状态为1,下次不扫描。
} else if (str.contains("ok") || org.apache.commons.lang3.StringUtils.countMatches(str, "fail") < 3) {
//只会有几种种情况,一种是fail,一种是fail+fail。一种是fail+ok,一种是ok,得到最后状态前的值就可以了,前面的不用管。
String[] parats = str.split("\\+");
//获取最后状态前的时间。
String time = parats[str.length() - 3];
LocalDate parse1 = LocalDate.parse(time, DateTimeFormatter.ofPattern("yyyy-M-d"));
//得到订单的截止时间。
String orderHodTime = orderProductEmailVO.getBaseInfo().getOrderHodTime();
LocalDate parse2 = LocalDate.parse(orderHodTime, DateTimeFormatter.ofPattern("yyyy-M-d"));
//计算两个时间之间的天数间隔。parse2-parse1
long daysBetween = ChronoUnit.DAYS.between(parse2, parse1);
if (eventEnum.getTitle().equals(EmailTemplateEnum.CONFIRM_SAMPLE_TEMPLATE.getTitle())) {
if (daysBetween == 21) {
//直接发邮件。
for (List email : emails) {
emailSendUtils.sendEmail(eventEnum, email, orderProductEmailVO);
}
}
} else if (eventEnum.getTitle().equals(EmailTemplateEnum.AITEX_SGS_TEST_TEMPLATE.getTitle())) {
if (daysBetween == 3) {
//直接发邮件。
for (List email : emails) {
emailSendUtils.sendEmail(eventEnum, email, orderProductEmailVO);
}
}
} else {
if (daysBetween == 7) {
//直接发邮件。
for (List email : emails) {
emailSendUtils.sendEmail(eventEnum, email, orderProductEmailVO);
}
}
}
}
}
//没有ok或者fail状态,只通过时间来判断。
if (eventEnum.getTitle().equals(EmailTemplateEnum.OTHER_SAMPLE_TEMPLATE.getTitle())) {
String orderHodTime = orderProductEmailVO.getBaseInfo().getOrderHodTime();
LocalDate parse1 = LocalDate.parse(str, DateTimeFormatter.ofPattern("yyyy-M-d"));
//订单的HOD截止时间。
LocalDate parse2 = LocalDate.parse(orderHodTime, DateTimeFormatter.ofPattern("yyyy-M-d"));
long daysBetween = ChronoUnit.DAYS.between(parse2, parse1);
if (daysBetween == 14) {
for (List email : emails) {
emailSendUtils.sendEmail(eventEnum, email, orderProductEmailVO);
}
}
} else if (eventEnum.getTitle().equals(EmailTemplateEnum.BARCODE_ARRIVAL_TEMPLATE.getTitle())) {
String orderHodTime = orderProductEmailVO.getBaseInfo().getOrderHodTime();
LocalDate parse1 = LocalDate.parse(str, DateTimeFormatter.ofPattern("yyyy-M-d"));
//订单的HOD截止时间。
LocalDate parse2 = LocalDate.parse(orderHodTime, DateTimeFormatter.ofPattern("yyyy-M-d"));
long daysBetween = ChronoUnit.DAYS.between(parse2, parse1);
if (daysBetween == 7) {
for (List email : emails) {
emailSendUtils.sendEmail(eventEnum, email, orderProductEmailVO);
}
}
} else if (eventEnum.getTitle().equals(EmailTemplateEnum.LATEST_DC_TEMPLATE.getTitle())) {
String orderHodTime = orderProductEmailVO.getBaseInfo().getOrderHodTime();
LocalDate parse1 = LocalDate.parse(str, DateTimeFormatter.ofPattern("yyyy-M-d"));
//订单的HOD截止时间。
LocalDate parse2 = LocalDate.parse(orderHodTime, DateTimeFormatter.ofPattern("yyyy-M-d"));
long daysBetween = ChronoUnit.DAYS.between(parse2, parse1);
if (daysBetween == 10) {
for (List email : emails) {
emailSendUtils.sendEmail(eventEnum, email, orderProductEmailVO);
}
}
} else if (eventEnum.getTitle().equals(EmailTemplateEnum.END_CHECK_DATE_TEMPLATE.getTitle())) {
String orderHodTime = orderProductEmailVO.getBaseInfo().getOrderHodTime();
LocalDate parse1 = LocalDate.parse(str, DateTimeFormatter.ofPattern("yyyy-M-d"));
//订单的HOD截止时间。
LocalDate parse2 = LocalDate.parse(orderHodTime, DateTimeFormatter.ofPattern("yyyy-M-d"));
long daysBetween = ChronoUnit.DAYS.between(parse2, parse1);
if (daysBetween == 2) {
for (List email : emails) {
emailSendUtils.sendEmail(eventEnum, email, orderProductEmailVO);
}
}
}
}
}
/*发送中期验货报告和尾期验货报告,疑问,是什么时候发送,质检信息中有中期验货字段,是否是填写了中期验货字段就发送还是说填写了跟单信息发送*/
public void send() {
}
/*发送生产指示书*/
public void sende(File file) {
}
/*返回邮箱
* 解释:根据订单的客户编码和事件类型,得到这个客户编码配置好的邮箱配置,返回邮箱*/
public List<List<String>> getEmails(EmailTemplateEnum eventEnum, OrderProductEmailVO orderProductEmailVO) {
String customerCode = orderProductEmailVO.getBaseInfo().getCustomerCode();
List<ReceiveEmailMappingDO> receiveEmailMappingDOList = receiveEmailMappingService.list(new LambdaQueryWrapper<ReceiveEmailMappingDO>()
.eq(BaseDO::getEnableFlag, Constant.ENABLE_TEN)
.eq(ReceiveEmailMappingDO::getTypeValue, customerCode));
Set<List<String>> emailList = receiveEmailMappingDOList.stream().map(x -> {
ReceiveEmailConfigItemVO receiveEmailConfigItemVO = JSON.parseObject(x.getConfigInfos(), ReceiveEmailConfigItemVO.class);
if (eventEnum.getTemplateId() == OrderEventEnum.getEvent(receiveEmailConfigItemVO.getEvent()).getTemplateId()) {
List<String> emailsList = receiveEmailConfigItemVO.getEmails();
return emailsList;
}
return null;
}).collect(Collectors.toSet());
return new ArrayList<>(emailList);
}
/* public void a(String str, OrderProductEmailVO orderProductEmailVO) {
//包含ok。
String[] parats = str.split("\\+");
//获取ok前的时间。
String time = parats[str.length() - 3];
LocalDate parse1 = LocalDate.parse(time, DateTimeFormatter.ofPattern("yyyy-M-d"));
//得到订单的截止时间。
String orderHodTime = orderProductEmailVO.getBaseInfo().getOrderHodTime();
LocalDate parse2 = LocalDate.parse(orderHodTime, DateTimeFormatter.ofPattern("yyyy-M-d"));
//计算两个时间之间的天数间隔。parse2-parse1
long daysBetween = ChronoUnit.DAYS.between(parse2, parse1);
if (daysBetween == 21) {
//直接发邮件。
for (List email : emails) {
emailSendUtils.sendEmail(eventEnum, email, orderProductEmailVO);
}
}
}*/
@Scheduled(cron = "0 0 2 * * ?")
public void checkOverTimeExecuteV2() {
List<OrderEventJobVO> jobVOList = transfer2OrderEventList(null, null, null);
Map<String, List<OrderEventJobVO>> map = handlerOrderEvent(jobVOList);
for (Map.Entry<String, List<OrderEventJobVO>> entry : map.entrySet()) {
sendEmail4OrderEvent(OrderEventEnum.getEvent(entry.getKey()), entry.getValue());
}
}
/**
* @param eventEnum
* @param eventJobVOS
*/
private void sendEmail4OrderEvent(OrderEventEnum eventEnum, List<OrderEventJobVO> eventJobVOS) {
// todo
}
/**
* @param orderBaseInfoList
* @param orderInspectionStageList
* @param orderTrackStageList
* @return
*/
private List<OrderEventJobVO> transfer2OrderEventList(List<OrderBaseInfoDO> orderBaseInfoList, List<OrderInspectionStageDO> orderInspectionStageList, List<OrderTrackStageDO> orderTrackStageList) {
// todo
return null;
}
/**
* @param orderEventJobVOList
* @return
*/
private Map<String, List<OrderEventJobVO>> handlerOrderEvent(List<OrderEventJobVO> orderEventJobVOList) {
Map<String, List<OrderEventJobVO>> map = new HashMap<>();
for (OrderEventJobVO eventJobVO : orderEventJobVOList) {
Map<String, OrderEventJobVO> eventJobVOMap = groupByOrderEvent(eventJobVO);
if (CollectionUtils.isNotEmpty(eventJobVOMap)) {
for (Map.Entry<String, OrderEventJobVO> entry : eventJobVOMap.entrySet()) {
String key = entry.getKey();
if (map.containsKey(key)) {
List<OrderEventJobVO> list = map.get(key);
list.add(entry.getValue());
map.put(key, list);
} else {
List<OrderEventJobVO> list = new ArrayList<>();
list.add(entry.getValue());
map.put(key, list);
}
}
}
}
return map;
}
/**
* @param eventJobVO
* @return
*/
private Map<String, OrderEventJobVO> groupByOrderEvent(OrderEventJobVO eventJobVO) {
Map<String, OrderEventJobVO> map = new HashMap<>();
if (filterConfirmSampleOrderEvent(eventJobVO)) {
map.put(OrderEventEnum.CONFIRM_SAMPLE_EVENT.getEvent(), eventJobVO);
}
// todo 其他订单超期事件判断
return map;
}
/**
* @param eventJobVO
* @return
*/
private Boolean filterConfirmSampleOrderEvent(OrderEventJobVO eventJobVO) {
// todo 判断是否未能在规定的期限内完成以下货号的确认样确认
return true;
}
}