package jnpf.fileStorage.dms;
|
|
import com.fasterxml.jackson.databind.JsonNode;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import jnpf.exception.DataException;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.http.MediaType;
|
import org.springframework.stereotype.Component;
|
import org.springframework.web.util.UriUtils;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import java.io.File;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.UncheckedIOException;
|
import java.net.URI;
|
import java.net.URLConnection;
|
import java.nio.charset.StandardCharsets;
|
import java.nio.file.Files;
|
import java.nio.file.Path;
|
import java.nio.file.StandardCopyOption;
|
import java.util.Iterator;
|
import java.util.Locale;
|
import java.util.function.Function;
|
|
@Component
|
@RequiredArgsConstructor
|
public class DmsCommonFileReader {
|
private static final String FILE_URL_PREFIX = "/api/file/Image/";
|
private static final String FILE_DOWNLOAD_PATH = "/api/file/Download";
|
private static final String ANNEX_TYPE = "annex";
|
|
private final ObjectMapper objectMapper;
|
private final DmsCommonFileStorage commonFileStorage;
|
|
public <T> T withFile(String url, Object fileJson, String documentName,
|
Function<MultipartFile, T> operation) {
|
SourceFile source = resolve(url, fileJson);
|
if (!commonFileStorage.exists(source.type, source.fileName)) {
|
throw new DataException("file-common文件不存在：" + source.fileName);
|
}
|
|
Path temporaryFile = null;
|
try {
|
temporaryFile = Files.createTempFile("dms-workflow-file-", ".tmp");
|
Path target = temporaryFile;
|
commonFileStorage.download(source.type, source.fileName, input -> {
|
try {
|
Files.copy(input, target, StandardCopyOption.REPLACE_EXISTING);
|
} catch (IOException exception) {
|
throw new UncheckedIOException(exception);
|
}
|
});
|
if (Files.size(temporaryFile) == 0L) {
|
throw new DataException("file-common文件内容为空：" + source.fileName);
|
}
|
String originalFilename = originalFilename(
|
fileJson, url, source.fileName, documentName);
|
return operation.apply(new PathMultipartFile(temporaryFile, originalFilename));
|
} catch (UncheckedIOException exception) {
|
throw new DataException("读取file-common文件失败：" + exception.getCause().getMessage());
|
} catch (IOException exception) {
|
throw new DataException("读取file-common文件失败：" + exception.getMessage());
|
} finally {
|
if (temporaryFile != null) {
|
try {
|
Files.deleteIfExists(temporaryFile);
|
} catch (IOException ignored) {
|
// Temporary-file cleanup failure must not hide the DMS result.
|
}
|
}
|
}
|
}
|
|
SourceFile parse(String value) {
|
if (value == null || value.trim().isEmpty()) {
|
throw new DataException("文件URL不能为空");
|
}
|
try {
|
URI uri = URI.create(value.trim());
|
if (uri.getScheme() != null && !"http".equalsIgnoreCase(uri.getScheme())
|
&& !"https".equalsIgnoreCase(uri.getScheme())) {
|
throw new DataException("文件URL仅支持file-common的HTTP路径");
|
}
|
String path = uri.getRawPath();
|
int prefixIndex = path == null ? -1 : path.indexOf(FILE_URL_PREFIX);
|
if (prefixIndex < 0) {
|
throw new DataException("文件URL不是file-common文件路径");
|
}
|
String remainder = path.substring(prefixIndex + FILE_URL_PREFIX.length());
|
String[] parts = remainder.split("/", -1);
|
if (parts.length != 2) {
|
throw new DataException("file-common文件URL格式不正确");
|
}
|
String type = decodeSegment(parts[0]);
|
String fileName = decodeSegment(parts[1]);
|
validateSegment(type, "文件类型");
|
validateSegment(fileName, "文件名");
|
return new SourceFile(type, fileName);
|
} catch (DataException exception) {
|
throw exception;
|
} catch (IllegalArgumentException exception) {
|
throw new DataException("file-common文件URL格式不正确");
|
}
|
}
|
|
private SourceFile resolve(String url, Object fileJson) {
|
try {
|
return parse(url);
|
} catch (DataException original) {
|
if (!isDownloadUrl(url)) {
|
throw original;
|
}
|
JsonNode root = jsonNode(fileJson);
|
String fileId = findFileId(root, url, true);
|
if (fileId == null) {
|
fileId = findFileId(root, url, false);
|
}
|
if (fileId == null) {
|
throw original;
|
}
|
validateSegment(fileId, "文件编号");
|
return new SourceFile(ANNEX_TYPE, fileId);
|
}
|
}
|
|
private boolean isDownloadUrl(String value) {
|
if (value == null || value.trim().isEmpty()) {
|
return false;
|
}
|
try {
|
URI uri = URI.create(value.trim());
|
if (uri.getScheme() != null && !"http".equalsIgnoreCase(uri.getScheme())
|
&& !"https".equalsIgnoreCase(uri.getScheme())) {
|
return false;
|
}
|
String path = uri.getRawPath();
|
return path != null && (FILE_DOWNLOAD_PATH.equals(path)
|
|| path.endsWith(FILE_DOWNLOAD_PATH));
|
} catch (IllegalArgumentException ignored) {
|
return false;
|
}
|
}
|
|
private String decodeSegment(String value) {
|
try {
|
return UriUtils.decode(value, StandardCharsets.UTF_8);
|
} catch (IllegalArgumentException exception) {
|
throw new DataException("file-common文件URL编码不正确");
|
}
|
}
|
|
private void validateSegment(String value, String label) {
|
if (value == null || value.trim().isEmpty() || value.contains("/")
|
|| value.contains("\\") || ".".equals(value) || "..".equals(value)) {
|
throw new DataException(label + "不合法");
|
}
|
}
|
|
private String originalFilename(Object fileJson, String url, String storedFilename,
|
String documentName) {
|
JsonNode root = jsonNode(fileJson);
|
String name = findName(root, url, storedFilename, true);
|
if (name == null) {
|
name = findName(root, url, storedFilename, false);
|
}
|
if (name != null && !name.trim().isEmpty()) {
|
return name.trim();
|
}
|
String extension = extension(storedFilename);
|
String fallback = documentName == null || documentName.trim().isEmpty()
|
? storedFilename : documentName.trim();
|
return extension.isEmpty()
|
|| fallback.toLowerCase(Locale.ROOT).endsWith(extension.toLowerCase(Locale.ROOT))
|
? fallback : fallback + extension;
|
}
|
|
private JsonNode jsonNode(Object fileJson) {
|
if (fileJson == null) {
|
return null;
|
}
|
try {
|
if (fileJson instanceof String) {
|
String text = ((String) fileJson).trim();
|
if (!text.startsWith("{") && !text.startsWith("[")) {
|
return null;
|
}
|
return objectMapper.readTree(text);
|
}
|
return objectMapper.valueToTree(fileJson);
|
} catch (RuntimeException | IOException ignored) {
|
return null;
|
}
|
}
|
|
private String findName(JsonNode node, String url, String storedFilename,
|
boolean requireMatch) {
|
if (node == null) {
|
return null;
|
}
|
if (node.isArray()) {
|
Iterator<JsonNode> items = node.elements();
|
while (items.hasNext()) {
|
String name = findName(items.next(), url, storedFilename, requireMatch);
|
if (name != null) {
|
return name;
|
}
|
}
|
return null;
|
}
|
if (!node.isObject()) {
|
return null;
|
}
|
boolean matches = textEquals(node.get("url"), url)
|
|| textEquals(node.get("fileId"), storedFilename);
|
if (!requireMatch || matches) {
|
String name = text(node.get("name"));
|
if (name == null) {
|
name = text(node.get("fileName"));
|
}
|
if (name != null) {
|
return name;
|
}
|
}
|
Iterator<JsonNode> children = node.elements();
|
while (children.hasNext()) {
|
String name = findName(children.next(), url, storedFilename, requireMatch);
|
if (name != null) {
|
return name;
|
}
|
}
|
return null;
|
}
|
|
private String findFileId(JsonNode node, String url, boolean requireMatch) {
|
if (node == null) {
|
return null;
|
}
|
if (node.isArray()) {
|
Iterator<JsonNode> items = node.elements();
|
while (items.hasNext()) {
|
String fileId = findFileId(items.next(), url, requireMatch);
|
if (fileId != null) {
|
return fileId;
|
}
|
}
|
return null;
|
}
|
if (!node.isObject()) {
|
return null;
|
}
|
boolean matches = textEquals(node.get("url"), url);
|
if (!requireMatch || matches) {
|
String fileId = text(node.get("fileId"));
|
if (fileId != null) {
|
return fileId;
|
}
|
}
|
Iterator<JsonNode> children = node.elements();
|
while (children.hasNext()) {
|
String fileId = findFileId(children.next(), url, requireMatch);
|
if (fileId != null) {
|
return fileId;
|
}
|
}
|
return null;
|
}
|
|
private boolean textEquals(JsonNode node, String expected) {
|
return node != null && node.isTextual() && node.asText().equals(expected);
|
}
|
|
private String text(JsonNode node) {
|
return node == null || !node.isTextual() || node.asText().trim().isEmpty()
|
? null : node.asText();
|
}
|
|
private String extension(String filename) {
|
int index = filename.lastIndexOf('.');
|
return index <= 0 || index == filename.length() - 1 ? "" : filename.substring(index);
|
}
|
|
static final class SourceFile {
|
private final String type;
|
private final String fileName;
|
|
private SourceFile(String type, String fileName) {
|
this.type = type;
|
this.fileName = fileName;
|
}
|
|
String getType() {
|
return type;
|
}
|
|
String getFileName() {
|
return fileName;
|
}
|
}
|
|
private static final class PathMultipartFile implements MultipartFile {
|
private final Path path;
|
private final String originalFilename;
|
|
private PathMultipartFile(Path path, String originalFilename) {
|
this.path = path;
|
this.originalFilename = originalFilename;
|
}
|
|
@Override
|
public String getName() {
|
return "file";
|
}
|
|
@Override
|
public String getOriginalFilename() {
|
return originalFilename;
|
}
|
|
@Override
|
public String getContentType() {
|
String guessed = URLConnection.guessContentTypeFromName(originalFilename);
|
return guessed == null ? MediaType.APPLICATION_OCTET_STREAM_VALUE : guessed;
|
}
|
|
@Override
|
public boolean isEmpty() {
|
return getSize() == 0L;
|
}
|
|
@Override
|
public long getSize() {
|
try {
|
return Files.size(path);
|
} catch (IOException exception) {
|
throw new UncheckedIOException(exception);
|
}
|
}
|
|
@Override
|
public byte[] getBytes() throws IOException {
|
return Files.readAllBytes(path);
|
}
|
|
@Override
|
public InputStream getInputStream() throws IOException {
|
return Files.newInputStream(path);
|
}
|
|
@Override
|
public void transferTo(File destination) throws IOException {
|
Files.copy(path, destination.toPath(), StandardCopyOption.REPLACE_EXISTING);
|
}
|
}
|
}
|
