优化程序注释

yangys

2025-09-20 fe5370f0b107736fd41de699612f021969bc954f

优化程序注释

 blade-service/blade-mdm/src/main/java/org/springblade/mdm/machinefile/service/ReceiveFileCheckService.java

@@ -1,8 +1,10 @@
package org.springblade.mdm.machinefile.service;

import com.qiniu.util.IOUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.tool.utils.Func;
import org.springblade.mdm.basesetting.machine.entity.Machine;
import org.springblade.mdm.basesetting.machine.service.MachineService;
import org.springblade.mdm.commons.contants.RegExpConstants;
@@ -10,9 +12,10 @@
import org.springblade.mdm.gkw.programnode.vo.ProgramNameVO;
import org.springblade.mdm.machinefile.entity.FileSendRecord;
import org.springblade.mdm.machinefile.entity.MachineFile;
import org.springblade.mdm.program.entity.ProgramOnMachine;
import org.springblade.mdm.program.service.ProgramAnnotationService;
import org.springblade.mdm.program.service.ProgramOnMachineService;
import org.springblade.mdm.program.service.programannotation.AnnotationUtil;
import org.springblade.mdm.program.service.programannotation.*;
import org.springblade.mdm.utils.FileContentUtil;
import org.springblade.mdm.utils.ProgramFileNameParser;
import org.springblade.system.pojo.entity.DictBiz;
@@ -21,10 +24,7 @@
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
@@ -46,6 +46,11 @@
    private ProgramOnMachineService programOnMachineService;
    @Autowired
    private FileSendRecordService fileSendRecordService;
    @Autowired
    private AnnotationProcessorHelper annoProcessHelper;
    @Autowired
    private ProgramAnnotationService programAnnotationService;

    /**
     * æ–‡ä»¶åˆæ³•æ€§æ£€æŸ¥
     * @param machineFile
@@ -59,9 +64,12 @@
        if(!checkFilePath.toFile().exists()){
            return;
        }

        AnnotationProperties annoProps = AnnotationProperties.getDefault();
        try(InputStream fileIns = Files.newInputStream(checkFilePath);) {
            int excepType = MachineFile.EXCEPTION_OK;
            if(!FileContentUtil.isTextFile(fileIns)){
            ByteArrayInputStream byteStream = new ByteArrayInputStream(IOUtils.toByteArray(fileIns));
            if(!FileContentUtil.isTextFile(byteStream)){
                //非文本
                excepType = MachineFile.EXCEPTION_NOT_TEXT;
            }else{
@@ -94,6 +102,28 @@
                                excepType = MachineFile.EXCEPTION_NOT_MATCH_SEND;
                            }
                        }

                        if(excepType == MachineFile.EXCEPTION_NOT_MATCH_SEND){
                            //如果文件未下发过，查看是否有现场编程记录
                            byteStream.reset();

                            //AnnotationProcessor processor = annoProcessHelper.getProcessor(machine.getControlSystem());
                            String lgLine = FileContentUtil.readLineAt(byteStream,annoProps.getDeviationLineIndex());
                            String textWithoutAnno = AnnotationUtil.removeAnnotation(machine.getControlSystem(),lgLine,programAnnotationService.getAnnotionDictList());
                            String[] strArr = Func.split(textWithoutAnno,":");//临时更改单是冒号分隔，后面是单号
                            long progOnMachineCount = programOnMachineService.lambdaQuery()
                                .eq(ProgramOnMachine::getDrawingNo,progNameVO.getDrawingNo())
                                .eq(ProgramOnMachine::getProcessNo,progNameVO.getProcessNo())
                                .eq(ProgramOnMachine::getProcessEdition,progNameVO.getProcessEdition())
                                .eq(strArr.length==2,ProgramOnMachine::getDeviation,strArr[1])//临时更改单匹配

                                .eq(ProgramOnMachine::getMachineCode,machineFile.getMachineCode()).count();

                            if(progOnMachineCount > 0){//有现场编程记录，检查通过
                                excepType = MachineFile.EXCEPTION_OK;
                            }

                        }
                    }
                }
            }

 blade-service/blade-mdm/src/main/java/org/springblade/mdm/program/service/NcProgramExportDNCService.java

@@ -130,6 +130,7 @@
                annoData.setProgramStatus(status);
                annoData.setDeviation(programPackageNode.getDeviation());
                annoData.setFilename(programFile.getName());

                InputStream addedInsFinal = annoProcessor.putAnnotation(annoData,inputStream);
                addedInsFinal.reset();
                /*

 blade-service/blade-mdm/src/main/java/org/springblade/mdm/program/service/programannotation/AbstractProcessor.java

@@ -2,6 +2,7 @@

import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springblade.mdm.program.service.ProgramAnnotationService;
import org.springblade.mdm.utils.FileContentUtil;
import org.springblade.system.pojo.entity.DictBiz;
@@ -31,7 +32,15 @@
            byteInputStream.reset();

            if(AnnotationUtil.isAnnotation(sendDirLine,getControlSystem(),annoDicts)){
                finishedStream = FileContentUtil.replaceAtLine(byteInputStream,annotationProperties.getSendPathLineIndex(),sendPathAnnotation);
                String planText = AnnotationUtil.removeAnnotation(getControlSystem(),sendDirLine,annoDicts);
                if(!planText.equals(sendPath)) {
                    //非路径的注释，插入
                    finishedStream = FileContentUtil.insertLine(byteInputStream,annotationProperties.getSendPathLineIndex(),sendPathAnnotation);
                }else{
                    //是路径，不处理直接返回原输入流
                    finishedStream = inputStream;
                }
                //finishedStream = FileContentUtil.replaceAtLine(byteInputStream,annotationProperties.getSendPathLineIndex(),sendPathAnnotation);
            }else{
                finishedStream = FileContentUtil.insertLine(byteInputStream,annotationProperties.getSendPathLineIndex(),sendPathAnnotation);
            }
@@ -43,21 +52,37 @@
    }
    @Override
    public InputStream putFilenameAnnotation(String fileName, InputStream inputStream) throws IOException {
        List<DictBiz> annoDicts = programAnnotationService.getAnnotionDictList();
        ByteArrayInputStream bais = new ByteArrayInputStream(com.qiniu.util.IOUtils.toByteArray(inputStream));
        List<DictBiz> annoDicts = programAnnotationService.getAnnotionDictList();//TODO è¿™é‡Œåº”该不用加载，参数传过来就行
        ByteArrayInputStream byteStream = new ByteArrayInputStream(IOUtils.toByteArray(inputStream));

        String line = FileContentUtil.readLineAt(bais, annotationProperties.getProgramNameLineIndex());
        bais.reset();
        boolean isAnnotation = AnnotationUtil.isAnnotation(line,this.getControlSystem(),annoDicts);
        InputStream insAfter;
        String programNameLine = FileContentUtil.readLineAt(byteStream, annotationProperties.getProgramNameLineIndex());
        byteStream.reset();
        boolean isAnnotation = AnnotationUtil.isAnnotation(programNameLine,this.getControlSystem(),annoDicts);
        InputStream insAfterProgramName;
        //加入程序名注释行
        String proNameLine =  AnnotationUtil.generateAnnotation(FilenameUtils.removeExtension(fileName),getControlSystem(),annoDicts);
        String proNameAnnotation =  AnnotationUtil.generateAnnotation(FilenameUtils.removeExtension(fileName),getControlSystem(),annoDicts);

        if(isAnnotation){//是注释
            //提取注释内文字
            //String planText = AnnotationUtil.removeAnnotation(getControlSystem(),programNameline,annoDicts);
            if(!StringUtils.equals(programNameLine,proNameAnnotation)) {
                //注释不是程序名（工艺员自己写的注释），插入
                insAfterProgramName = FileContentUtil.insertLine(byteStream,annotationProperties.getProgramNameLineIndex(),proNameAnnotation);
            }else{
                //是程序名注释，不处理，返回原stream
                insAfterProgramName =  byteStream;
            }
        }else{
            //非注释，插入状态
            insAfterProgramName = FileContentUtil.insertLine(byteStream,annotationProperties.getProgramNameLineIndex(),proNameAnnotation);
        }
        /*
        if(isAnnotation){
            insAfter = FileContentUtil.replaceAtLine(bais, annotationProperties.getProgramNameLineIndex(),proNameLine);
        }else{
            insAfter = FileContentUtil.insertLine(bais, annotationProperties.getProgramNameLineIndex(),proNameLine);
        }
        return insAfter;
        }*/
        return insAfterProgramName;
    }

    @Override
