yangys
2025-08-17 0ef4cc755bddd87799b8bfdd65c8123df6e149d0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
package org.springblade.mdm.program.service;
 
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springblade.core.oss.model.BladeFile;
import org.springblade.core.tool.api.R;
import org.springblade.mdm.flow.entity.FlowProgramFile;
import org.springblade.mdm.utils.FileContentUtil;
import org.springblade.system.feign.IDictClient;
import org.springblade.system.pojo.entity.Dict;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
 
/**
 * 下发/回传程序统计
 *
 * @author yangys
 */
@Slf4j
@Service
public class ProgramAnnotationService {
 
    @Autowired
    private IDictClient dictClient;
 
    private static final String DEFAULT_ANNOTATION_SETTING = "(,)";
 
    public static final String ANNOTATION_DICT = "machine_annotation";
 
    public List<Dict> getAnnotionList(){
        List<Dict> annotationList;
        R<List<Dict>> dictsResult = dictClient.getList(ANNOTATION_DICT);
        if(dictsResult.isSuccess()) {
            annotationList = dictsResult.getData();
        }else{
            annotationList = Collections.emptyList();
        }
 
        return annotationList;
    }
 
 
    /**
     * 判断一行文本是否是注释
     * @param line
     * @param annotationList 注释注释字典项列表
     * @return
     */
    public boolean isAnnotation(String line,String machineGroupCode,List<Dict> annotationList){
        boolean isAnno = false;
        Optional<Dict> dictOpt = annotationList.stream().filter(dict -> {return dict.getDictKey().equals(machineGroupCode);}).findFirst();
        String annotationSetting = DEFAULT_ANNOTATION_SETTING;
        if(dictOpt.isPresent()) {
            annotationSetting = dictOpt.get().getRemark();
        }
        String begin = "";
        String end = "";
        String[] arr = annotationSetting.split(",");
        if(arr.length == 2){
            begin = arr[0];
            end = arr[1];
        }
        isAnno = StringUtils.startsWith(line,begin) && StringUtils.endsWith(line,end);
        return isAnno;
    }
 
 
 
    public String generateAnnotation(String oriTest,String machineGroupCode,List<Dict> annotationList) {
 
        String annotation = oriTest;
        String begin = "(";
        String end = ")";
 
        Optional<Dict> dictOpt = annotationList.stream().filter(dict -> {return dict.getDictKey().equals(machineGroupCode);}).findFirst();
        String annotationSetting = DEFAULT_ANNOTATION_SETTING;
        if(dictOpt.isPresent()) {
            annotationSetting = dictOpt.get().getRemark();
        }
        String[] arr = StringUtils.split(annotationSetting,",");
        if(arr.length == 2){
            begin = arr[0];
            end = arr[1];
        }else if(arr.length == 1){
            begin = begin = arr[0];
            end = "";
        }
 
        annotation = begin + oriTest + end;
        return annotation;
    }
 
    public String[] getAnnotationStartAndEnd(String machineGroupCode,List<Dict> annotationList) {
 
        String begin = "(";
        String end = ")";
 
        Optional<Dict> dictOpt = annotationList.stream().filter(dict -> {return dict.getDictKey().equals(machineGroupCode);}).findFirst();
        String annotationSetting = DEFAULT_ANNOTATION_SETTING;
        if(dictOpt.isPresent()) {
            annotationSetting = dictOpt.get().getRemark();
        }
        String[] arr = StringUtils.split(annotationSetting,",");
        if(arr.length == 2){
            begin = arr[0];
            end = arr[1];
        }else if(arr.length == 1){
            begin = arr[0];
            end = "";
        }
 
 
        return new String[]{begin,end};
    }
 
    public String removeAnnotation(String machineGroupCode,String text,String begin,String end){
        List<Dict> annoDicts = getAnnotionList();
        String[] arr = getAnnotationStartAndEnd(machineGroupCode,annoDicts);
        return removeAnnotationInner(text,begin,end);
    }
 
    public static String removeAnnotationInner(String text,String begin,String end){
        String temp = StringUtils.removeEnd(StringUtils.removeStart(text,begin),end);
        return temp;
    }
 
    /**
     * 为程序文件增加注释
     * @param oriText 原始文本
     * @param lineIndex 行索引 0 based
     * @param inputStream 文件的输入流
     * @param machineGroup 机床组 生成注释用
     * @return 加注释后的流
     * @throws IOException
     */
    public InputStream setAnnotation(String oriText,int lineIndex,InputStream inputStream, String machineGroup) throws IOException {
        List<Dict> annoDicts = getAnnotionList();
        //
        InputStream finishedStream;
        try(inputStream){
            ByteArrayInputStream byteInputStream =  new ByteArrayInputStream(IOUtils.toByteArray(inputStream));
 
            String annoTxt = generateAnnotation(oriText,machineGroup,annoDicts);//加了注释之后的文本
 
            String lineText = FileContentUtil.readLineAt(byteInputStream,lineIndex);//第三行应该是状态注释
            byteInputStream.reset();
 
            if(isAnnotation(lineText,machineGroup,annoDicts)){
                finishedStream = FileContentUtil.replaceAtLine(byteInputStream,lineIndex,annoTxt);
            }else{
                finishedStream = FileContentUtil.insertLine(byteInputStream,lineIndex,annoTxt);
            }
            finishedStream.reset();
 
        }
 
        return finishedStream;
    }
}