EmploymentSite/src/main/java/com/hz/employmentsite/services/impl/system/FileServiceImpl.java

package com.hz.employmentsite.services.impl.system;

import com.hz.employmentsite.AppConfig;
import com.hz.employmentsite.mapper.CfFileMapper;
import com.hz.employmentsite.mapper.cquery.FileCQuery;
import com.hz.employmentsite.model.CfFile;
import com.hz.employmentsite.model.CfFileExample;
import com.hz.employmentsite.services.service.system.FileService;
import com.hz.employmentsite.util.FtpHelper;
import com.hz.employmentsite.vo.system.FileModel;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.net.URLEncoder;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.List;
import java.util.UUID;

@Service("FileService")
public class FileServiceImpl implements FileService {

    @Autowired
    FtpHelper ftpHelper;
    @Autowired
    private FileCQuery fileCQuery;
    @Autowired
    private CfFileMapper cfFileMapper;
    @Autowired
    private AppConfig appConfig;

    private final Logger logger;

    public FileServiceImpl() {
        logger = LoggerFactory.getLogger(this.getClass());
    }


    public List<FileModel> getList(String fileRefID) {
        return fileCQuery.getList(fileRefID);
    }

    public CfFile getFileByID(String fileID){
        return cfFileMapper.selectByPrimaryKey(fileID);
    }

    @Override
    public Integer saveFile(MultipartFile[] files, String fileRefID, Integer fileType, String userId, Integer isSingle) throws Exception {

        Integer result = 0;

        FTPClient ftpClient = new FTPClient();

        //如果是单文件上传，删除原先数据
        if (isSingle == 1) {
            CfFileExample example = new CfFileExample();
            example.or().andFileRefIDEqualTo(fileRefID);
            cfFileMapper.deleteByExample(example);
        }
        for (Integer i = 0; i < files.length; i++) {
            MultipartFile file = files[i];
            String fileName = file.getOriginalFilename();
            byte[] byteArr = file.getBytes();
            String fileId = UUID.randomUUID().toString();

            String fileSuffix = fileName.indexOf(".") >= 0 ? fileName.substring(fileName.lastIndexOf(".")) : "";

            fileName = fileName + this.getFileSuffix(fileSuffix);
            ftpHelper.connectToServer(ftpClient);
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);

            CfFile cfFile = new CfFile();
            cfFile.setFileId(fileId);
            cfFile.setUserID(userId);
            cfFile.setFileType(fileType);
            cfFile.setFileRefID(fileRefID);
            cfFile.setCreateTime(new Date());
            cfFile.setFileSuffix(fileName.indexOf(".") >= 0 ? fileName.substring(fileName.lastIndexOf(".")) : "");
            cfFile.setFileName(fileName);

            String filePath = createServeDir(cfFile.getCreateTime(), ftpClient);
            cfFile.setFileUrl(filePath + "/" + fileId + cfFile.getFileSuffix());

            ftpClient.changeWorkingDirectory(filePath);
            ftpClient.storeFile(fileId + cfFile.getFileSuffix(), new ByteArrayInputStream(byteArr));
            ftpHelper.closeConnect(ftpClient);

            result += cfFileMapper.insert(cfFile);

        }