@@ -69,41 +94,84 @@
            ByteArrayInputStream byteInputStream =  new ByteArrayInputStream(IOUtils.toByteArray(inputStream));

            //1加入发送路径的注释
            /*
            String sendPathAnnotation = AnnotationUtil.generateAnnotation(annoData.getSendPath(),getControlSystem(),annoDicts);//加了注释之后的文本

            String sendDirLine = FileContentUtil.readLineAt(byteInputStream,annotationProperties.getSendPathLineIndex());//第2行是发送路径
            byteInputStream.reset();
            String statusLine = FileContentUtil.readLineAt(byteInputStream,annotationProperties.getStatusLineIndex());//状态注释
            byteInputStream.reset();

            InputStream insAfterSetSendDir ;
            if(AnnotationUtil.isAnnotation(sendDirLine,getControlSystem(),annoDicts)){
                insAfterSetSendDir = FileContentUtil.replaceAtLine(byteInputStream,annotationProperties.getSendPathLineIndex(),sendPathAnnotation);
            }else{
                insAfterSetSendDir = FileContentUtil.insertLine(byteInputStream,annotationProperties.getSendPathLineIndex(),sendPathAnnotation);
            }

            insAfterSetSendDir.reset();
            */

            InputStream insAfterSetSendDir = putSendPathAnnotation(annoData.getSendPath(),byteInputStream,annoDicts);

            /*
            String statusLine = FileContentUtil.readLineAt(insAfterSetSendDir,annotationProperties.getStatusLineIndex());//状态注释
            insAfterSetSendDir.reset();

            //加入状态注释行
            InputStream insAfterStatus;
            String statusAnnotation = AnnotationUtil.generateAnnotation(annoData.getProgramStatus(),getControlSystem(),annoDicts);//注释后的状态文本
            if(AnnotationUtil.isAnnotation(statusLine,getControlSystem(),annoDicts)){
                finishedStream = FileContentUtil.replaceAtLine(insAfterSetSendDir,annotationProperties.getStatusLineIndex(),statusAnnotation);
                insAfterStatus = FileContentUtil.replaceAtLine(insAfterSetSendDir,annotationProperties.getStatusLineIndex(),statusAnnotation);
            }else{
                finishedStream = FileContentUtil.insertLine(insAfterSetSendDir,annotationProperties.getStatusLineIndex(),statusAnnotation);
                insAfterStatus = FileContentUtil.insertLine(insAfterSetSendDir,annotationProperties.getStatusLineIndex(),statusAnnotation);
            }*/
            InputStream insAfterStatus = putStatusAnnotation(annoData.getProgramStatus(),insAfterSetSendDir,annoDicts);

            if(StringUtils.isNotBlank(annoData.getDeviation())){
                finishedStream = putDeviationAnnotation(annoData.getDeviation(),insAfterStatus,annoDicts);
            }else{
                //是更改单号，不处理直接返回原输入流
                finishedStream = insAfterStatus;
            }
        }

        return finishedStream;
    }

    protected InputStream putStatusAnnotation(String status,InputStream inputStream,List<DictBiz> annoDicts) throws IOException {
        InputStream insAfterStatus;
        //加入lg单号

        String statusLine = FileContentUtil.readLineAt(inputStream,annotationProperties.getStatusLineIndex());//状态注释
        String stationAnnotation = AnnotationUtil.generateAnnotation(status,getControlSystem(),annoDicts);

        inputStream.reset();
        if(AnnotationUtil.isAnnotation(statusLine,getControlSystem(),annoDicts) ){
            //是注释
            //提取注释内文字
            String planText = AnnotationUtil.removeAnnotation(getControlSystem(),statusLine,annoDicts);
            if(!StringUtils.equalsAny(planText,AnnotationUtil.SQ,AnnotationUtil.GH,AnnotationUtil.LG)) {
                //注释不是状态（工艺员自己写的注释），插入
                insAfterStatus = FileContentUtil.insertLine(inputStream,annotationProperties.getStatusLineIndex(),stationAnnotation);
            }else{
                //是状态注释，替换
                insAfterStatus =  FileContentUtil.replaceAtLine(inputStream,annotationProperties.getStatusLineIndex(),stationAnnotation);
            }
        }else{
            //非注释，插入状态
            insAfterStatus = FileContentUtil.insertLine(inputStream,annotationProperties.getStatusLineIndex(),stationAnnotation);
        }
        return insAfterStatus;
    }

    protected InputStream putDeviationAnnotation(String deviation,InputStream inputStream,List<DictBiz> annoDicts) throws IOException {
        InputStream insAfter1;
        //加入lg单号
        String devLine = FileContentUtil.readLineAt(inputStream,annotationProperties.getDeviationLineIndex());//状态注释

        String devAnnotation = AnnotationUtil.generateAnnotation(deviation,getControlSystem(),annoDicts);

        inputStream.reset();
        if(AnnotationUtil.isAnnotation(devLine,getControlSystem(),annoDicts) ){
            //是注释
            //提取注释内文字
            String planText = AnnotationUtil.removeAnnotation(getControlSystem(),devLine,annoDicts);
            if(!planText.equals(deviation)) {
                //注释不是临时更改单号（工艺员自己写的注释），插入
                insAfter1 = FileContentUtil.insertLine(inputStream,annotationProperties.getDeviationLineIndex(),devAnnotation);
            }else{
                //是更改单号，不处理直接返回原输入流
                insAfter1 = inputStream;
            }
        }else{
            //非注释，怎插入lg号
            insAfter1 = FileContentUtil.insertLine(inputStream,annotationProperties.getDeviationLineIndex(),devAnnotation);
        }
        return insAfter1;
    }

    @Override
    public abstract void setControlSystem(String controlSystemDictVal) ;


 blade-service/blade-mdm/src/main/java/org/springblade/mdm/program/service/programannotation/AnnotationProcessorHelper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,29 @@
