yangys
2025-08-20 432198337fb3d8a99fadb4b7825771d68bb10b9e
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
 
package org.springblade.mdm.gkw.programnode.service;
 
import com.baomidou.mybatisplus.core.metadata.IPage;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.mp.base.BizServiceImpl;
import org.springblade.core.mp.support.Condition;
import org.springblade.mdm.basesetting.machine.MachineService;
import org.springblade.mdm.basesetting.machine.entity.Machine;
import org.springblade.mdm.gkw.programnode.entity.MachineFile;
import org.springblade.mdm.gkw.programnode.mapper.MachineFileMapper;
import org.springblade.mdm.machineback.vo.MachineBackFileHandleQueryVO;
import org.springblade.mdm.machineback.vo.MachineBackFileQueryVO;
import org.springblade.mdm.machineback.vo.MachineBackFileVO;
import org.springblade.mdm.utils.FileContentUtil;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
 
/**
 * 机床文件
 *
 * @author yangys
 */
@Slf4j
@Service
@AllArgsConstructor
public class MachineFileService extends BizServiceImpl<MachineFileMapper, MachineFile> {
    private final MachineService machineService;
    /**
     * 检测文件是否存在
     * @param name 文件名
     * @param dirType 文件夹类型
     * @param machineCode 所属机床
     * @return 是否存在于库内
     */
    public boolean fileExists(String name, String dirType,String machineCode) {
        return this.lambdaQuery().eq(MachineFile::getName, name)
            .eq(MachineFile::getDirType, dirType)
            .eq(MachineFile::getMachineCode, machineCode).count()>0;
    }
 
    @Transactional(readOnly = true)
    public String getMachineFileContent(Long id) {
        MachineFile machineFile = getById(id);
        Machine machine = machineService.getByCode(machineFile.getMachineCode());
 
        String filePathStr = getBasePath(machine,machineFile.getDirType())+ File.separator+machineFile.getName();
 
        String content;
 
        Path filePath = Paths.get(filePathStr);
        if(!filePath.toFile().exists()){
            return StringUtils.EMPTY;
        }
        try (InputStream inputStream = Files.newInputStream(filePath)) {
            // 使用输入流读取文件内容
            content = FileContentUtil.getContentFromStream(inputStream);
        } catch (IOException e) {
            log.error("读取文件md5失败",e);
            return StringUtils.EMPTY;
        }
 
        return content;
    }
 
    /**
     * 获取基本路径
     * @param machine
     * @param dirType
     * @return
     */
    public static String getBasePath(Machine machine,String dirType){
        String dirPath;
        switch (dirType) {
            case MachineFile.DIR_TYPE_REC:
                dirPath = machine.getProgReceiveDir();
                break;
            case MachineFile.DIR_TYPE_SEND:
                dirPath = machine.getProgSendDir();
                break;
            case MachineFile.DIR_TYPE_TEMP:
                dirPath = machine.getProgTempDir();
                break;
            default:
                log.warn("目录类型不匹配:{}",dirType);
                return null;//不符合任何类型,直接退出
        }
        return dirPath;
    }
 
    @Transactional
    public void saveFileContent(Long id, String content) throws IOException {
        MachineFile machineFile = getById(id);
        Machine machine = machineService.getByCode(machineFile.getMachineCode());
 
        String filePathStr = getBasePath(machine,machineFile.getDirType())+ File.separator+machineFile.getName();
        Path filePath = Paths.get(filePathStr);
        String charsetName = "UTF-8";
        try (InputStream inputStream = Files.newInputStream(filePath)) {
            // 使用输入流读取文件内容
            charsetName = FileContentUtil.detectFromInputStream(inputStream);
        } catch (IOException e) {
            log.error("读取文件编码失败",e);
            throw new ServiceException("获取文件编码失败");
        }
        FileUtils.writeStringToFile(filePath.toFile(),content,charsetName);
    }
 
    /**
     * 获取文件的输入流
     * @param machineFile
     * @return
     * @throws IOException
     */
    public InputStream getInputStream(MachineFile machineFile) throws IOException {
 
        Machine machine = machineService.getByCode(machineFile.getMachineCode());
 
        String filePathStr = getBasePath(machine,machineFile.getDirType())+ File.separator+machineFile.getName();
        Path filePath = Paths.get(filePathStr);
        return Files.newInputStream(filePath);
 
    }
 
    @Transactional(readOnly = true)
    public IPage<MachineBackFileVO> machineBackFilePageQuery(MachineBackFileQueryVO query) {
        return this.baseMapper.machineBackFilePageQuery(Condition.getPage(query),query);
    }
 
    public MachineFile getExistsFile(String name, String dirType, String machineCode) {
        return this.lambdaQuery().eq(MachineFile::getName, name)
            .eq(MachineFile::getDirType, dirType)
            .eq(MachineFile::getMachineCode, machineCode).list().stream().findFirst().orElse(null);
    }
 
    /**
     * 回传程序处理 分页查询
     * @param query
     * @return
     */
    public IPage<MachineBackFileVO> handlePageQuery(MachineBackFileHandleQueryVO query) {
        IPage<MachineBackFileVO> page = this.getBaseMapper().handlePageQuery(Condition.getPage(query),query);
        return page;
    }
}