修复审批表，确认表内容

yangys

2025-09-23 3baca21e0e6563f8379359ef2ba78c224eb4bc80

 blade-service/blade-mdm/src/main/java/org/springblade/mdm/flow/excution/cure/NormalCureFinishDataHandler.java

@@ -7,23 +7,21 @@
import org.springblade.core.oss.model.BladeFile;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.DateUtil;
import org.springblade.core.tool.utils.Func;
import org.springblade.mdm.basesetting.machine.MachineService;
import org.springblade.mdm.basesetting.machine.service.MachineService;
import org.springblade.mdm.basesetting.machine.entity.Machine;
import org.springblade.mdm.commons.contants.ParamConstants;
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.excution.dispatch.FinishDataHandler;
import org.springblade.mdm.flow.service.ApproveRecordService;
import org.springblade.mdm.flow.service.FlowProgramFileService;
import org.springblade.mdm.flow.service.FlowProgramProperties;
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.NcNodeHisService;
import org.springblade.mdm.program.service.NcNodeService;
import org.springblade.mdm.program.service.NcProgramApprovedService;
import org.springblade.mdm.program.service.ProgramAnnotationService;
import org.springblade.mdm.program.service.programannotation.AnnotationProperties;
import org.springblade.mdm.program.service.programannotation.AnnotationUtil;
import org.springblade.mdm.program.service.programannotation.MachineAnnotationConfig;
import org.springblade.mdm.utils.EntityUtil;
import org.springblade.system.feign.ISysClient;
import org.springblade.system.pojo.entity.DictBiz;
@@ -35,9 +33,11 @@
import java.io.IOException;
import java.io.InputStream;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Optional;