package org.springblade.mdm.program.service.programannotation;

import org.springblade.core.tool.utils.SpringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * è´Ÿè´£åˆ‡æ¢åˆé€‚的注释处理器
 */
@Component
public class AnnotationProcessorHelper {
    @Autowired
    private MachineAnnotationConfig annotationConfig;

    public AnnotationProcessor getProcessor(String controlSystem){
        AnnotationProperties props = annotationConfig.getConfigMap().get(controlSystem);
        AnnotationProcessor processor;
        if(props != null){
            processor = SpringUtil.getBean(props.getBeanId());
            processor.setAnnotationProperties(props);

        }else{
            processor = SpringUtil.getBean(DefaultProcessor.class);
            processor.setAnnotationProperties(AnnotationProperties.getDefault());
        }
        processor.setControlSystem(controlSystem);
        return processor;
    }
}

 blade-service/blade-mdm/src/main/java/org/springblade/mdm/task/ReceiveDirCheckTask.java

@@ -47,6 +47,9 @@
    @Autowired
    private ReceiveFileCheckService receiveFileCheckService;

    @Autowired
    private ReceiveDirMoveService receiveDirMoveService;

    // æ¯5秒执行一次
    //@Scheduled(fixedRate = 1000000)
    //@Scheduled(cron = "0 1 0 * * ?") // æ¯å¤©ä¸Šåˆ0点1分执行
