skyouc
1 天以前 03f63637e706283f1a95b7d0d6d631901ae359b2
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.vincent.rsf.server.manager.schedules;
 
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.enums.*;
import com.vincent.rsf.server.manager.service.*;
import com.vincent.rsf.server.manager.service.impl.LocServiceImpl;
import com.vincent.rsf.server.system.utils.SystemAuthUtils;
import org.springframework.beans.BeanUtils;
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 java.util.*;
import java.util.stream.Collectors;
 
/**
 * @author Ryan
 * @version 1.0
 * @date 2025/7/18
 * @description: 盘点单任务档
 */
@Component
public class CheckOrderSchedules {
 
    @Autowired
    private TaskService taskService;
    @Autowired
    private TaskItemService taskItemService;
    @Autowired
    private CheckDiffService checkDiffService;
    @Autowired
    private CheckDiffItemService checkDiffItemService;
    @Autowired
    private CheckOrderService checkOrderService;
    @Autowired
    private CheckOrderItemService checkOrderItemService;
    @Autowired
    private LocServiceImpl locService;
 
    /**
     * @author Ryan
     * @date 2025/7/18
     * @description: 自动获取已生成盘点任务的盘点列表
     * @version 1.0
     */
    @Scheduled(cron = "0/15 * * * * ?")
    @Transactional(rollbackFor = Exception.class)
    public void genReCheck() {
        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
                .select(Task::getId)
                .eq(Task::getTaskType, TaskType.TASK_TYPE_CHECK_OUT.type));
        if (tasks.isEmpty()) {
            return;
        }
        List<CheckDiffItem> list = checkDiffItemService
                .list(new LambdaQueryWrapper<CheckDiffItem>()
                        .select(CheckDiffItem::getTaskItemId));
        if (list.isEmpty()) {
            return;
        }
        Set<Long> taskIds = tasks.stream().map(Task::getId).collect(Collectors.toSet());
        List<Long> itemIds = list.stream().map(CheckDiffItem::getTaskItemId).collect(Collectors.toList());
        List<TaskItem> taskItems = taskItemService
                .list(new LambdaQueryWrapper<TaskItem>()
                        .in(TaskItem::getTaskId, taskIds)
                        .notIn(TaskItem::getId, itemIds));
        if (taskItems.isEmpty()) {
            return;
        }
        Long loginUserId = SystemAuthUtils.getLoginUserId();
        Map<Long, List<TaskItem>> taskMps = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getOrderId));
        taskMps.keySet().forEach(orderId -> {
            WkOrder order = checkOrderService.getById(orderId);
            if (Objects.isNull(order)) {
                throw new CoolException("盘点单据不存在!!");
            }
            CheckDiff checkDiff = checkDiffService.getOne(new LambdaQueryWrapper<CheckDiff>().eq(CheckDiff::getOrderId, orderId));
            if (Objects.isNull(checkDiff)) {
                checkDiff = new CheckDiff();
                checkDiff.setAnfme(order.getAnfme())
                        .setCheckType(order.getCheckType())
                        .setOrderCode(order.getCode())
                        .setExceStatus(CheckDiffExceStatus.CHECK_DIFF_EXCE_STATUS_INIT.val)
                        .setCreateBy(loginUserId)
                        .setCreateTime(new Date())
                        .setUpdateBy(loginUserId)
                        .setUpdateTime(new Date())
                        .setOrderId(order.getId());
                if (!checkDiffService.save(checkDiff)) {
                    throw new CoolException("盘点差异单保存失败!!");
                }
            }
 
            List<TaskItem> items = taskMps.get(orderId);
            List<CheckDiffItem> diffItems = new ArrayList<>();
            CheckDiff finalCheckDiff = checkDiff;
            items.forEach(item -> {
                Task task = taskService.getById(item.getTaskId());
                if (Objects.isNull(task)) {
                    throw new CoolException("数据错误:任务不存在!!");
                }
                CheckDiffItem checkDiffItem = new CheckDiffItem();
                BeanUtils.copyProperties(item, checkDiffItem);
                checkDiffItem.setCheckId(finalCheckDiff.getId())
                        .setTaskItemId(item.getId())
                        .setTaskId(item.getTaskId())
                        .setCreateBy(loginUserId)
                        .setCreateTime(new Date())
                        .setBarcode(task.getBarcode())
                        .setUpdateBy(loginUserId)
                        .setUpdateTime(new Date())
                        .setOrderCode(finalCheckDiff.getOrderCode());
                diffItems.add(checkDiffItem);
 
                if (Objects.isNull(finalCheckDiff.getAreaId())) {
                    Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>()
                            .eq(Loc::getCode, task.getOrgLoc())
                            .eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_R.type));
                    if (Objects.isNull(loc)) {
                        throw new CoolException("盘点库位不存在!!");
                    }
                    finalCheckDiff.setAreaId(loc.getAreaId()).setAreaName(loc.getAreaId$());
 
                    if (!checkDiffService.updateById(finalCheckDiff)) {
                        throw new CoolException("库区信息修改失败!!");
                    }
                }
            });
 
            if (!checkDiffItemService.saveBatch(diffItems)) {
                throw new CoolException("盘点差异单保存失败!!");
            }
        });
    }
}