yangys
2025-09-09 3d558e1bb5091b76a6525f6fab015574e1755200
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
 
package org.springblade.mdm.flow.service;
 
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.mp.base.BizServiceImpl;
import org.springblade.mdm.commons.service.ParamService;
import org.springblade.mdm.flow.entity.TaskDispatch;
import org.springblade.mdm.flow.mapper.TaskDispatchMapper;
import org.springblade.mdm.flow.vo.TaskAssignVO;
import org.springblade.mdm.program.entity.DrawingNos;
import org.springblade.mdm.program.mapper.DrawingNosMapper;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
 
/**
 * 任务派工数据 处理服务
 *
 * @author yangys
 */
@Slf4j
@Service
public class TaskDispatchService  extends BizServiceImpl<TaskDispatchMapper, TaskDispatch> {
    @Autowired
    private ParamService paramService;
    @Autowired
    private DrawingNosMapper drawingNosMapper;
 
 
    @Transactional(rollbackFor = Exception.class)
    public TaskDispatch saveTask(TaskAssignVO startVO,boolean isDup) {
        TaskDispatch taskDispatch = new TaskDispatch();
        BeanUtils.copyProperties(startVO, taskDispatch);
        if(isDup){
            taskDispatch.setStatus(TaskDispatch.STATUS_DUP);
        }
        this.save(taskDispatch);
 
        addDrawingNos(taskDispatch.getDrawingNo());
        return taskDispatch;
    }
 
    /**
     * 加u人下拉数据
     * @param drawingNo
     */
    public void addDrawingNos(String drawingNo){
        DrawingNos data = drawingNosMapper.selectById(drawingNo);
        if(data == null){
            data = new DrawingNos();
            data.setDrawingNo(drawingNo);
            try {
                drawingNosMapper.insert(data);
            }catch (Exception e){
                log.error("加入零组件号下拉数据错误");
            }
        }
    }
    /*
    public void updateSuccess(long id, String instId) {
        TaskDispatch taskDispatch = getById(id);
        taskDispatch.setProcessInstanceId(instId);
        taskDispatch.setStatus(TaskDispatch.STATUS_STARTED);
        this.updateById(taskDispatch);
    }
 
     */
 
 
    /**
     * 检查是否重复派工
     * @param startVO
     * @return
     */
    public boolean checkIsDuplicate(TaskAssignVO startVO) {
        if(startVO.isTemporaryFlow()){
            //试切补充,不验证重复
            return false;
        }
 
        int taskDupDays = paramService.taskDuplicateCheckDays();
        LocalDateTime checkStartDate = LocalDateTime.now().minusDays(taskDupDays);
        LambdaQueryChainWrapper<TaskDispatch> q = lambdaQuery().eq(TaskDispatch::getDrawingNo,startVO.getDrawingNo())
            .eq(TaskDispatch::getProcessNo,startVO.getProcessNo())
            //.eq(TaskDispatch::getProcessEdition,startVO.getProcessEdition())
            .eq(TaskDispatch::getMachineCode,startVO.getMachineCode())
            .gt(TaskDispatch::getCreateTime,checkStartDate);
 
        long cnt = q.count();
 
        return cnt > 0;
    }
    @Transactional(readOnly = true)
    public List<String> drawingNoSeletDropList(String drawingNo){
        return drawingNosMapper.selectDropDownList(drawingNo);
    }
 
    @Transactional
    public void resetDrawingNos() {
        drawingNosMapper.delete(Wrappers.emptyWrapper());//
        List<String> dnoList =  baseMapper.distinctAllDrawingNo();
        for(String dno : dnoList){
            DrawingNos drawingNos = new DrawingNos();
            drawingNos.setDrawingNo(dno);
            drawingNosMapper.insert(drawingNos);
        }
 
    }
 
    /**
     * 清理过期的异常任务计划
     */
    @Transactional
    public void cleanExpiredExceptionTask() {
        int expireDays = paramService.getTaskExpireDays();
        LocalDateTime expiredTime = LocalDateTime.now().minusDays(expireDays);
        baseMapper.deleteExpiredExceptionTasks(expiredTime);
    }
 
    /**
     * 根据mes唯一标识获取派工数据
     * @param mesTaskId
     * @return
     */
    public TaskDispatch getByMesTaskId(String mesTaskId) {
        Optional<TaskDispatch> opt = lambdaQuery().eq(TaskDispatch::getMesTaskId, mesTaskId).oneOpt();
        return opt.orElse(null);
    }
 
    public TaskDispatch getByProgramNo(String programNo) {
        return lambdaQuery().eq(TaskDispatch::getProgramNo, programNo).one();
    }
}