@@ -62,6 +65,8 @@
            log.info("reccheckfile start");
            checkFiles();

            //检查完成，直接移动无异常的文件
            receiveDirMoveService.moveValidateFiles();
            log.info("reccheckfile end");
        }


 blade-service/blade-mdm/src/main/java/org/springblade/mdm/task/ReceiveDirMoveService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,84 @@
package org.springblade.mdm.task;

import lombok.extern.slf4j.Slf4j;
import org.springblade.mdm.basesetting.machine.entity.Machine;
import org.springblade.mdm.basesetting.machine.service.MachineService;
import org.springblade.mdm.commons.service.ParamService;
import org.springblade.mdm.machinefile.entity.MachineFile;
import org.springblade.mdm.machinefile.service.MachineFileService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.time.LocalDateTime;
import java.util.List;

/**
 * æœºåºŠå›žä¼ æ–‡ä»¶å¤¹rec，目录文件超过机床设定的时间移动到temp文件夹
 */
@Slf4j
@Component
@EnableScheduling
public class ReceiveDirMoveService {
    @Autowired
    private MachineFileService machineFileService;
    @Autowired
    private MachineService machineService;


    /**
     * æ‰«ææ•°æ®åº“记录，超时则移动文件
     */
    public void moveValidateFiles() {
        List<Machine> machines = machineService.getEnableMachines();
        LocalDateTime now = LocalDateTime.now();
        for (Machine machine : machines) {

            //LocalDateTime earlyTime = now.minusHours(remainHours);
            List<MachineFile> pendingFiles = this.machineFileService.lambdaQuery()
                .eq(MachineFile::getDirType,MachineFile.DIR_TYPE_REC)
                .eq(MachineFile::getExceptionType,MachineFile.EXCEPTION_OK)
                .eq(MachineFile::getMachineCode,machine.getCode()).list();


            for(MachineFile overTimeFile : pendingFiles){
                try {
                    moveFileToTemp(overTimeFile, machine);
                }catch(Exception e){
                    log.error("移动rec文件失败:{}",overTimeFile.getName(),e);
                }
            }

        }

    }

