工控网分析程序状态问题修复

yangys

2025-09-18 a3048fa6fa72fa3cc5da2c43c59bd000e00c9599

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

@@ -1,23 +1,31 @@
package org.springblade.mdm.flow.excution.dispatch;

import com.alibaba.excel.util.StringUtils;
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.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
import org.springblade.core.oss.OssTemplate;
import org.springblade.core.oss.model.BladeFile;
import org.springblade.mdm.basesetting.machine.entity.Machine;
import org.springblade.mdm.basesetting.machine.service.MachineService;
import org.springblade.mdm.flow.constants.FlowConstant;
import org.springblade.mdm.flow.entity.FlowProgramFile;
import org.springblade.mdm.flow.service.ApproveRecordService;
import org.springblade.mdm.flow.excution.ListenerHelper;
import org.springblade.mdm.flow.service.FlowProgramFileService;
import org.springblade.mdm.flow.service.FlowProgramProperties;
import org.springblade.mdm.gkw.programnode.vo.ProgramNameVO;
import org.springblade.mdm.program.entity.NcNode;
import org.springblade.mdm.program.entity.NcProgramApproved;
import org.springblade.mdm.program.service.NcNodeAutoCreateService;
import org.springblade.mdm.program.service.NcNodeService;
import org.springblade.mdm.program.service.NcProgramApprovedService;
import org.springblade.mdm.utils.EntityUtil;
import org.springblade.mdm.program.service.programannotation.*;
import org.springblade.mdm.utils.ProgramFileNameParser;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
@@ -27,118 +35,139 @@
@Component("normalDispatchFinishDataHandler")
public class NormalFinishDataHandler implements FinishDataHandler{
   @Autowired
   private NcProgramApprovedService approvedService;
   @Autowired
   private ApproveRecordService approveRecordService;
   @Autowired
   private FlowProgramFileService flowProgramFileService;
   @Autowired
   private MachineAnnotationConfig annotationConfig;
   @Autowired
   private MachineService machineService;
   @Autowired
   private NcNodeService ncNodeService;
   @Autowired
   private NcNodeAutoCreateService ncNodeAutoCreateService;
   @Autowired
   private ListenerHelper listenerHelper;
   @Autowired
   private OssTemplate ossTemplate;

   /**
    * DispatchFinishListener中调用
    * @param props 执行对象
    * @param props 流程属性
    */
   public void handleData(FlowProgramProperties props) {
   public void handleData(FlowProgramProperties props) throws IOException {
      // 执行业务逻辑
      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());
      if(FlowConstant.Y.equals(props.getHasCuredProgram())){
         //有固化
         packageNode = ncNodeService.getById(props.getCuredNodeId());

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

            //版本号根据零组件号+工序号，工序版次，机床组 直接查询数量，+1获取
            Integer newVersion = ncNodeService.calculateVersionNumber(packageNode);
            packageNode = ncNodeAutoCreateService.createNodeTreeWithProgram(props,newVersion);
         }else{
            //不可用，去固化找最新节点
            packageNode = ncNodeService.getLastEditionCuredProgramPackage(programPkgName,props.getProcessEdition());
            //可用，空升版（修改其工序版次），原来的节点清除
            moveToNewProcessEdition(packageNode,props);

            //更新已固化的，同名、不同机床组的程序为锁定状态
            ncNodeService.lockSameNameOtherMachineGroupProgramPackage(packageNode);
         }
      }else if(Func.isNotBlank(props.getDeviation())){
         //有偏离单
         packageNode = ncNodeService.getLastEditionDeviationProgramPackage(programPkgName,props.getProcessEdition());
      }else{
         //普通试切，或者有固化不可用
         packageNode = ncNodeService.getLastEditionTryingProgramPackage(programPkgName,props.getProcessEdition());
         //普通试切
         packageNode = ncNodeAutoCreateService.createNodeTreeWithProgram(props,1);
         long hisSerial = ncNodeService.calculateHistorySerial(packageNode);
         packageNode.setHisSerial(hisSerial);
         ncNodeService.updateById(packageNode);
      }