/**
 * 普通派工完成数据处理器，功能：插入审批表数据，DispatchFinishListener调用
@@ -46,13 +46,13 @@
@Component("normalCureFinishDataHandler")
public class NormalCureFinishDataHandler implements FinishDataHandler {
   @Autowired
   private NcProgramApprovedService approvedService;
   @Autowired
   private ApproveRecordService approveRecordService;
   private MachineAnnotationConfig config;

   @Autowired
   private FlowProgramFileService flowProgramFileService;
   @Autowired
   private NcNodeService nodeService;

   @Autowired
   private NcNodeAutoCreateService ncNodeAutoCreateService;
   @Autowired
@@ -73,122 +73,208 @@
    * @param flowProps 流程属性
    */
   public void handleData(FlowProgramProperties flowProps) {
      // 执行业务逻辑

      //需要固化的节点
      NcNode pkgNode = nodeService.lambdaQuery().eq(NcNode::getProcessInstanceId,  flowProps.getProcessInstanceId()).one();
      //试切的
      pkgNode.setIsCured(1);
      pkgNode.setIsLocked(NcNode.UNLOCK);
      //设置过期日期
      pkgNode.upgradeVersionNumber();
      pkgNode.setExpireDate(calculateExpireDate());
      //原节点保留不动,置为老版本
      pkgNode.setIsLastEdition(0);
      pkgNode.setIsLocked(1);
      nodeService.updateById(pkgNode);

      List<NcNode> historyProgramPackageNodes = nodeService.getNodeHistory(pkgNode);
      nodeService.getBaseMapper().deleteById(pkgNode.getParentId());//删除机床组节点
      //List<NcNode> historyProgramPackageNodes = nodeService.getTryNodeHistory(pkgNode);
      try {
         moveNodeToCuredTree(pkgNode, historyProgramPackageNodes, flowProps);
         moveNodeToCuredTree(pkgNode, flowProps);//, historyProgramPackageNodes

         //固化不锁定，后续还可能使用该固化程序
         //nodeService.lockSameNameOtherMachineGroupProgramPackage(pkgNode);
         /*
         nodeService.lambdaUpdate().eq(NcNode::getDrawingNo,pkgNode.getDrawingNo())
            .eq(NcNode::getProcessNo,pkgNode.getProcessNo())
            .eq(NcNode::getName,pkgNode.getName())
            .ne(NcNode::getMachineGroupCode,pkgNode.getMachineGroupCode())
            .eq(NcNode::getIsCured,1)
            .set(NcNode::getIsLocked,NcNode.LOCKED)
            .set(NcNode::getRemark,"回传固化同名程序锁定")
            .update();
         */
      }catch(Exception e) {
         log.error("固化流程完成异常",e);
         throw new ServiceException("普通固化执行异常"+e.getMessage());
      }
      addApproveTable(pkgNode,flowProps);
      updateApproveRecordNodeId(flowProps.getProcessInstanceId(), pkgNode.getId());

   }


   /**
    * 将节点和历史节点挪动到固化的同级节点下
    * @param pkgNode 要挪动的节点
    * @param historyProgramPackageNodes 程序包名 历史节点
    * @param pkgNode1 要固化的节点
    * @param programProperties 流程属性
    */
   void moveNodeToCuredTree(NcNode pkgNode,List<NcNode> historyProgramPackageNodes, FlowProgramProperties programProperties) throws IOException {
      //创建节点到机床级别.(固化树)
      NcNode machineNode = ncNodeAutoCreateService.createNodeTreeToMachine(programProperties);
   void moveNodeToCuredTree(NcNode pkgNode1, FlowProgramProperties programProperties) throws IOException {

      pkgNode.setParentId(machineNode.getParentId());
      pkgNode.setParentIds(machineNode.getParentIds());//更新上级节点，下面还要用应为在historyProgramPackageNodes中的和这个不是一个实例
      //机床下现在没有文件了，程序包名升级与机床同级了，改为找到机床同级程序包名更新了
      //TODO 这个parentIds是不是不够？，不够，一个机床下多个程序包的情况不行吧，但是按照树，多个程序包不太现实
      this.nodeService.lambdaUpdate().likeRight(NcNode::getParentIds, machineNode.getParentIds())
      //创建节点到机床级别.(固化树)
      NcNode machineGroupNode = ncNodeAutoCreateService.createNodeTreeToMachineGroup(programProperties);

      //新建一个节点，作为固化节点，
      this.nodeService.lambdaUpdate().likeRight(NcNode::getParentIds, machineGroupNode.subNodeParentIds())
         .in(NcNode::getNodeType, Arrays.asList(NcNode.TYPE_PROGRAM_PACKAGE,NcNode.TYPE_PROGRAM_FILE))
         .ne(NcNode::getId,pkgNode.getId())//不要更新新固化的节点new
         .set(NcNode::getIsLastEdition,0).set(NcNode::getIsLocked,1).update();

      for(NcNode hisPackageNode : historyProgramPackageNodes){
         if(!hisPackageNode.getId().equals(pkgNode.getId())){
            hisPackageNode.setIsLastEdition(0);
      List<NcNode> programNodes = nodeService.getProgramFilesByPackageId(pkgNode1.getId());
      boolean tryPkgNodeHasChild = !programNodes.isEmpty();

      //新建固化节点
      NcNode cureNode = createNewCureNodeByTargetNode(pkgNode1,tryPkgNodeHasChild);
      cureNode.setParentId(machineGroupNode.getId());
      cureNode.setParentIds(machineGroupNode.subNodeParentIds());
      nodeService.save(cureNode);

      this.copyNonProgramNodes(pkgNode1,cureNode);
      /*
      List<NcNode> oriProgramNodes = nodeService.lambdaQuery().eq(NcNode::getParentId,pkgNode1.getId()).list();
      FlowProgramFile pfile;
      for(NcNode oldProgramNode : oriProgramNodes){
         oldProgramNode.setParentIds(pkgNode1.subNodeParentIds());
         oldProgramNode.setIsLastEdition(0);
         //当前固化程序包名下的“其他文件”非程序文件。不设置为老版本，直接挪到固化树下,两个网络之间只交换程序文件，其他文件只能保留
         //其他文件，需要复制到新建的固化节点下（程序文件不复制）
         pfile = flowProgramFileService.getById(oldProgramNode.getFlowProgramFileId());
         if(!pfile.isProgram()) {
            NcNode newFileNode = new NcNode();
            BeanUtils.copyProperties(oldProgramNode, newFileNode);
            EntityUtil.clearBaseProperties(newFileNode);
            newFileNode.setParentId(cureNode.getId());
            newFileNode.setParentIds(cureNode.subNodeParentIds());
            newFileNode.setIsLastEdition(1);
            nodeService.save(newFileNode);
         }
         hisPackageNode.setParentId(machineNode.getParentId());
         hisPackageNode.setParentIds(machineNode.getParentIds());//程序包与机床节点同级

         //处理程序包下层的程序节点111
         List<NcNode> programNodes = nodeService.lambdaQuery().eq(NcNode::getParentId,hisPackageNode.getId()).list();
         FlowProgramFile pfile;
         for(NcNode programNode : programNodes){
            programNode.setParentIds(hisPackageNode.getParentIds()+","+hisPackageNode.getId());
            programNode.setIsLastEdition(0);

            pfile = flowProgramFileService.getById(programNode.getFlowProgramFileId());
            if(programNode.getParentId().equals(pkgNode.getId()) && !pfile.isProgram()){
               //当前固化程序包名下的“其他文件”非程序文件。不设置为老版本，直接挪到固化树下,两个网络之间只交换程序文件，其他文件只能保留
               programNode.setIsLastEdition(1);
            }

         }
         nodeService.updateBatchById(programNodes);
      }
      nodeService.updateBatchById(historyProgramPackageNodes);
      nodeService.updateBatchById(oriProgramNodes);
      */

      Machine machine = machineService.getByCode(pkgNode.getMachineCode());
      List<DictBiz> annoDicts = programAnnotationService.getAnnotionList();
      //新的流程文件，需要在包节点下新建，不能用老的
      List<FlowProgramFile> files = flowProgramFileService.lambdaQuery().eq(FlowProgramFile::getProcessInstanceId,pkgNode.getProcessInstanceId()).list();
      this.addNewProgramNode(cureNode,pkgNode1.getProcessInstanceId());

   }

   /**
    * 从待固化节点复制非程序文件节点到固化节点下
    * @param oriPkgNode 待固化节点
    * @param cureNode 固化节点
    */
   void copyNonProgramNodes(NcNode oriPkgNode,NcNode cureNode){
      List<NcNode> oriProgramNodes = nodeService.lambdaQuery().eq(NcNode::getParentId,oriPkgNode.getId()).list();
      FlowProgramFile pfile;
      for(NcNode oldProgramNode : oriProgramNodes){
         oldProgramNode.setParentIds(oriPkgNode.subNodeParentIds());
         oldProgramNode.setIsLastEdition(0);
         //当前固化程序包名下的“其他文件”非程序文件。不设置为老版本，直接挪到固化树下,两个网络之间只交换程序文件，其他文件只能保留
         //其他文件，需要复制到新建的固化节点下（程序文件不复制）
         pfile = flowProgramFileService.getById(oldProgramNode.getFlowProgramFileId());
         if(!pfile.isProgram()) {
            NcNode newFileNode = new NcNode();
            BeanUtils.copyProperties(oldProgramNode, newFileNode);
            EntityUtil.clearBaseProperties(newFileNode);
            newFileNode.setParentId(cureNode.getId());
            newFileNode.setParentIds(cureNode.subNodeParentIds());
            newFileNode.setIsLastEdition(1);
            nodeService.save(newFileNode);
         }

      }
      nodeService.updateBatchById(oriProgramNodes);
   }

   void addNewProgramNode(NcNode cureNode,String processInstanceId) throws IOException {
      Machine machine = machineService.getByCode(cureNode.getMachineCode());
      List<DictBiz> annoDicts = programAnnotationService.getAnnotionDictList();
      //新的流程文件，需要在包节点下新建，不能用老的包节点
      List<FlowProgramFile> files = flowProgramFileService.lambdaQuery().eq(FlowProgramFile::getProcessInstanceId,processInstanceId).list();
      for(FlowProgramFile flowProgramFile : files){
         NcNode newProgNode = new NcNode();
         BeanUtils.copyProperties(pkgNode,newProgNode);

         BeanUtils.copyProperties(cureNode,newProgNode);
         EntityUtil.clearBaseProperties(newProgNode);

         newProgNode.setName(flowProgramFile.getName());
         newProgNode.setNodeType(NcNode.TYPE_PROGRAM_FILE);
         newProgNode.setParentId(pkgNode.getId());
         newProgNode.setParentIds(pkgNode.getParentIds()+","+pkgNode.getId());
         newProgNode.setParentId(cureNode.getId());
         newProgNode.setParentIds(cureNode.subNodeParentIds());
         newProgNode.setIsLastEdition(1);
         newProgNode.setFlowProgramFileId(flowProgramFile.getId());
         newProgNode.setIsCured(1);

         setGhAnnotation(flowProgramFile,machine.getControlSystem(),annoDicts);

         nodeService.save(newProgNode);

         //修改文件内容更新注释，并更新文件数据的地址
         ///替换注释后总是不行啊
         setGhAnnotation(flowProgramFile,machine.getMachineGroupCode(),annoDicts);

         //flowProgramFileService.updateById(flowProgramFile);
      }
   }

   /**
    * 复制待固化节点数据，创建一个新的固化节点
    * @param waitingCureNode 待固化节点
    * @param tryPkgNodeHasProgramFiles 是否有程序文件
    * @return 固化节点
    */
   NcNode createNewCureNodeByTargetNode(NcNode waitingCureNode,boolean tryPkgNodeHasProgramFiles){
      //新建一个节点，作为固化节点，老节点保留不动
      NcNode cureNode = new NcNode();
      BeanUtils.copyProperties(waitingCureNode, cureNode);
      EntityUtil.clearBaseProperties(cureNode);
      cureNode.setIsCured(1);
      cureNode.setIsLocked(NcNode.UNLOCK);
      cureNode.setIsLastEdition(1);
      cureNode.setExpireDate(calculateExpireDate());//设置过期日期

      cureNode.setHisSerial(nodeService.calculateHistorySerial(cureNode));

      Optional<NcNode> optOldCuredPackageNode = nodeService.lambdaQuery().eq(NcNode::getName,waitingCureNode.getName())
         .eq(NcNode::getProcessNo,waitingCureNode.getProcessNo())
         .eq(NcNode::getProcessEdition,waitingCureNode.getProcessEdition())
         .eq(NcNode::getIsLastEdition,1).eq(NcNode::getIsCured,1).oneOpt();

      if(optOldCuredPackageNode.isEmpty() && tryPkgNodeHasProgramFiles){
         //之前 没有已固化的程序包名，则直接更新版本号，如果有，那就使用node现在的版本号，因为不可用转为试切，审批完成已经升级version
         //tryPkdNodeHasProgramFiles 试切程序包下有程序文件才需要升级版本（没有文件的是车床，无文件，直接等待回传）
         cureNode.upgradeVersionNumber();
      }

      return cureNode;
   }
   /**
    * 设置固化注释,实现方式，获取文件字节下，修改后替换文件
    * @param flowProgramFile oss 文件
    *
    */
   void setGhAnnotation(FlowProgramFile flowProgramFile,String machineGroup,List<DictBiz> annoDicts) throws IOException {
   void setGhAnnotation(FlowProgramFile flowProgramFile,String controlSystem,List<DictBiz> annoDicts) throws IOException {
      String ossName = flowProgramFile.getOssName();
      //
      try(InputStream ins = ossTemplate.statFileStream(ossName);){
         byte[] bytes = IOUtils.toByteArray(ins);
         ByteArrayInputStream byteInputStream =  new ByteArrayInputStream(bytes);

         InputStream finishedStream = programAnnotationService.setGHAnnotation(byteInputStream,machineGroup,annoDicts);

         List<DictBiz> annoDictList = programAnnotationService.getAnnotionDictList();
         AnnotationProperties annoProps = config.getConfigMap().get(controlSystem);
         if(annoProps == null){
            annoProps = AnnotationProperties.getDefault();
         }
         InputStream finishedStream =AnnotationUtil.setAnnotationAndGetInputStream(byteInputStream, AnnotationUtil.GH, annoProps.getStatusLineIndex(), controlSystem, annoDictList);
         try(finishedStream) {
            finishedStream.reset();
            BladeFile bfile = ossTemplate.putFile(flowProgramFile.getName(), finishedStream);
            //替换原有的文件地址
            flowProgramFile.setOssName(bfile.getName());

            flowProgramFileService.updateById(flowProgramFile);
         }
      }
   }


   /**
    * 计算有效期
    * @return
    * @return 过期日
    */
   private Date calculateExpireDate() {
      R<String> validMonResult = sysClient.getParamValue(ParamConstants.CURE_VALID_MONTH_KEY);
@@ -202,27 +288,4 @@
      return DateUtil.toDate(now.plusMonths(month));
   }

   /**
    * 保存审批完成的记录
    * @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();
   }
}