    /**
     * æ–‡ä»¶ç§»åŠ¨åˆ°temp
     * @param overTimeFile
     */
    private void moveFileToTemp(MachineFile overTimeFile,Machine machine) throws IOException {
        String srcFilepath = MachineFileService.getBasePath(machine,overTimeFile.getDirType())+ File.separator+overTimeFile.getName();
        Path source = Paths.get(srcFilepath);
        if(!source.toFile().exists()){
            return;
        }
        String targetFilepath = MachineFileService.getBasePath(machine,MachineFile.DIR_TYPE_TEMP)+ File.separator+overTimeFile.getName();
        Path target = Paths.get(targetFilepath);

        Path targetDir = target.getParent();
        if (targetDir != null && !Files.exists(targetDir)) {
            Files.createDirectories(targetDir);
        }

        // ä½¿ç”¨ REPLACE_EXISTING é€‰é¡¹æ¥è¦†ç›–已存在的文件
        Files.move(source, target, StandardCopyOption.REPLACE_EXISTING);
    }
}

 blade-service/blade-mdm/src/main/java/org/springblade/mdm/task/ReceiveDirMoveTask.java

@@ -38,7 +38,8 @@
     */
    private static final int DEFAULT_HOUR = 0;

    @Scheduled(cron = "${task.cron.machine_rec_move:0 3 * * * ?}")
    //@Scheduled(cron = "${task.cron.machine_rec_move:0 3 * * * ?}")
    /*
    public void execute() {
        String networkType = paramService.getParamValue(ParamService.NETWORK_TYPE,ParamService.NETWORK_TYPE_SHEMI);

@@ -49,17 +50,13 @@

    }

    /**
     * æ‰«ææ•°æ®åº“记录，超时则移动文件
     */

    public void moveValidateFiles() {
        List<Machine> machines = machineService.getEnableMachines();
        LocalDateTime now = LocalDateTime.now();
        for (Machine machine : machines) {
            int remainHours = machine.getReceiveDirExpiryHours() != null ?machine.getReceiveDirExpiryHours():DEFAULT_HOUR;
            /*if(remainHours == 0){
                continue;
            }*/

            //LocalDateTime earlyTime = now.minusHours(remainHours);
            List<MachineFile> pendingFiles = this.machineFileService.lambdaQuery()
                .eq(MachineFile::getDirType,MachineFile.DIR_TYPE_REC)
@@ -79,10 +76,6 @@

    }

    /**
     * æ–‡ä»¶ç§»åŠ¨åˆ°temp
     * @param overTimeFile
     */
    private void moveFileToTemp(MachineFile overTimeFile,Machine machine) throws IOException {
        String srcFilepath = MachineFileService.getBasePath(machine,overTimeFile.getDirType())+ File.separator+overTimeFile.getName();
        Path source = Paths.get(srcFilepath);
@@ -100,4 +93,5 @@
        // ä½¿ç”¨ REPLACE_EXISTING é€‰é¡¹æ¥è¦†ç›–已存在的文件
        Files.move(source, target, StandardCopyOption.REPLACE_EXISTING);
    }
    */
}

 blade-service/blade-mdm/src/test/java/org/springblade/mdm/machinefile/service/ReceiveFileCheckServiceTest.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,16 @@
package org.springblade.mdm.machinefile.service;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springblade.core.tool.utils.Func;

public class ReceiveFileCheckServiceTest {
    @Test
    public void testSplie(){
        String[] arr = Func.split("LG",":");
        Assertions.assertEquals(1, arr.length);

        arr = Func.split(null,":");
        Assertions.assertEquals(0, arr.length);
    }
}

 doc/sql/mdm/mdm.mysql.all.create.sql