      addApproveTable(packageNode,props);
      updateApproveRecordNodeId(instId, packageNode.getId());
      listenerHelper.addApproveTable(packageNode,props);

      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) throws IOException {
      //ncNodeService.deleteMachineGroupNodeByParentId();
      ncNodeService.getBaseMapper().deleteById(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(FlowConstant.CURE_PROCESS_KEY);//临时修改其为固化,在固化下创建节点
      NcNode machineGroupNode = ncNodeAutoCreateService.createNodeTreeToMachineGroup(tempProps);

            //新的流程对应的文件更新到新节点下
            List<FlowProgramFile> newFlowFileList = flowProgramFileService.listByProcessInstanceId(progProperties.getProcessInstanceId());
            for (FlowProgramFile newFlowFile : newFlowFileList) {
               NcNode newProgramNode = new NcNode();
               BeanUtils.copyProperties(newCuredPkgNode, newProgramNode);
               EntityUtil.clearBaseProperties(newProgramNode);
      //移动程序包名节点
      packageNode.setProcessEdition(tempProps.getProcessEdition());
      packageNode.setParentId(machineGroupNode.getId());
      packageNode.setParentIds(machineGroupNode.subNodeParentIds());
      packageNode.setName(tempProps.getDrawingNo()+"-"+tempProps.getProcessNo()+"-"+tempProps.getProcessEdition());

               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);
            }
      this.ncNodeService.updateById(packageNode);
      Machine machine = machineService.getByCode(packageNode.getMachineCode());
      //移动程序节点
      //List<DictBiz> annoDicts = programAnnotationService.getAnnotionDictList();
      List<NcNode> programNodes = ncNodeService.getProgramFilesByPackageId(packageNode.getId());
      for(NcNode programNode : programNodes){
         FlowProgramFile progFile = this.flowProgramFileService.getById(programNode.getFlowProgramFileId());

            //原节点更新为老版本，锁定
            curedProgramPackage.setIsLastEdition(0);
            curedProgramPackage.setIsLocked(1);
            ncNodeService.updateById(curedProgramPackage);
         programNode.setParentIds(packageNode.subNodeParentIds());
         programNode.setProcessEdition(tempProps.getProcessEdition());//修改工序版次
         programNode.setVersionNumber(packageNode.getVersionNumber());
         if(progFile.isProgram()) {
            programNode.setName(buildNewFilename(programNode.getName(), tempProps.getProcessEdition()));//名称修改，工序版次部分
            setNewProgramNameAnnotation(programNode.getName(), progFile, machine.getControlSystem());
         }
      }
      ncNodeService.updateBatchById(programNodes);

   }

   /**
    * 构建新的程序市名
    * @param filename 程序包名
    * @param newProcessEdition 新的工序版次
    * @return 新的程序文件名
    */
   String buildNewFilename(String filename,String newProcessEdition){
      ProgramNameVO pnameVO = ProgramFileNameParser.parseProgramName(filename);
      String ext = FilenameUtils.getExtension(filename);
      String name= pnameVO.getDrawingNo()+"-"+pnameVO.getProcessNo()+"-"+newProcessEdition+"-"+pnameVO.getSegmentCount()+"-"+pnameVO.getSegmentNo();
      if(StringUtils.isNotBlank(ext)){
         name += "."+ext;
      }
      return name;
   }

   /**
    * 设置固化注释,实现方式，获取文件字节下，修改后替换文件
    * @param flowProgramFile oss 文件
    *
    */
   void setNewProgramNameAnnotation(String filename,FlowProgramFile flowProgramFile, String controlSystem) throws IOException {

      try(InputStream ins = ossTemplate.statFileStream(flowProgramFile.getOssName());){
         ByteArrayInputStream byteInputStream =  new ByteArrayInputStream(IOUtils.toByteArray(ins));


         AnnotationProcessor annoProcessor = ProcessorHelper.getProcessor(controlSystem,this.annotationConfig);

         InputStream finishedStream = annoProcessor.putFilenameAnnotation(filename,byteInputStream);
         //InputStream finishedStream = AnnotationUtil.setAnnotationAndGetInputStream(byteInputStream, "GH", annoProps.getStatusLineIndex(), controlSystem, annoDictList);
         try(finishedStream) {
            finishedStream.reset();
            BladeFile bfile = ossTemplate.putFile(flowProgramFile.getName(), finishedStream);
            //替换原有的文件地址
            flowProgramFile.setOssName(bfile.getName());
            flowProgramFile.setName(filename);
            flowProgramFileService.updateById(flowProgramFile);
         }
      }
   }

   /**
    * 保存审批完成的记录
    * @param packageNode
    * @param props
    */
   void addApproveTable(NcNode packageNode,FlowProgramProperties props){
      NcProgramApproved approved = new NcProgramApproved();

      approved.setProgramName(packageNode.getName());
      approved.setNcNodeId(packageNode.getId());//程序包节点id
      approved.setTitle(props.getTitle());
      approved.setProgrammerId(props.getProgrammerId());
      approvedService.save(approved);

   }


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