工控网导出使用实际编程人匹配

yangys

2025-09-04 86079d1c2bd7981165487e6e08d2399b80687f6e

 blade-service/blade-mdm/src/main/java/org/springblade/mdm/flow/excution/dispatch/NormalFinishDataHandler.java

@@ -1,9 +1,7 @@
package org.springblade.mdm.flow.excution.dispatch;

import lombok.extern.slf4j.Slf4j;
import org.springblade.core.tool.utils.Func;
import org.springblade.mdm.flow.constants.FlowContants;
import org.springblade.mdm.flow.entity.ApproveRecord;
import org.springblade.mdm.flow.entity.FlowProgramFile;
import org.springblade.mdm.flow.service.ApproveRecordService;
import org.springblade.mdm.flow.service.FlowProgramFileService;
@@ -29,8 +27,6 @@
   @Autowired
   private NcProgramApprovedService approvedService;
   @Autowired
   private ApproveRecordService approveRecordService;
   @Autowired
   private FlowProgramFileService flowProgramFileService;
   @Autowired
   private NcNodeService ncNodeService;
@@ -42,81 +38,79 @@
    */
   public void handleData(FlowProgramProperties props) {
      // 执行业务逻辑
      String instId = props.getProcessInstanceId();

      String programPkgName = NcNodeService.genProgramName(props.getDrawingNo(),props.getProcessNo());
      createProgramNodes(props);

      //TODO 偏离单，和已经固化的程序，没有处理,:已经处理没有验证
      NcNode packageNode;
      if(FlowContants.Y.equals(props.getHasCuredProgram())){
         //有固化，且程序可用，从固化树查询节点.使用流程中保存的节点
         //packageNode = ncNodeService.getLastEditionCuredProgramPackage(programPkgName,props.getProcessEdition());
         if(FlowContants.Y.equals(props.getCureProgramUseable())) {
            packageNode = ncNodeService.getById(props.getCuredNodeId());
         //有固化
         packageNode = ncNodeService.getById(props.getCuredNodeId());

         if(FlowContants.N.equals(props.getCureProgramUseable())) {
            //程序不可用
            //原来的固化节点锁定
            packageNode.lock();
            ncNodeService.updateById(packageNode);

            Integer newVersion = packageNode.genNewVersionNumber();
            packageNode = ncNodeAutoCreateService.createNodeTreeWithProgram(props,newVersion);
         }else{
            //不可用，去固化找最新节点
            packageNode = ncNodeService.getLastEditionCuredProgramPackage(programPkgName,props.getProcessEdition());
            //可用，升版（修改其工序版本），原来的节点清除
            moveToNewProcessEdition(packageNode,props);
         }
      }else if(Func.isNotBlank(props.getDeviation())){
         //有偏离单
         packageNode = ncNodeService.getLastEditionDeviationProgramPackage(programPkgName,props.getProcessEdition());
      }else{
         //普通试切，或者有固化不可用
         packageNode = ncNodeService.getLastEditionTryingProgramPackage(programPkgName,props.getProcessEdition());
         //普通试切
         packageNode = ncNodeAutoCreateService.createNodeTreeWithProgram(props,1);
      }

      addApproveTable(packageNode,props);
      updateApproveRecordNodeId(instId, packageNode.getId());
      //updateApproveRecordNodeId(instId, packageNode.getId());
      log.info("普通流程已完成in DispatchFinishListener");
   }

   /**
    * 自动创建程序节点
    * @param progProperties 流程属性
    * 节点移动到新的工序版本下
    * @param packageNode 程序包名节点
    * @param props 流程属性
    */
   void createProgramNodes(FlowProgramProperties progProperties){
      if(FlowContants.N.equals(progProperties.getHasCuredProgram())) {
         //无固化:(试切或者偏离)
         ncNodeAutoCreateService.createNodeTreeWithProgram(progProperties);
      }else{
         //有固化，程序不可用
         if(FlowContants.N.equals(progProperties.getCureProgramUseable())) {
            //固化程序不可用，需要重新建立程序包名和文件节点;可用情况在流程审批中已经升级过节点了
            NcNode curedProgramPackage = ncNodeService.getById(progProperties.getCuredNodeId());
   private void moveToNewProcessEdition(NcNode packageNode, FlowProgramProperties props) {
      ncNodeService.deleteMachineNodeByParentId(packageNode.getParentId());

            NcNode newCuredPkgNode = new NcNode();
            BeanUtils.copyProperties(curedProgramPackage, newCuredPkgNode);
            EntityUtil.clearBaseProperties(newCuredPkgNode);
            newCuredPkgNode.setIsLastEdition(1);
            newCuredPkgNode.setIsLocked(0);
            newCuredPkgNode.upgradeVersionNumber();
            ncNodeService.save(newCuredPkgNode);
      FlowProgramProperties tempProps = new FlowProgramProperties();
      BeanUtils.copyProperties(props,tempProps);
      tempProps.setProcessDefinitionKey(FlowContants.CURE_PROCESS_KEY);//临时修改其为固化,在固化下创建节点
      NcNode machineNode = ncNodeAutoCreateService.createNodeTreeToMachine(tempProps);

            //新的流程对应的文件更新到新节点下
            List<FlowProgramFile> newFlowFileList = flowProgramFileService.listByProcessInstanceId(progProperties.getProcessInstanceId());
            for (FlowProgramFile newFlowFile : newFlowFileList) {
               NcNode newProgramNode = new NcNode();
               BeanUtils.copyProperties(newCuredPkgNode, newProgramNode);
               EntityUtil.clearBaseProperties(newProgramNode);
      //移动历史节点到新的版次节点下
      List<NcNode> packageHisNodes = ncNodeService.getNodeHistory(packageNode);//该包的历史节点列表
      for(NcNode hisPackageNode : packageHisNodes){
         hisPackageNode.setParentId(machineNode.getParentId());
         hisPackageNode.setParentIds(machineNode.getParentIds());

               newProgramNode.setName(newFlowFile.getName());
               newProgramNode.setNodeType(NcNode.TYPE_PROGRAM_FILE);
               newProgramNode.setParentId(newCuredPkgNode.getId());
               newProgramNode.setIsLastEdition(1);
               newProgramNode.setIsLocked(0);
               newProgramNode.setParentIds(newCuredPkgNode.getParentIds() + "," + newCuredPkgNode.getId());
               newProgramNode.setFlowProgramFileId(newFlowFile.getId());
               ncNodeService.save(newProgramNode);
            }
         List<NcNode> oriProgramNodes = ncNodeService.lambdaQuery().eq(NcNode::getParentId,hisPackageNode.getId()).list();

            //原节点更新为老版本，锁定
            curedProgramPackage.setIsLastEdition(0);
            curedProgramPackage.setIsLocked(1);
            ncNodeService.updateById(curedProgramPackage);
         for(NcNode oldProgramNode : oriProgramNodes){
            oldProgramNode.setParentIds(hisPackageNode.getParentIds()+","+hisPackageNode.getId());
         }
         ncNodeService.updateBatchById(oriProgramNodes);
      }
      ncNodeService.updateBatchById(packageHisNodes);

      //移动程序包名节点
      packageNode.setProcessEdition(tempProps.getProcessEdition());
      packageNode.setParentId(machineNode.getParentId());
      packageNode.setParentIds(machineNode.getParentIds());
      this.ncNodeService.updateById(packageNode);

      //移动程序节点
      List<NcNode> programNodes = ncNodeService.getProgramFilesByPackageId(packageNode.getId());
      for(NcNode programNode : programNodes){
         programNode.setParentIds(packageNode.getParentIds()+","+packageNode.getId());
         programNode.setProcessEdition(tempProps.getProcessEdition());//修改工序版次
         programNode.setVersionNumber(packageNode.getVersionNumber());
      }
      ncNodeService.updateBatchById(programNodes);


   }


   /**
    * 保存审批完成的记录
@@ -129,16 +123,10 @@
      approved.setProgramName(packageNode.getName());
      approved.setNcNodeId(packageNode.getId());//程序包节点id
      approved.setTitle(props.getTitle());
      approved.setProgrammerId(props.getProgrammerId());
      approved.setProgrammerId(props.getActProgrammerId());
      approved.setProcessInstanceId(props.getProcessInstanceId());
      approvedService.save(approved);

   }


   void updateApproveRecordNodeId(String processInstanceId,Long nodeId){
      //更新审批记录的ncNodeId
      approveRecordService.lambdaUpdate()
         .eq(ApproveRecord::getProcessInstanceId, processInstanceId)
         .set(ApproveRecord::getNcNodeId,nodeId).update();
   }
}