@@ -21,7 +21,7 @@
  `tenant_id` varchar(6) DEFAULT NULL COMMENT '所属租户',
  `code` varchar(100) NOT NULL COMMENT '机床编号',
  `name` varchar(100) NOT NULL COMMENT '机床描述/型号',
  `avatar` varchar(400) DEFAULT NULL COMMENT '图片地址',
  `equipment_code` varchar(100) DEFAULT NULL COMMENT '设备编号',
  `machine_group_code` varchar(255) NOT NULL COMMENT '所属机床组代码，,在业务字典配置（key=machine_group）',
  `machine_spec` varchar(40) DEFAULT NULL COMMENT '机器规格:01车床/02铣床,在业务字典配置（key=machine_spec）',
  `operator` varchar(100)  COMMENT '操作员，文本录入',
@@ -202,6 +202,7 @@
   `process_name` varchar(20) NULL COMMENT '工序名称',
   `process_no` varchar(100) NULL COMMENT '工序号',
   `machine_code` varchar(100) DEFAULT NULL COMMENT '设备编号/机床编号',
   `equipment_code` varchar(100) DEFAULT NULL COMMENT '设备编号',
   `drawing_no` varchar(100) NULL COMMENT '零组件编号/图号',
   `process_edition` varchar(40) DEFAULT NULL COMMENT '工序版次，升版就是变更改该字段，需要保留历史记录',
   `craft_edition` varchar(40) DEFAULT NULL COMMENT '工艺版次',
@@ -211,7 +212,8 @@
   `err_msg` varchar(200) NULL COMMENT '错误或者提示信息',
   `process_instance_id` varchar(64) NULL COMMENT '关联的流程实例id，流程发起后填充',
   `program_no` varchar(20) NULL COMMENT '数控程序编号，流程发起后填充',
   `mes_task_id` varchar(100) NULL COMMENT 'MES任务唯一标识',
   `operation_id` varchar(100) NULL COMMENT '工序唯一码(MES发送)',
   `process_card` varchar(40) NULL COMMENT '过程卡号（mes提供）',
   `inspector` varchar(40) NULL COMMENT '检验员（mes提供）',
   `check_time` datetime DEFAULT NULL COMMENT '检验时间',
   `operator` varchar(40) NULL COMMENT '操作者（mes提供）',
@@ -385,8 +387,6 @@
    PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='工控网机床文件修改历史';



DROP TABLE IF EXISTS `mdm_file_send_record`;
CREATE TABLE `mdm_file_send_record` (
    `id` bigint NOT NULL,
@@ -420,3 +420,35 @@
   PRIMARY KEY (`drawing_no`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='零组件号下拉数据';


DROP TABLE IF EXISTS `mdm_program_on_machine`;
CREATE TABLE `mdm_program_on_machine` (
    `id` bigint NOT NULL,
    `tenant_id` varchar(6) DEFAULT NULL COMMENT '所属租户',
    `drawing_no` varchar(100) NULL COMMENT '零组件编号/图号',
    `process_no` varchar(100) NULL COMMENT '工序号',
    `process_edition` varchar(40) DEFAULT NULL COMMENT '工序版次',
    `machine_code` varchar(100) DEFAULT NULL COMMENT '设备编号/机床编号',
    `process_instance_id` varchar(64) DEFAULT NULL COMMENT '流程实例id',
    `status` int DEFAULT NULL COMMENT '业务状态',
    `create_dept` bigint DEFAULT NULL COMMENT '创建单位',
    `is_deleted` int DEFAULT NULL,
    `create_time` datetime DEFAULT NULL COMMENT '创建时间',
    `create_user` bigint DEFAULT NULL COMMENT '创建人',
    `update_time` datetime DEFAULT NULL COMMENT '更新时间',
    `update_user` bigint DEFAULT NULL COMMENT '更新人',
    PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='现场编程记录';

DROP TABLE IF EXISTS `mdm_mes_sync`;
CREATE TABLE `mdm_mes_sync` (
    `id` bigint NOT NULL,
    `operation_id` varchar(100) NULL COMMENT '工序唯一码',
    `program_no` varchar(100) NOT NULL COMMENT '程序编号',
    `cured_time` datetime NOT NULL COMMENT '固化时间',
    `try_times` int NOT NULL DEFAULT 0 COMMENT '重试次数',
    `status` int NOT NULL COMMENT '状态：1:初始入库; 2:同步成功;3:同步失败',
    `create_time` datetime NOT NULL COMMENT '创建时间',
    `update_time` datetime NOT NULL COMMENT '更新时间',
    PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='向MES回传数据';