api/src/main/java/com/xjrsoft/config/FileCheckRuleConfig.java

package com.xjrsoft.config;

import lombok.Getter;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

/**
 * 文件校验规则配置（优化版）
 */
@Getter
public final class FileCheckRuleConfig {
    /* ========== 基础类型规则 ========== */
    /**
     * 图片规则（严格模式）
     */
    public static final FileCheckRuleConfig IMAGE = builder()
            .withExtensions("jpg", "jpeg", "png", "gif", "webp", "bmp","svg")
            .withMimeTypes(
                    "image/jpeg",
                    "image/png",
                    "image/gif",
                    "image/webp",
                    "image/bmp",
                    "image/svg+xml",
                    "image/svg"
            )
            .build();
    /**
     * 视频规则
     */
    public static final FileCheckRuleConfig VIDEO = builder()
            .withExtensions("mp4", "mov", "avi", "wmv", "flv", "mkv")
            .withMimeTypes(
                    "video/mp4",
                    "video/quicktime",
                    "video/x-msvideo",
                    "video/x-ms-wmv",
                    "video/x-flv",
                    "video/x-matroska"
            )
            .build();
    /**
     * 音频规则
     */
    public static final FileCheckRuleConfig AUDIO = builder()
            .withExtensions("mp3", "wav", "aac", "flac", "ogg", "m4a")
            .withMimeTypes(
                    "audio/mpeg",
                    "audio/wav",
                    "audio/aac",
                    "audio/flac",
                    "audio/ogg",
                    "audio/x-m4a"
            )
            .build();
    /**
     * 文档规则
     */
    public static final FileCheckRuleConfig DOCUMENT = builder()
            .withExtensions(
                    "pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "txt",
                    // WPS 文件扩展名
                    "wps", "et", "dps", "wpt", "ett", "dpt", "vsd", "vsdx",
                    "ofd","xml"
            )
            .withMimeTypes(
                    "application/pdf",
                    "application/msword",
                    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
                    "application/vnd.ms-excel",
                    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                    "application/vnd.ms-powerpoint",
                    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
                    "text/plain",
                    // WPS MIME 类型 - 补充更多可能的类型
                    "application/vnd.ms-works",
                    "application/wps-office.wps",
                    "application/wps-office.et",
                    "application/wps-office.dps",
                    "application/wps-office.wpt",
                    "application/wps-office.ett",
                    "application/wps-office.dpt",
                    "application/kswps",
                    "application/kset",
                    "application/ksdps",
                    "application/x-wps",
                    "application/x-et",
                    "application/x-dps",
                    "application/vnd.wps-office.wps",
                    "application/vnd.wps-office.et",
                    "application/vnd.wps-office.dps",
                    "application/wpsofficevideo/x-matroska",

                    // OFD MIME 类型
                    "application/ofd",
                    "application/x-ofd",

                    "application/xml",
                    "text/xml",
                    "application/xhtml+xml",

                    // 其他可能的 MIME 类型
                    "application/octet-stream",
                    "application/x-msdownload"
            )
            .build();

    /**
     * 压缩包规则
     */
    public static final FileCheckRuleConfig ARCHIVE = builder()
            .withExtensions(
                    "zip", "rar", "7z", "tar", "gz", "bz2", "xz",
                    "jar", "war", "ear", // Java 归档文件
                    "cab", // Windows 归档文件
                    "iso", // 光盘映像文件
                    "dmg", // macOS 磁盘映像
                    "apk", // Android 应用包
                    "msi"  // Windows 安装包
            )
            .withMimeTypes(
                    "application/zip",
                    "application/x-rar-compressed",
                    "application/x-7z-compressed",
                    "application/x-tar",
                    "application/gzip",
                    "application/x-bzip2",
                    "application/x-xz",
                    "application/java-archive",
                    "application/vnd.ms-cab-compressed",
                    "application/x-iso9660-image",
                    "application/x-apple-diskimage",
                    "application/vnd.android.package-archive",
                    "application/x-msdownload",
                    "application/x-zip-compressed",
                    "application/x-compressed"
            )
            .build();
//    /**
//     * 特殊文件类型规则
//     */
//    public static final FileCheckRuleConfig SPECIAL = builder()
//            .withExtensions("mp4", "mov", "avi", "wmv", "flv", "mkv")
//            .withMimeTypes(
//                    "video/mp4",
//                    "video/quicktime",
//                    "video/x-msvideo",
//                    "video/x-ms-wmv",
//                    "video/x-flv",
//                    "video/x-matroska"
//            )
//            .build();
    /* ========== 组合类型规则 ========== */
    /**
     * 媒体规则（图片+视频）
     */
    public static final FileCheckRuleConfig MEDIA = combine(IMAGE, VIDEO);
    /**
     * 图片和文档规则
     */
    public static final FileCheckRuleConfig IMAGE_AND_DOCUMENT = combine(IMAGE, DOCUMENT);
    /**
     * 所有类型规则
     */
    public static final FileCheckRuleConfig ALL = combine(IMAGE, VIDEO, AUDIO, DOCUMENT, ARCHIVE);

    private final Set<String> allowedExtensions;
    private final Set<String> allowedMimeTypes;

    private FileCheckRuleConfig(Builder builder) {
        this.allowedExtensions = Collections.unmodifiableSet(builder.extensions);
        this.allowedMimeTypes = Collections.unmodifiableSet(builder.mimeTypes);
    }

    /**
     * 创建新的构建器
     */
    public static Builder builder() {
        return new Builder();
    }

    /**
     * 合并多个规则配置
     */
    public static FileCheckRuleConfig combine(FileCheckRuleConfig... configs) {
        Builder builder = builder();
        for (FileCheckRuleConfig config : configs) {
            builder.extensions.addAll(config.allowedExtensions);
            builder.mimeTypes.addAll(config.allowedMimeTypes);
        }
        return builder.build();
    }

    /**
     * 构建器类
     */
    public static final class Builder {
        private final Set<String> extensions = new HashSet<>();
        private final Set<String> mimeTypes = new HashSet<>();

        private Builder() {
        }

        public Builder withExtensions(String... extensions) {
            this.extensions.addAll(Arrays.asList(extensions));
            return this;
        }

        public Builder withMimeTypes(String... mimeTypes) {
            this.mimeTypes.addAll(Arrays.asList(mimeTypes));
            return this;
        }

        public Builder addExtension(String extension) {
            this.extensions.add(extension);
            return this;
        }

        public Builder addMimeType(String mimeType) {
            this.mimeTypes.add(mimeType);
            return this;
        }

        public Builder from(FileCheckRuleConfig config) {
            this.extensions.addAll(config.allowedExtensions);
            this.mimeTypes.addAll(config.allowedMimeTypes);
            return this;
        }

        public FileCheckRuleConfig build() {
            return new FileCheckRuleConfig(this);
        }
    }
}