        return result;
    }

    private String getFileSuffix(String fileSuffix) {
        switch (fileSuffix) {
            case ".x-zip-compressed":
                fileSuffix = ".zip";
                break;
            case ".ms-powerpoint":
                fileSuffix = ".ppt";
                break;
            case ".presentation":
                fileSuffix = ".pptx";
                break;
            case ".ms-excel":
                fileSuffix = ".xls";
                break;
            case ".sheet":
                fileSuffix = ".xlsx";
                break;
            case "plain":
                fileSuffix = ".txt";
                break;
            case ".msword":
                fileSuffix = ".doc";
                break;
            case ".document":
                fileSuffix = ".docx";
                break;
            default:
                fileSuffix = "";
                break;
        }
        return fileSuffix;
    }

    public String createServeDir(Date date, FTPClient ftpClient) throws IOException {

        String fileDir = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMM"));

        FTPFile[] ftpFiles = ftpClient.listFiles(fileDir);
        if (ftpFiles.length == 0) {
            ftpClient.makeDirectory(fileDir);
        }

        return fileDir;
    }

    @Override
    public CfFile downFtpFile(String fileId, OutputStream os) {
        CfFile file = cfFileMapper.selectByPrimaryKey(fileId);

        try {
            FTPClient ftpClient = new FTPClient();
            ftpHelper.connectToServer(ftpClient);
            ftpClient.enterLocalPassiveMode();
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);

            ftpClient.retrieveFile(file.getFileUrl(), os);

            ftpHelper.closeConnect(ftpClient);

        } catch (Exception ex) {
            logger.error("downFtpFile，下载文件失败！", ex);
            file = null;
        }

        return file;
    }

    @Override
    public void downloadTempFile(String fileName, OutputStream os) throws FileNotFoundException {
        try {
            InputStream inputStream = new FileInputStream(new File(appConfig.staticLocations.replace("file:", "") + "doc/template/" + fileName));
            os.write(inputStream.readAllBytes());
            os.flush();
        } catch (Exception ex) {
            logger.error("downloadTempFile，下载文件失败！", ex);
        }
    }

    @Override
    public ResponseEntity<Resource> downloadApk() throws IOException {
        // 从服务器获取APK文件
        String apkFilePath = appConfig.staticLocations.replace("file:", "") + "apk/app.apk";
        File apkFile = new File(apkFilePath);

        // 创建文件资源对象
        Path path = Paths.get(apkFile.getAbsolutePath());
        ByteArrayResource resource = new ByteArrayResource(Files.readAllBytes(path));

        // 设置下载响应头
        HttpHeaders headers = new HttpHeaders();
        headers.add(HttpHeaders.CONTENT_TYPE,"application/vnd.android.package-archive");
        headers.add(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename*=UTF-8''" + URLEncoder.encode("惠州市就业驿站管理系统.apk", "UTF-8"));

        // 返回文件资源对象和响应头
        return ResponseEntity.ok()
                .headers(headers)
                .contentLength(apkFile.length())
                .contentType(MediaType.APPLICATION_OCTET_STREAM)
                .body(resource);
    }

    @Override
    public Integer delete(String fileId) throws IOException {
        CfFile cfFile = cfFileMapper.selectByPrimaryKey(fileId);
        Path filePath = Paths.get(CreateFileFullName(cfFile.getFileUrl()));
        if (Files.exists(filePath)) {
            Files.delete(filePath);
        }

        return cfFileMapper.deleteByPrimaryKey(fileId);
    }

    public String CreateFileFullName(String fileName) {

        Path pFileName = Paths.get(appConfig.uploadfileUrl, fileName);

        if (!Files.exists(pFileName.getParent())) {
            try {
                Files.createDirectory(pFileName.getParent());
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

        String FileFullName = pFileName.toString();

        return FileFullName;
    }


    @Override
    public String downFtpFileToLocal(String fileId) {
        try {
            CfFile cfFile = cfFileMapper.selectByPrimaryKey(fileId);
            FTPClient ftpClient = new FTPClient();
            ftpHelper.connectToServer(ftpClient);
            ftpClient.enterLocalPassiveMode();
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ftpClient.retrieveFile(cfFile.getFileUrl(), bos);
            ftpHelper.closeConnect(ftpClient);

            String downPath = "doc\\down\\";
            String filePath = appConfig.staticLocations.replace("file:", "") + downPath;
            String fileName =  cfFile.getFileId() + "-" + UUID.randomUUID().toString() + cfFile.getFileSuffix();
            Path dictPath = Paths.get(filePath);
            if (!Files.exists(dictPath)) {
                Files.createDirectory(dictPath);
            }

            File file = new File(filePath + fileName);
            if (!file.exists()) {
                file.createNewFile();
            }

            FileOutputStream fos = new FileOutputStream(file);
            fos.write(bos.toByteArray());
            fos.flush();
            fos.close();

            return downPath + fileName;

        } catch (Exception ex) {
            logger.error("downFtpFile，下载文件失败！", ex);
            return "";
        }
    }


    //<dependency>
    //            <groupId>commons-fileupload</groupId>
    //            <artifactId>commons-fileupload</artifactId>
    //            <version>1.4</version>
    // </dependency>
    //拷贝文件，未测试
    /*public void copyFileByRefID(String sourceRefID, List<String> fileRefIDList, String userId) throws Exception {
        List<FileModel> fileList = fileCQuery.getList(sourceRefID);

        List<MultipartFile> multipartFiles = new ArrayList<>();

        FTPClient ftpClient = new FTPClient();
        ftpHelper.connectToServer(ftpClient);
        ftpClient.enterLocalPassiveMode();
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);

        fileList.forEach(item -> {
            try {
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                ftpClient.retrieveFile(item.getFileUrl(), bos);

                FileItemFactory factory = new DiskFileItemFactory(16, null);
                FileItem fileItem = factory.createItem(item.getFileName().replace(item.getFileSuffix(), ""), "text/plan", true, item.getFileSuffix().replace(".", ""));
                OutputStream os = fileItem.getOutputStream();
                os.write(bos.toByteArray());
                os.flush();

                multipartFiles.add(new CommonsMultipartFile(fileItem));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        });

        ftpHelper.closeConnect(ftpClient);

        fileRefIDList.forEach(fileRefID -> {
            try {
                saveFile((MultipartFile[]) multipartFiles.toArray(), fileRefID, 1, userId);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });

    }*/

}