yangys
2025-09-20 fcee672452c02cc29e0e17ebc27a8c51698c6d0d
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
 
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.apache.commons.lang3.StringUtils;
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.entity.NcNode;
import org.springblade.mdm.program.entity.NcNodeHis;
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);
    }
 
    /**
     * 根据工序唯一码获取派工数据
     * @param operationId 工序唯一码
     * @return
     */
    public TaskDispatch getByOperationId(String operationId) {
        Optional<TaskDispatch> opt = lambdaQuery().eq(TaskDispatch::getOperationId, operationId).oneOpt();
        return opt.orElse(null);
    }
 
    /**
     * 根据程序内部编号获取实体
     * @param programNo 内部编号
     * @return 实体
     */
    public TaskDispatch getByProgramNo(String programNo) {
        return lambdaQuery().eq(TaskDispatch::getProgramNo, programNo).one();
    }
 
 
    /**
     * 查询偏离单的序号
     * @param programNo 偏离单的程序包名节点
     * @return 序号
     */
    public long getDeviationSerial(String programNo) {
        TaskDispatch dispatch = this.getByProgramNo(programNo);
 
        return lambdaQuery()
            .eq(TaskDispatch::getDrawingNo,dispatch.getDrawingNo())
            .eq(TaskDispatch::getProcessNo,dispatch.getProcessNo())
            .eq(TaskDispatch::getProcessEdition,dispatch.getProcessEdition())
            .eq(TaskDispatch::getDeviation,dispatch.getDeviation())
            .le(TaskDispatch::getCreateTime,dispatch.getCreateTime())  //时间小于等于当前节点
            .count();
    }
}