4dkankan-center-scene/src/main/java/com/fdkankan/scene/oss/OssUtil.java

package com.fdkankan.scene.oss;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.StrUtil;
import com.fdkankan.common.util.DateExtUtil;
import com.fdkankan.scene.config.FdkkLaserConfig;
import com.fdkankan.scene.config.ServiceConfig;
import com.fdkankan.scene.oss.aliyun.AliyunOssTemplate;
import com.fdkankan.scene.oss.minio.MinioOssTemplate;
import com.fdkankan.scene.util.CmdBuildUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.Base64Utils;
import sun.rmi.runtime.Log;

import java.io.File;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.FileSystemException;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.stream.Collectors;

@Slf4j
@Component
public class OssUtil {

    public static final String tempBasePath = "download/temp/";

    @Autowired
    AliyunOssTemplate aliyunOssTemplate;
    @Autowired
    MinioOssTemplate minioOssTemplate;
    @Autowired
    FdkkLaserConfig fdkkLaserConfig;
    @Autowired
    ServiceConfig serviceConfig;

    public String getPathKey(String sceneCode, String type, String fileName) {
        return fdkkLaserConfig.getDefaultFolder() + "/" + sceneCode + "/temp/" + type + "/" + fileName;
    }

    public void rmFileCmd(String prefix, String targetDir) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                minioOssTemplate.rmFileCmd(targetDir);
            } else {
                aliyunOssTemplate.rmFileCmd(targetDir);
            }
        } else {
            FileUtil.del(FdkkLaserConfig.getProfile(prefix) + File.separator + targetDir.replaceAll("/", Matcher.quoteReplacement(File.separator)));
        }

    }

    public String getHostByBucket(String bucket) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                return minioOssTemplate.calculateUrl(bucket, "");
            } else {
                return aliyunOssTemplate.calculateUrl(bucket, "");
            }
        } else {
            return serviceConfig.getBaseUrl() + "profile";
        }
    }


    public void uploadFileDirCmd(String prefix, String uploadDir, String target, Boolean isLink) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                minioOssTemplate.uploadFileDirCmd(uploadDir, target);
            } else {
                aliyunOssTemplate.uploadFileDirCmd(uploadDir, target);
            }
        } else {
            if (isLink) {
                String path = FdkkLaserConfig.getProfile(prefix) + File.separator + target;
                File folder = FileUtil.file(path);
                if (!FileUtil.exist(folder.getParent())) {
                    FileUtil.mkdir(folder.getParent());
                }
                CmdBuildUtil.MkLinkDir(folder.getAbsolutePath(), FileUtil.file(uploadDir).getAbsolutePath());
            } else {
                File[] ls = FileUtil.ls(uploadDir);
                for (File l : ls) {
                    FileUtil.copy(
                            FileUtil.file(l),
                            FileUtil.file(FdkkLaserConfig.getProfile(prefix) + File.separator + target),
                            true);
                }
            }

        }

    }


    public String uploadFile(String prefix, String pathKey, String filePath, boolean isLink) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                return minioOssTemplate.uploadFile(pathKey, filePath);
            } else {
                return aliyunOssTemplate.uploadFile(pathKey, filePath);
            }
        } else {
            if (isLink) {
                File file = FileUtil.file(filePath);
                if (!FileUtil.exist(file.getParent())) {
                    FileUtil.mkdir(file.getParent());
                }
                File pathKeyFile = FileUtil.file(FdkkLaserConfig.getProfile(prefix) + File.separator + pathKey);
                if (!FileUtil.exist(pathKeyFile.getParent())) {
                    FileUtil.mkdir(pathKeyFile.getParent());
                }
                CmdBuildUtil.MkLinkFile(pathKeyFile.getAbsolutePath(), file.getAbsolutePath());
            } else {
                FileUtil.copy(filePath,
                        FdkkLaserConfig.getProfile(prefix) + File.separator + pathKey,
                        true);
            }
            return pathKey;
        }
    }

    public String uploadFileText(String bucket, String pathKey, String text) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                return minioOssTemplate.uploadFileText(bucket, pathKey, text);
            } else {
                return aliyunOssTemplate.uploadFileText(bucket, pathKey, text);
            }
        } else {
            FileUtil.writeBytes(text.getBytes(StandardCharsets.UTF_8), FdkkLaserConfig.getProfile(bucket) + File.separator + pathKey);
            return pathKey;
        }
    }

    public String uploadFileBase64Image(String bucket, String pathKey, String base64) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                return minioOssTemplate.uploadFileBase64Image(bucket, pathKey, base64);
            } else {
                return aliyunOssTemplate.uploadFileBase64Image(bucket, pathKey, base64);
            }
        } else {
            byte[] bytes = Base64Utils.decodeFromString(base64);
            FileUtil.writeBytes(bytes, FdkkLaserConfig.getProfile(bucket) + File.separator + pathKey);
            return pathKey;
        }
    }

    public String uploadFileBytes(String bucket, String pathKey, byte[] bytes) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                return minioOssTemplate.uploadFileBytes(bucket, pathKey, bytes);
            } else {
                return aliyunOssTemplate.uploadFileBytes(bucket, pathKey, bytes);
            }
        } else {
            FileUtil.writeBytes(bytes, FdkkLaserConfig.getProfile(bucket) + File.separator + pathKey);
            return pathKey;
        }
    }

    public String uploadFileString(String bucket, String pathKey, String content) {
        FileUtil.writeUtf8String(content, FdkkLaserConfig.getProfile(bucket) + File.separator + pathKey);
        return pathKey;
    }

    public String uploadFileStream(String bucket, String pathKey, InputStream stream) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                return minioOssTemplate.uploadFileStream(bucket, pathKey, stream);
            } else {
                return aliyunOssTemplate.uploadFileStream(bucket, pathKey, stream);
            }
        } else {
            FileUtil.writeFromStream(stream, FdkkLaserConfig.getProfile(bucket) + File.separator + pathKey);
            return pathKey;
        }
    }


    public String uploadFileImage(String prefix, String pathKey, String filePath, boolean isLink) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                return minioOssTemplate.uploadFileImage(pathKey, filePath);
            } else {
                return aliyunOssTemplate.uploadFileImage(pathKey, filePath);
            }
        } else {
            if (isLink) {
                File file = FileUtil.file(filePath);
                if (!FileUtil.exist(file.getParent())) {
                    FileUtil.mkdir(file.getParent());
                }
                File pathKeyFile = FileUtil.file(FdkkLaserConfig.getProfile(prefix) + File.separator + pathKey);
                if (!FileUtil.exist(pathKeyFile.getParent())) {
                    FileUtil.mkdir(pathKeyFile.getParent());
                }
                CmdBuildUtil.MkLinkFile(pathKeyFile.getAbsolutePath(), file.getAbsolutePath());
            } else {
                FileUtil.copy(filePath,
                        FdkkLaserConfig.getProfile(prefix) + File.separator + pathKey,
                        true);
            }

            return pathKey;
        }
    }


    public File downloadFileTmp(String pathKey) {
        if (FdkkLaserConfig.isLocalization()) {
            return minioOssTemplate.downloadFileTmp(pathKey);
        } else {
            return aliyunOssTemplate.downloadFileTmp(pathKey);
        }
    }


    public File downloadFileTmp(String bucket, String pathKey) {
        if (FdkkLaserConfig.isLocalization()) {
            return minioOssTemplate.downloadFileTmp(bucket, pathKey);
        } else {
            return aliyunOssTemplate.downloadFileTmp(bucket, pathKey);
        }
    }


    public Object downloadFile(String prefix, String pathKey, String file) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                return minioOssTemplate.downloadFile(pathKey, file);
            } else {
                return aliyunOssTemplate.downloadFile(pathKey, file);
            }
        }else{
            String copyPath="";
            if (pathKey.contains(FdkkLaserConfig.getProfile(prefix))){
                copyPath=pathKey;
            }else {
                copyPath=FdkkLaserConfig.getProfile(prefix) + File.separator + pathKey;
            }
            File copy = FileUtil.copy(new File(copyPath),
                    new File(file), true);
            return copy.exists();
        }
    }


    public Boolean copyObject(String prefix, String oldPath, String newPath) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                return minioOssTemplate.copyObject(oldPath, newPath);
            } else {
                return aliyunOssTemplate.copyObject(oldPath, newPath);
            }
        }else{
            File copy = FileUtil.copy(FdkkLaserConfig.getProfile(prefix) + File.separator + oldPath,
                FdkkLaserConfig.getProfile(prefix) + File.separator + newPath, true);
            return copy.exists();
        }
    }

    public Boolean copyDir(String prefix, String oldPath, String newPath) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                return minioOssTemplate.copyObject(oldPath, newPath);
            } else {
                return aliyunOssTemplate.copyObject(oldPath, newPath);
            }
        }else{
            if(new File(FdkkLaserConfig.getProfile(prefix) + File.separator + oldPath).exists()){
                File copy = FileUtil.copyContent(new File(FdkkLaserConfig.getProfile(prefix) + File.separator + oldPath),
                        new File(FdkkLaserConfig.getProfile(prefix) + File.separator + newPath), true);
                return copy.exists();
            }
            return false;
        }
    }


    public Boolean copyObject(String bucket, String oldPath, String toBucket, String newPath) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                return minioOssTemplate.copyObject(bucket, oldPath, toBucket, newPath);
            } else {
                return aliyunOssTemplate.copyObject(bucket, oldPath, toBucket, newPath);
            }
        }else{
            File copy = FileUtil.copy(FdkkLaserConfig.getProfile(bucket) + File.separator + oldPath,
                    FdkkLaserConfig.getProfile(toBucket) + File.separator + newPath, true);
            return copy.exists();
        }
    }


    public void deleteObject(String prefix, String keyName) throws FileSystemException {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                minioOssTemplate.deleteObject(keyName);
            } else {
                aliyunOssTemplate.deleteObject(keyName);
            }
        } else {
            FileUtil.del(
                    FdkkLaserConfig.getProfile(prefix) + File.separator + keyName
            );
        }
    }

    public List<String> getFileFolder(String keyName) {
        return null;
    }


    public List<String> getFileFolder(String bucket, String keyName) {
        return null;
    }

    public boolean doesObjectExist(String prefix, String keyName) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                return minioOssTemplate.doesObjectExist(keyName);
            } else {
                return aliyunOssTemplate.doesObjectExist(keyName);
            }
        } else {
            return FileUtil.exist(FdkkLaserConfig.getProfile(prefix) + File.separator + keyName);
        }
    }


    public Object downloadFile(String bucket, String pathKey, Consumer handler) {
        return null;
    }


    public Object downloadFile(String pathKey, Consumer handler) {
        return null;
    }

    public String calculateUrl(String prefix, String keyName) {
        if (FdkkLaserConfig.isBucket()) {
            if (FdkkLaserConfig.isLocalization()) {
                return keyName;
            } else {
                return keyName;
            }
        } else {
            return FdkkLaserConfig.getProfile(prefix) + File.separator + keyName;
        }
    }

    public String getFileContent(String prefix, String pathKey) {
        if(!FileUtil.exist(FdkkLaserConfig.getProfile(prefix) + File.separator + pathKey)){
            return null;
        }
        return FileUtil.readUtf8String(FdkkLaserConfig.getProfile(prefix) + File.separator + pathKey);
    }
    public String getFileContentloc(String pathKey) {
        return FileUtil.readUtf8String(File.separator + pathKey);
    }
    public List<String> listFiles(String prefix, String pathKey) {
        return FileUtil.loopFiles(
                FdkkLaserConfig.getProfile(prefix) + File.separator + pathKey).stream().map(file->{
            return file.getAbsolutePath().replace(FdkkLaserConfig.getProfile(prefix) + File.separator, "");
        }).collect(Collectors.toList());
    }

    public void uploadMulFiles(String prefix, Map<String, String> files){
        files.keySet().stream().forEach(key -> this.uploadFile(prefix, files.get(key), key, false));
    }

    public static String getUploadTempFileKey(String prefix, String extName){
        String fileName = StrUtil.isNotEmpty(prefix) ? prefix : UUID.randomUUID().toString();
        if(StrUtil.isNotEmpty(extName)){
            fileName += "." + extName;
        }
        return tempBasePath + DateUtil.format(new Date(), DateExtUtil.dateStyle6) + "/" + fileName;
    }
}