增加车床程序处理；退回改为实际编程员

yangys

2025-09-03 a3a9933cf1b49006edf470615236f94ebdaa4cb9

 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;
@@ -43,104 +39,79 @@
   public void handleData(FlowProgramProperties props) {
      // 执行业务逻辑
      String instId = props.getProcessInstanceId();

      String programPkgName = NcNodeService.genProgramName(props.getDrawingNo(),props.getProcessNo());
      //NcNode packageNode =createProgramNodes(props);
      NcNode packageNode;// = ncNodeAutoCreateService.createNodeTreeWithProgram(props);
      if(FlowContants.Y.equals(props.getHasCuredProgram()) && FlowContants.Y.equals(props.getCureProgramUseable())){
         //有固化，且程序可用
      NcNode packageNode;
      if(FlowContants.Y.equals(props.getHasCuredProgram())){
         //有固化
         packageNode = ncNodeService.getById(props.getCuredNodeId());

      }else{
         packageNode = ncNodeAutoCreateService.createNodeTreeWithProgram(props);
      }

      if(FlowContants.Y.equals(props.getHasCuredProgram()) && FlowContants.N.equals(props.getCureProgramUseable())){
         //有固化 但不可用，试切节点的新节点 版本号为 固化版本号+1
         NcNode curedPackageNode = ncNodeService.getById(props.getCuredNodeId());
         packageNode.setVersionNumber(curedPackageNode.genNewVersionNumber());
         ncNodeService.updateById(packageNode);
      }
      //NcNode packageNode;
      /*
      if(FlowContants.Y.equals(props.getHasCuredProgram())){
         //有固化，且程序可用，从固化树查询节点.使用流程中保存的节点
         if(FlowContants.Y.equals(props.getCureProgramUseable())) {
            packageNode = ncNodeService.getById(props.getCuredNodeId());
         }else{
            //不可用，去试切找最新节点
            //packageNode = ncNodeService.getLastEditionCuredProgramPackage(programPkgName,props.getProcessEdition());
            packageNode = ncNodeService.getLastEditionTryingProgramPackage(programPkgName,props.getProcessEdition());
            //不可用的固化程序锁定
         if(FlowContants.N.equals(props.getCureProgramUseable())) {
            //程序不可用
            //原来的固化节点锁定
            packageNode.lock();
            ncNodeService.updateById(packageNode);

            Integer newVersion = packageNode.genNewVersionNumber();
            packageNode = ncNodeAutoCreateService.createNodeTreeWithProgram(props,newVersion);
         }else{
            //可用，升版（修改其工序版本），原来的节点清除
            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 流程属性
    */
   NcNode createProgramNodes(FlowProgramProperties progProperties){
      NcNode programPkgNode = null;
      if(FlowContants.N.equals(progProperties.getHasCuredProgram())) {
         //无固化:(试切或者偏离)
         programPkgNode = ncNodeAutoCreateService.createNodeTreeWithProgram(progProperties);
      }else{
         if(FlowContants.N.equals(progProperties.getCureProgramUseable())) {
            programPkgNode = ncNodeAutoCreateService.createNodeTreeWithProgram(progProperties);//暂时与上面使用相同代码，createNodeTreeWithProgram中区分了普通试切和不可用的情况
   private void moveToNewProcessEdition(NcNode packageNode, FlowProgramProperties props) {
      ncNodeService.deleteMachineNodeByParentId(packageNode.getParentId());

      FlowProgramProperties tempProps = new FlowProgramProperties();
      BeanUtils.copyProperties(props,tempProps);
      tempProps.setProcessDefinitionKey(FlowContants.CURE_PROCESS_KEY);//临时修改其为固化,在固化下创建节点
      NcNode machineNode = ncNodeAutoCreateService.createNodeTreeToMachine(tempProps);

      //移动历史节点到新的版次节点下
      List<NcNode> packageHisNodes = ncNodeService.getNodeHistory(packageNode);//该包的历史节点列表
      for(NcNode hisPackageNode : packageHisNodes){
         hisPackageNode.setParentId(machineNode.getParentId());
         hisPackageNode.setParentIds(machineNode.getParentIds());

         List<NcNode> oriProgramNodes = ncNodeService.lambdaQuery().eq(NcNode::getParentId,hisPackageNode.getId()).list();

         for(NcNode oldProgramNode : oriProgramNodes){
            oldProgramNode.setParentIds(hisPackageNode.getParentIds()+","+hisPackageNode.getId());
         }
         //有固化，程序不可用,应该去试切建立节点
         /*
         if(FlowContants.N.equals(progProperties.getCureProgramUseable())) {
            //固化程序不可用，需要重新建立程序包名和文件节点;可用情况在流程审批中已经升级过节点了
            NcNode curedProgramPackage = ncNodeService.getById(progProperties.getCuredNodeId());

            NcNode newCuredPkgNode = new NcNode();
            BeanUtils.copyProperties(curedProgramPackage, newCuredPkgNode);
            EntityUtil.clearBaseProperties(newCuredPkgNode);
            newCuredPkgNode.setIsLastEdition(1);
            newCuredPkgNode.setIsLocked(0);
            newCuredPkgNode.upgradeVersionNumber();
            ncNodeService.save(newCuredPkgNode);

            //新的流程对应的文件更新到新节点下
            List<FlowProgramFile> newFlowFileList = flowProgramFileService.listByProcessInstanceId(progProperties.getProcessInstanceId());
            for (FlowProgramFile newFlowFile : newFlowFileList) {
               NcNode newProgramNode = new NcNode();
               BeanUtils.copyProperties(newCuredPkgNode, newProgramNode);
               EntityUtil.clearBaseProperties(newProgramNode);

               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);
            }

            //原节点更新为老版本，锁定
            curedProgramPackage.setIsLastEdition(0);
            curedProgramPackage.setIsLocked(1);
            ncNodeService.updateById(curedProgramPackage);
         }*/
         ncNodeService.updateBatchById(oriProgramNodes);
      }
      ncNodeService.updateBatchById(packageHisNodes);

      return programPkgNode;
      //移动程序包名节点
      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);


   }


   /**
    * 保存审批完成的记录
@@ -154,15 +125,9 @@
      approved.setNcNodeId(packageNode.getId());//程序包节点id
      approved.setTitle(props.getTitle());
      approved.setProgrammerId(props.getProgrammerId());
      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();
   }
}