caimei-zplm-admin-api/src/main/java/com/caimei/service/data/impl/DatabaseServiceImpl.java

package com.caimei.service.data.impl;

import com.alibaba.fastjson.JSONObject;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.profile.DefaultProfile;
import com.aliyuncs.utils.StringUtils;
import com.caimei.annotation.CurrentUser;
import com.caimei.mapper.cmMapper.FileMapper;
import com.caimei.model.ResponseJson;
import com.caimei.model.po.SysUser;
import com.caimei.model.vo.FileTreeVo;
import com.caimei.service.async.AsyncService;
import com.caimei.service.data.DatabaseService;
import com.caimei.utils.FileZipUtils;
import com.caimei.utils.OSSUtils;
import com.sun.org.apache.regexp.internal.RE;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * @author zzj
 */
@Slf4j
@Service
public class DatabaseServiceImpl implements DatabaseService {

    @Resource
    private FileMapper fileMapper;

    @Value("${spring.profiles.active}")
    private String active;

    @Resource
    private AsyncService asyncService;

    @Override
    public ResponseJson<List<FileTreeVo>> getFileById(Integer fileId, Integer authUserId) {
        List<FileTreeVo> fileTree = fileMapper.findFileTree(fileId, authUserId, null);
        return ResponseJson.success(fileTree);
    }

    @Override
    public ResponseJson createPackage(Integer authUserId, Integer fileId, String packageName) {
        fileMapper.creatPackage(authUserId, fileId, packageName);
        return ResponseJson.success();
    }

