yangys
2025-09-29 4c7296d45efe849dc70a3b2e2240c905481a91c9
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
package org.springblade.mdm.flow.service;
 
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.flowable.engine.IdentityService;
import org.flowable.engine.RuntimeService;
import org.flowable.engine.runtime.ProcessInstance;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.mdm.flow.constants.FlowConstant;
import org.springblade.mdm.flow.constants.FlowVariableConstant;
import org.springblade.mdm.flow.entity.FlowProgramFile;
import org.springblade.mdm.program.entity.NcNode;
import org.springblade.mdm.program.service.NcNodeService;
import org.springblade.mdm.utils.EntityUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
/**
 * 固化流程服务
 */
@Slf4j
@Service
@AllArgsConstructor
public class CureFlowService {
 
    private final RuntimeService runtimeService;
 
    private final IdentityService identityService;
    private final NcNodeService ncNodeService;
 
    private final FlowProgramFileService flowProgramFileService;
    private final FlowCommonService flowCommonService;
 
    /**
     * 启动固化流程
     */
    @Transactional
    public void startCureNew(Map<Long, List<FlowProgramFile>> pkgIdFileMap) {
        pkgIdFileMap.forEach(this::startOneNew);
    }
 
    /**
     * 启动一调程序的固化流程
     * @param nodeId
     * @param fileList
     */
    private void startOneNew(Long nodeId, List<FlowProgramFile> fileList) {
        Map<String, Object> vars = new HashMap<>();
        NcNode programPackage = this.ncNodeService.getById(nodeId);
        vars.put(FlowConstant.NODE_ID,programPackage.getId());
 
        flowCommonService.putFlowVariablesByNode(vars,programPackage);
 
        flowCommonService.putDefaultAssignees(vars,programPackage.getDrawingNo(),null);
        vars.put(FlowVariableConstant.ASSIGNEE,vars.get(FlowVariableConstant.PROGRAMMER));
        identityService.setAuthenticatedUserId(String.valueOf(AuthUtil.getUserId()));//设置流程发起人
        vars.put(FlowVariableConstant.LAST_STEP_USER_NICKNAME, AuthUtil.getNickName());
 
        if(programPackage.getDeviation() != null) {
            vars.put(FlowVariableConstant.MY_PROCESS_NAME, "临时更改单回传");
            vars.put(FlowVariableConstant.TITLE,programPackage.getName()+"-临时更改单回传");//自动增加标题
        }else {
            vars.put(FlowVariableConstant.MY_PROCESS_NAME, "固化流程");
            vars.put(FlowVariableConstant.TITLE,programPackage.getName()+"-"+programPackage.getProcessEdition()+"-固化");//自动增加标题
        }
        ProcessInstance inst = runtimeService.startProcessInstanceByKey(FlowConstant.CURE_PROCESS_KEY,"0",vars);
 
        //更新程序包名节点的流程实例id
        programPackage.setProcessInstanceId(inst.getProcessInstanceId());
        ncNodeService.updateById(programPackage);
 
        for(FlowProgramFile flowProgramFile : fileList){
            flowProgramFile.setProcessInstanceId(inst.getProcessInstanceId());
        }
        this.flowProgramFileService.saveBatch(fileList);
 
        addPreviousOtherFiles(programPackage.getId(),inst.getProcessInstanceId());
 
        log.info("启动固化流程完成,实例id={}", inst.getId());
    }
 
    /**
     * 复制试切阶段的其他文件给固化流程
     * @param previousNodeId 试切阶段的节点id
     * @param newProcessInstanceId 新的固化流程实例id
     */
    void addPreviousOtherFiles(Long previousNodeId,String newProcessInstanceId) {
        List<NcNode> previousFileNodes = ncNodeService.getProgramFilesByPackageId(previousNodeId);
        for(NcNode fileNode : previousFileNodes){
 
            FlowProgramFile progFile = flowProgramFileService.getById(fileNode.getFlowProgramFileId());
            if(!progFile.isProgram()){
                FlowProgramFile newProgFile = new FlowProgramFile();
                BeanUtils.copyProperties(progFile,newProgFile);
                EntityUtil.clearBaseProperties(newProgFile);
                newProgFile.setProcessInstanceId(newProcessInstanceId);
 
                flowProgramFileService.save(newProgFile);
            }
        }
    }
}