Macbook
296 lines
12 KiB
Java
296 lines
12 KiB
Java
package com.goldenchart.service;
|
|
|
|
import com.goldenchart.dto.VerificationIssueImageDto;
|
|
import com.goldenchart.entity.GcVerificationIssueImage;
|
|
import com.goldenchart.repository.GcVerificationIssueImageRepository;
|
|
import com.goldenchart.repository.GcVerificationIssueRepository;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.springframework.beans.factory.annotation.Value;
|
|
import org.springframework.core.io.Resource;
|
|
import org.springframework.core.io.UrlResource;
|
|
import org.springframework.stereotype.Service;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
import org.springframework.web.multipart.MultipartFile;
|
|
|
|
import java.io.IOException;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.util.List;
|
|
import java.util.Optional;
|
|
import java.util.Set;
|
|
import java.util.UUID;
|
|
|
|
@Service
|
|
@Slf4j
|
|
public class VerificationIssueImageService {
|
|
|
|
private static final Set<String> ALLOWED_IMAGE_TYPES = Set.of(
|
|
"image/jpeg", "image/png", "image/gif", "image/webp", "image/bmp"
|
|
);
|
|
|
|
private static final Set<String> ALLOWED_DOCUMENT_TYPES = Set.of(
|
|
"application/zip",
|
|
"application/x-zip-compressed",
|
|
"application/x-hwp",
|
|
"application/haansoft-hwp",
|
|
"application/vnd.hancom.hwp",
|
|
"application/hwp+zip",
|
|
"application/vnd.hancom.hwpx",
|
|
"application/x-hwpx"
|
|
);
|
|
|
|
private final GcVerificationIssueImageRepository imageRepository;
|
|
private final GcVerificationIssueRepository issueRepository;
|
|
private final Path uploadRoot;
|
|
private final long maxFileSizeBytes;
|
|
private final int maxImagesPerIssue;
|
|
|
|
public VerificationIssueImageService(
|
|
GcVerificationIssueImageRepository imageRepository,
|
|
GcVerificationIssueRepository issueRepository,
|
|
@Value("${goldenchart.verification.upload-dir:data/verification-images}") String uploadDir,
|
|
@Value("${goldenchart.verification.max-image-size-mb:5}") int maxImageSizeMb,
|
|
@Value("${goldenchart.verification.max-images-per-issue:30}") int maxImagesPerIssue) throws IOException {
|
|
this.imageRepository = imageRepository;
|
|
this.issueRepository = issueRepository;
|
|
this.uploadRoot = Paths.get(uploadDir).toAbsolutePath().normalize();
|
|
this.maxFileSizeBytes = maxImageSizeMb * 1024L * 1024L;
|
|
this.maxImagesPerIssue = maxImagesPerIssue;
|
|
Files.createDirectories(this.uploadRoot);
|
|
}
|
|
|
|
public List<VerificationIssueImageDto> listByIssue(Long issueId) {
|
|
return imageRepository.findByIssueIdOrderBySortOrderAscCreatedAtAsc(issueId).stream()
|
|
.map(this::toDto)
|
|
.toList();
|
|
}
|
|
|
|
@Transactional
|
|
public List<VerificationIssueImageDto> upload(Long issueId, List<MultipartFile> files) throws IOException {
|
|
if (!issueRepository.existsById(issueId)) {
|
|
throw new IllegalArgumentException("issue not found: " + issueId);
|
|
}
|
|
if (files == null || files.isEmpty()) {
|
|
throw new IllegalArgumentException("no files");
|
|
}
|
|
|
|
long current = imageRepository.findByIssueIdOrderBySortOrderAscCreatedAtAsc(issueId).size();
|
|
if (current + files.size() > maxImagesPerIssue) {
|
|
throw new IllegalArgumentException("max images exceeded: " + maxImagesPerIssue);
|
|
}
|
|
|
|
Path issueDir = uploadRoot.resolve("issue_" + issueId);
|
|
Files.createDirectories(issueDir);
|
|
|
|
int sort = (int) current;
|
|
List<VerificationIssueImageDto> saved = new java.util.ArrayList<>();
|
|
|
|
for (MultipartFile file : files) {
|
|
if (file == null || file.isEmpty()) continue;
|
|
|
|
byte[] data = file.getBytes();
|
|
String contentType = resolveContentType(file, data);
|
|
validateFile(data.length, contentType);
|
|
|
|
String original = sanitizeFileName(file.getOriginalFilename());
|
|
String storedName = UUID.randomUUID() + "_" + original;
|
|
Path target = issueDir.resolve(storedName);
|
|
Files.write(target, data);
|
|
|
|
String relative = uploadRoot.relativize(target).toString().replace('\\', '/');
|
|
GcVerificationIssueImage entity = GcVerificationIssueImage.builder()
|
|
.issueId(issueId)
|
|
.fileName(original)
|
|
.contentType(contentType)
|
|
.storagePath(relative)
|
|
.fileSize((long) data.length)
|
|
.sortOrder(sort++)
|
|
.build();
|
|
saved.add(toDto(imageRepository.save(entity)));
|
|
}
|
|
|
|
if (saved.isEmpty()) {
|
|
throw new IllegalArgumentException("no valid attachment files");
|
|
}
|
|
return saved;
|
|
}
|
|
|
|
public Optional<Resource> loadFile(Long issueId, Long imageId) {
|
|
return imageRepository.findById(imageId)
|
|
.filter(img -> issueId.equals(img.getIssueId()))
|
|
.map(img -> {
|
|
try {
|
|
Path path = uploadRoot.resolve(img.getStoragePath()).normalize();
|
|
if (!path.startsWith(uploadRoot) || !Files.exists(path)) {
|
|
return null;
|
|
}
|
|
Resource resource = new UrlResource(path.toUri());
|
|
return resource.exists() && resource.isReadable() ? resource : null;
|
|
} catch (Exception e) {
|
|
log.warn("image load failed id={}: {}", imageId, e.getMessage());
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
|
|
public Optional<String> contentType(Long issueId, Long imageId) {
|
|
return imageRepository.findById(imageId)
|
|
.filter(img -> issueId.equals(img.getIssueId()))
|
|
.map(GcVerificationIssueImage::getContentType);
|
|
}
|
|
|
|
@Transactional
|
|
public boolean delete(Long issueId, Long imageId) throws IOException {
|
|
Optional<GcVerificationIssueImage> opt = imageRepository.findById(imageId)
|
|
.filter(img -> issueId.equals(img.getIssueId()));
|
|
if (opt.isEmpty()) return false;
|
|
GcVerificationIssueImage img = opt.get();
|
|
deletePhysicalFile(img.getStoragePath());
|
|
imageRepository.delete(img);
|
|
return true;
|
|
}
|
|
|
|
@Transactional
|
|
public void deleteAllForIssue(Long issueId) throws IOException {
|
|
List<GcVerificationIssueImage> images =
|
|
imageRepository.findByIssueIdOrderBySortOrderAscCreatedAtAsc(issueId);
|
|
for (GcVerificationIssueImage img : images) {
|
|
deletePhysicalFile(img.getStoragePath());
|
|
}
|
|
imageRepository.deleteByIssueId(issueId);
|
|
Path issueDir = uploadRoot.resolve("issue_" + issueId);
|
|
if (Files.isDirectory(issueDir)) {
|
|
try { Files.deleteIfExists(issueDir); } catch (IOException ignored) { /* ok */ }
|
|
}
|
|
}
|
|
|
|
private void validateFile(long sizeBytes, String contentType) {
|
|
if (contentType == null || !isAllowedContentType(contentType)) {
|
|
throw new IllegalArgumentException("unsupported file type");
|
|
}
|
|
if (sizeBytes > maxFileSizeBytes) {
|
|
throw new IllegalArgumentException("file too large");
|
|
}
|
|
}
|
|
|
|
private static boolean isAllowedContentType(String contentType) {
|
|
return ALLOWED_IMAGE_TYPES.contains(contentType)
|
|
|| ALLOWED_DOCUMENT_TYPES.contains(contentType);
|
|
}
|
|
|
|
private String resolveContentType(MultipartFile file, byte[] data) {
|
|
String type = file.getContentType();
|
|
if (type != null && !type.isBlank()) {
|
|
type = type.split(";")[0].trim().toLowerCase();
|
|
if ("image/jpg".equals(type) || "image/pjpeg".equals(type)) {
|
|
return "image/jpeg";
|
|
}
|
|
if ("image/x-png".equals(type)) {
|
|
return "image/png";
|
|
}
|
|
if (ALLOWED_IMAGE_TYPES.contains(type)) {
|
|
return type;
|
|
}
|
|
if (ALLOWED_DOCUMENT_TYPES.contains(type)) {
|
|
return type;
|
|
}
|
|
// application/octet-stream 등 — 매직 바이트·확장자로 판별
|
|
if ("application/octet-stream".equals(type) || type.startsWith("image/")) {
|
|
String sniffed = sniffFileType(data, file.getOriginalFilename());
|
|
if (sniffed != null) return sniffed;
|
|
}
|
|
}
|
|
|
|
String name = file.getOriginalFilename();
|
|
if (name != null) {
|
|
String lower = name.toLowerCase();
|
|
if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
|
|
if (lower.endsWith(".png")) return "image/png";
|
|
if (lower.endsWith(".gif")) return "image/gif";
|
|
if (lower.endsWith(".webp")) return "image/webp";
|
|
if (lower.endsWith(".bmp")) return "image/bmp";
|
|
if (lower.endsWith(".zip")) return "application/zip";
|
|
if (lower.endsWith(".hwp")) return "application/x-hwp";
|
|
if (lower.endsWith(".hwpx")) return "application/vnd.hancom.hwpx";
|
|
}
|
|
|
|
return sniffFileType(data, file.getOriginalFilename());
|
|
}
|
|
|
|
private String sniffFileType(byte[] header, String fileName) {
|
|
String image = sniffImageType(header);
|
|
if (image != null) return image;
|
|
|
|
if (header != null && header.length >= 4
|
|
&& header[0] == 0x50 && header[1] == 0x4B
|
|
&& (header[2] == 0x03 || header[2] == 0x05 || header[2] == 0x07)) {
|
|
if (fileName != null && fileName.toLowerCase().endsWith(".hwpx")) {
|
|
return "application/vnd.hancom.hwpx";
|
|
}
|
|
return "application/zip";
|
|
}
|
|
|
|
if (header != null && header.length >= 8
|
|
&& header[0] == (byte) 0xD0 && header[1] == (byte) 0xCF
|
|
&& header[2] == 0x11 && header[3] == (byte) 0xE0) {
|
|
if (fileName != null && fileName.toLowerCase().endsWith(".hwp")) {
|
|
return "application/x-hwp";
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private String sniffImageType(byte[] header) {
|
|
if (header == null) return null;
|
|
if (header.length >= 8
|
|
&& header[0] == (byte) 0x89 && header[1] == 0x50
|
|
&& header[2] == 0x4E && header[3] == 0x47) {
|
|
return "image/png";
|
|
}
|
|
if (header.length >= 3
|
|
&& header[0] == (byte) 0xFF && header[1] == (byte) 0xD8 && header[2] == (byte) 0xFF) {
|
|
return "image/jpeg";
|
|
}
|
|
if (header.length >= 6
|
|
&& header[0] == 0x47 && header[1] == 0x49 && header[2] == 0x46) {
|
|
return "image/gif";
|
|
}
|
|
if (header.length >= 12
|
|
&& header[0] == 0x52 && header[1] == 0x49 && header[2] == 0x46 && header[3] == 0x46
|
|
&& header[8] == 0x57 && header[9] == 0x45 && header[10] == 0x42 && header[11] == 0x50) {
|
|
return "image/webp";
|
|
}
|
|
if (header.length >= 2 && header[0] == 0x42 && header[1] == 0x4D) {
|
|
return "image/bmp";
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void deletePhysicalFile(String storagePath) throws IOException {
|
|
Path path = uploadRoot.resolve(storagePath).normalize();
|
|
if (path.startsWith(uploadRoot)) {
|
|
Files.deleteIfExists(path);
|
|
}
|
|
}
|
|
|
|
private String sanitizeFileName(String name) {
|
|
if (name == null || name.isBlank()) return "attachment.bin";
|
|
String base = Paths.get(name).getFileName().toString();
|
|
return base.replaceAll("[^a-zA-Z0-9._\\-가-힣]", "_");
|
|
}
|
|
|
|
private VerificationIssueImageDto toDto(GcVerificationIssueImage e) {
|
|
return VerificationIssueImageDto.builder()
|
|
.id(e.getId())
|
|
.issueId(e.getIssueId())
|
|
.fileName(e.getFileName())
|
|
.contentType(e.getContentType())
|
|
.fileSize(e.getFileSize())
|
|
.sortOrder(e.getSortOrder())
|
|
.url("/verification-issues/" + e.getIssueId() + "/images/" + e.getId() + "/file")
|
|
.createdAt(e.getCreatedAt())
|
|
.build();
|
|
}
|
|
}
|