    @Override
    public ResponseJson downLoadZip(Integer fileId, String packageName, Integer authUserId, HttpServletResponse response) {
        //有package则在服务器固定路径new file.mkdir
        UUID uuid = UUID.randomUUID();
        String filePath = "/mnt/newdatadrive/data/runtime/jar-instance/zplma/tempFile/" + uuid + "/";
        String zipPath = filePath + packageName;
        String delPath = filePath;
        filePath = zipPath;
        if ("dev".equals(active)) {
            filePath = "D:\\caimei-workSpace\\file\\" + uuid + "\\";
            zipPath = filePath + packageName;
            delPath = filePath;
            filePath = filePath + packageName + "\\";
        }
        boolean mkdirs = new File(filePath).mkdirs();
        Assert.isTrue(mkdirs, "文件夹创建失败");

        String param = fileId + "," + authUserId;
        recursion(param, filePath);
        //压缩
        FileZipUtils.compress(zipPath, "", true);
        String s = zipPath + ".zip";
        String fileName = packageName + ".zip";
        File file = new File(s);
        try {
            if (file.exists()) {
                FileInputStream fileInputStream = new FileInputStream(file);
                ServletOutputStream outputStream = response.getOutputStream();
                // 设置下载文件的mineType，告诉浏览器下载文件类型
                //            int i = fileName.lastIndexOf(".");
                //            String substring = fileName.substring(i + 1, filePath.length());
                response.setContentType("application/zip");
                // 设置一个响应头，无论是否被浏览器解析，都下载
                response.setHeader("Content-disposition", "attachment; filename=" + fileName);
                byte[] bytes = new byte[1024];
                int len;
                while ((len = fileInputStream.read(bytes)) != -1) {
                    outputStream.write(bytes, 0, len);
                }
                fileInputStream.close();
                outputStream.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        FileZipUtils.deleteFile(new File(delPath));
        return null;
    }

    @Override
    public ResponseJson insertNewFile(String fileName, String filePath, String previewUrl, Integer parentId, String fileType) {
        FileTreeVo fileTreeVo = new FileTreeVo();
        fileTreeVo.setFileName(fileName);
        fileTreeVo.setOssName(filePath);
        fileTreeVo.setOssUrl(previewUrl);
        fileTreeVo.setParentId(parentId);
        fileTreeVo.setFileType(fileType);
        fileMapper.insertNewFile(fileTreeVo);
        return ResponseJson.success();
    }

    @Override
    public ResponseJson<HashMap<String, String>> ossTokenGet() {
        return ResponseJson.success(OSSUtils.getToken());
    }

    @Override
    public ResponseJson getOssUploadResult(Integer authUserId, String fileName, String ossName, String ossUrl, String fileSize, Integer parentId, String mime) {
        FileTreeVo fileTreeVo = new FileTreeVo();
        fileTreeVo.setFileName(fileName);
        fileTreeVo.setOssName(ossName);
        fileTreeVo.setOssUrl(ossUrl);
        fileTreeVo.setParentId(parentId);
        if (fileName.contains(".")) {
            fileTreeVo.setFileType(fileName.substring(fileName.lastIndexOf(".") + 1));
        }
        fileTreeVo.setFileSize(fileSize);
        fileTreeVo.setPackageType(1);
        fileTreeVo.setAuthUserId(authUserId);
        fileTreeVo.setMime(mime);
        fileMapper.insertNewFile(fileTreeVo);
        if (mime.contains("image")) {
            //图片保存缩略图
            asyncService.insertScreenshot(fileTreeVo);
        }
        return ResponseJson.success();
    }

    @Override
    public ResponseJson updatePackage(Integer fileId, String packageName, Integer packageType) {
        FileTreeVo fileTreeVo = new FileTreeVo();
        fileTreeVo.setId(fileId);
        fileTreeVo.setPackageType(packageType);
        fileTreeVo.setFileName(packageName);
        fileMapper.updateFile(fileTreeVo);
        return ResponseJson.success();
    }

    @Override
    public ResponseJson movePackage(String fileId, Integer parentId) {
        if (fileId.contains(",")) {
            String[] split = fileId.split(",");
            for (String s : split) {
                FileTreeVo fileTreeVo = new FileTreeVo();
                fileTreeVo.setId(Integer.valueOf(s));
                fileTreeVo.setParentId(parentId);
                fileMapper.updateFile(fileTreeVo);
            }
        } else {
            FileTreeVo fileTreeVo = new FileTreeVo();
            fileTreeVo.setId(Integer.valueOf(fileId));
            fileTreeVo.setParentId(parentId);
            fileMapper.updateFile(fileTreeVo);
        }
        return ResponseJson.success();
    }

    @Override
    public ResponseJson deleteFiles(String fileId) {
        if (fileId.contains(",")) {
            String[] split = fileId.split(",");
            for (String s : split) {
                deleteFilesById(Integer.valueOf(s));
            }
        } else {
            deleteFilesById(Integer.valueOf(fileId));
        }
        return ResponseJson.success();
    }

    private void deleteFilesById(Integer fileId) {
        FileTreeVo file = fileMapper.findFile(fileId, null, null);
        if (0 == file.getPackageType()) {
            //文件夹
            List<FileTreeVo> fileTree = fileMapper.findFileTree(fileId, null, null);
            fileTree.forEach(f -> {
                deleteFilesById(f.getId());
            });
            fileMapper.deleteFileTreeById(fileId);
        } else {
            //单文件
            OSSUtils.deleteSingleFile(file.getOssName());
            fileMapper.deleteFileTreeById(fileId);
        }
    }

    @Override
    public ResponseJson<FileTreeVo> getCrumbs(Integer fileId, Integer authUserId) {
        if (fileId > 0) {
            FileTreeVo file = fileMapper.findFile(fileId, authUserId, null);
            FileTreeVo crumbsParent = getCrumbsParent(file, authUserId);
            return ResponseJson.success(crumbsParent);
        } else {
            return ResponseJson.success();
        }
    }

    @Override
    public ResponseJson<FileTreeVo> getPackageTree(Integer authUserId) {
        FileTreeVo fileTreeVo = new FileTreeVo();
        fileTreeVo.setId(0);
        fileTreeVo.setAuthUserId(authUserId);
        fileTreeVo.setPackageType(0);
        PackageTree(fileTreeVo);
        return ResponseJson.success(fileTreeVo);
    }

    @Override
    public ResponseJson downLoadChoseZip(String fileId, Integer authUserId, HttpServletResponse response) {
        if (fileId.contains(",")) {
            String[] split = fileId.split(",");
            ArrayList<FileTreeVo> fileTreeVos = new ArrayList<>();
            for (String s : split) {
                FileTreeVo file = fileMapper.findFile(Integer.valueOf(s), authUserId, null);
                fileTreeVos.add(file);
            }
            //有package则在服务器固定路径new file.mkdir
            UUID uuid = UUID.randomUUID();
            String zipPath = "/mnt/newdatadrive/data/runtime/jar-instance/zplma/tempFile/" + uuid;
            String filePath = zipPath;
            if ("dev".equals(active)) {
                zipPath = "D:\\caimei-workSpace\\file\\" + uuid;
                filePath = zipPath;
            }
            boolean mkdirs = new File(filePath).mkdirs();
            Assert.isTrue(mkdirs, "文件夹创建失败");

            for (FileTreeVo fileTreeVo : fileTreeVos) {
                if (1 == fileTreeVo.getPackageType()) {
                    //普通文件直接下载到临时文件夹uuid下
                    String fileName = "";
                    if ("dev".equals(active)) {
                        fileName = zipPath + "\\" + fileTreeVo.getFileName();
                    } else {
                        fileName = zipPath + "/" + fileTreeVo.getFileName();
                    }
                    OSSUtils.downFileByFilePath("authFile/", fileTreeVo.getOssName(), fileName);
                } else {
                    //文件夹在uuid文件夹下创建自己包名的文件夹
                    String param = fileTreeVo.getId() + "," + authUserId;
                    String myPath = "";
                    myPath = filePath + "/" + fileTreeVo.getFileName();
                    if ("dev".equals(active)) {
                        myPath = filePath + "\\" + fileTreeVo.getFileName();
                    }
                    boolean dirs = new File(myPath).mkdirs();
                    Assert.isTrue(dirs, "文件夹创建失败");
                    recursion(param, myPath);
                }
            }

            //压缩
            FileZipUtils.compress(zipPath, "", true);
            String s = zipPath + ".zip";
            String fileName = uuid + ".zip";
            File file = new File(s);
            try {
                if (file.exists()) {
                    FileInputStream fileInputStream = new FileInputStream(file);
                    ServletOutputStream outputStream = response.getOutputStream();
                    // 设置下载文件的mineType，告诉浏览器下载文件类型
//                                int i = fileName.lastIndexOf(".");
//                                String substring = fileName.substring(i + 1, filePath.length());
                    response.setContentType("application/zip");
                    // 设置一个响应头，无论是否被浏览器解析，都下载
                    response.setHeader("Content-disposition", "attachment; filename=" + fileName);
                    byte[] bytes = new byte[1024];
                    int len;
                    while ((len = fileInputStream.read(bytes)) != -1) {
                        outputStream.write(bytes, 0, len);
                    }
                    fileInputStream.close();
                    outputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            file.delete();
            FileZipUtils.deleteFile(new File(zipPath));
        }
        return null;
    }

    @Override
    public ResponseJson<FileTreeVo> getFileDetail(Integer fileId, Integer authUserId) {
        FileTreeVo file = fileMapper.findFile(fileId, authUserId, null);
        return ResponseJson.success(file);
    }

    private void PackageTree(FileTreeVo fileTreeVo) {
        if (null == fileTreeVo) {
            return;
        }
        List<FileTreeVo> fileList = fileMapper.findFileTree(fileTreeVo.getId(), fileTreeVo.getAuthUserId(), fileTreeVo.getPackageType());
        if (null != fileList && fileList.size() > 0) {
            fileTreeVo.setChildList(fileList);
        }
        fileList.forEach(this::PackageTree);
    }


    private FileTreeVo getCrumbsParent(FileTreeVo file, Integer authUserId) {
        if (null == file || 0 == file.getParentId()) {
            return file;
        }
        FileTreeVo fil = fileMapper.findFile(file.getParentId(), authUserId, null);
        fil.setChildNode(file);
        return getCrumbsParent(fil, authUserId);
    }

    private void recursion(String param, String filePath) {
        String[] split = param.split(",");
        Integer fileId = Integer.valueOf(split[0]);
        Integer authUserId = Integer.valueOf(split[1]);
        //1.如果当前目录存在普通文件，下载当前目录下的文件到文件夹中
        String finalFilePath = filePath;
        List<FileTreeVo> commonFile = existsPackageOrCommonFile(fileId, authUserId, 2);
        if (null != commonFile && commonFile.size() > 0) {
            commonFile.forEach(c -> {
                String fileName = "";
                if ("dev".equals(active)) {
                    fileName = finalFilePath + "\\" + c.getFileName();
                } else {
                    fileName = finalFilePath + "/" + c.getFileName();
                }
                OSSUtils.downFileByFilePath("authFile/", c.getOssName(), fileName);
            });
        }
        //2.如果存在文件夹循环文件夹，递归本方法
        List<FileTreeVo> packages = existsPackageOrCommonFile(fileId, authUserId, 1);
        HashMap<String, String> sonPackage = new HashMap<String, String>();
        if (null != packages && packages.size() > 0) {
            for (FileTreeVo aPackage : packages) {
                if ("dev".equals(active)) {
                    filePath = finalFilePath + "\\" + aPackage.getFileName();
                } else {
                    filePath = finalFilePath + "/" + aPackage.getFileName();
                }
                File fil = new File(filePath.toString());
                fil.mkdirs();
                String params = aPackage.getId() + "," + authUserId;
                sonPackage.put(params, filePath);
            }
        }
        sonPackage.forEach(this::recursion);
    }

    /**
     * selectFor 1文件夹package，2普通文件
     *
     * @param fileId
     * @param selectFor
     * @return
     */
    private List<FileTreeVo> existsPackageOrCommonFile(Integer fileId, Integer authUserId, Integer selectFor) {
        return fileMapper.findSonPackage(fileId, authUserId, selectFor);
    }
   @Override
   public ResponseJson uploadDictionary(MultipartFile[] File){
        //文件上传前的名称
       List<String> filenames=new ArrayList<>();
       for (MultipartFile multipartFile:File) {
           String fileName = multipartFile.getOriginalFilename();
           File file = new File(fileName);
           OutputStream out = null;
           try{
               //获取文件流，以文件流的方式输出到新文件
//    InputStream in = multipartFile.getInputStream();
               out = new FileOutputStream(file);
               byte[] ss = multipartFile.getBytes();
               for(int i = 0; i < ss.length; i++){
                   out.write(ss[i]);
               }
           }catch(IOException e){
               e.printStackTrace();
           }finally {
               if (out != null){
                   try {
                       out.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }
           }
           //保存文件夹及其文件
           upload(file,filenames);
       }
        return ResponseJson.success();
   }
    public List<String> upload(File file,List<String> filenames){
        File[] files=file.listFiles();
        for (File f:files) {
            if(f.isDirectory()){
                //递归 保存文件夹（返回父id，便于确定属于哪级目录）
                fileMapper.creatPackage(0, 0, f.getName());
                return upload(f,filenames);
            }else{
                //保存文件
                filenames.add(f.getName());
            }
        }
        return filenames;
    }

    @Override
    public ResponseJson uploadPackage(Integer authUserId,List<FileTreeVo> fileTreeVos){
        //如果文件夹没有文件则直接返回
        for (FileTreeVo fileTreeVo:fileTreeVos) {
            if (StringUtils.isNotEmpty(fileTreeVo.getFilePath())) {
                if (!fileTreeVo.getFilePath().contains(".")) {
                    ResponseJson.error("-1", "文件夹为空");
                }
                String[] filePathArr = fileTreeVo.getFilePath().split("/");
                String file=fileTreeVo.getFilePath().substring(fileTreeVo.getFilePath().lastIndexOf("/")+1,fileTreeVo.getFilePath().length());
                for (int i = 0; i < filePathArr.length; i++) {
                    if (filePathArr.length-1==i&&filePathArr[i].equals(file)) {
                        //新增文件
                        getOssUploadResult(authUserId, filePathArr[i], fileTreeVo.getOssName(), fileTreeVo.getOssUrl(), fileTreeVo.getFileSize(), fileTreeVo.getParentId(), fileTreeVo.getMime());
                        System.out.println("文件---------" + filePathArr[i]);
                    } else {
                        //判断是否根目录
                        List<Integer> dictionaryById=new ArrayList<>();
                        if(null!=fileTreeVo.getParentId()&&0==fileTreeVo.getParentId()){
                            dictionaryById=fileMapper.findDictionaryById(null,filePathArr[i],authUserId);
                        }else{
                             dictionaryById = fileMapper.findDictionaryById(fileTreeVo.getParentId(),filePathArr[i],authUserId);
                             if(null==dictionaryById||dictionaryById.size()<=0){
                                 //判断次级目录是否存在
                                 List<Integer> secondDictionaryById = fileMapper.findSecondDictionaryById(fileTreeVo.getParentId(), filePathArr[i],authUserId);
                                 if(null!=secondDictionaryById&&secondDictionaryById.size()>0){
                                     dictionaryById.add(secondDictionaryById.get(0));
                                 }
                             }
                        }
                        //创建文件夹
                        //判断文件夹是否存在（不存在则新建，存在则跳过）
                        if (null != dictionaryById && dictionaryById.size() > 0) {
                            fileTreeVo.setParentId(dictionaryById.get(0));
                            continue;
                        } else {
                            //不存在创建文件夹
                            fileMapper.creatPackage(authUserId, fileTreeVo.getParentId(), filePathArr[i]);
                            //查询最新文件夹id作为下一次的父id
                            List<Integer> newestInfoById = fileMapper.getNewestInfoById();
                            if (null != newestInfoById && newestInfoById.size() > 0) {
                                fileTreeVo.setParentId(newestInfoById.get(0));
//                                parentId = newestInfoById.get(0);
                            }
                        }
                        System.out.println("文件夹---------" + filePathArr[i]);
                    }
                }
            } else {
                ResponseJson.error("-1", "文件夹为空");
            }
        }
        return ResponseJson.success();
    }
}