com.crabshue.commons.archive.filesystem.FileSystemArchiveService Maven / Gradle / Ivy

Go to download
package com.crabshue.commons.archive.filesystem;

import java.io.File;
import java.io.InputStream;
import java.util.Collection;
import java.util.stream.Collectors;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOCase;
import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.crabshue.commons.archive.Archivable;
import com.crabshue.commons.archive.ArchiveService;
import com.crabshue.commons.archive.exceptions.ArchiveErrorContext;
import com.crabshue.commons.archive.exceptions.ArchiveErrorType;
import com.crabshue.commons.exceptions.ApplicationException;
import com.crabshue.commons.file.FileIOUtils;
import com.crabshue.commons.file.FileSystemUtils;

public abstract class FileSystemArchiveService implements ArchiveService {

    Logger logger = LoggerFactory.getLogger(FileSystemArchiveService.class);

    @Override
    public abstract String getArchiveRootPath();

    @Override
    public String getArchiveFolderPath(final T archivable) {
        Validate.notNull(archivable);

        if (archivable.getArchiveId() == null) {
            throw new IllegalArgumentException("Cannot provide archive folder for an archivable without id " + archivable);
        }

        final String folderName = archivable.getArchiveId();

        final File ret = new File(getArchiveRootPath(), folderName);
        return ret.getAbsolutePath();
    }

    @Override
    public Collection listFilesInArchive(final T archivable) {
        Validate.notNull(archivable);
        final File archiveFolder = this.provideArchiveFolder(archivable);

        final Collection ret = FileUtils.listFiles(archiveFolder,
            FileFilterUtils.trueFileFilter(), FileFilterUtils.trueFileFilter());

        return ret.stream()
            .map(File::getAbsolutePath)
            .collect(Collectors.toList());
    }


    @Override
    public File retrieveUniqueFileInArchive(final T archivable, final String filename) {
        Validate.notNull(archivable);
        Validate.notNull(filename);

        final File archiveFolder = this.provideArchiveFolder(archivable);
        final Collection candidates = FileUtils.listFiles(archiveFolder,
            FileFilterUtils.nameFileFilter(filename, IOCase.SENSITIVE), FileFilterUtils.trueFileFilter());

        if (candidates.isEmpty()) {
            throw new ApplicationException(ArchiveErrorType.ARCHIVE_FILE_NOT_FOUND, "Unexpected number of files in archive. Excepted one and only one.")
                .addContextValue(ArchiveErrorContext.FILENAME, filename);
        }

        final File ret = candidates.iterator().next();
        logger.info("Found file [{}] for archivable [{}] and filename [{}]", ret, archivable, filename);
        return ret;
    }

    @Override
    public void deleteArchiveFolder(final T archivable) {
        Validate.notNull(archivable);

        final File archiveFolder = new File(this.getArchiveFolderPath(archivable));

        if (!archiveFolder.exists()) {
            return;
        }
        FileUtils.deleteQuietly(archiveFolder);
    }

    @Override
    public void cleanArchiveFolder(final T archivable) {
        Validate.notNull(archivable);
        final File archiveFolder = this.provideArchiveFolder(archivable);

        FileSystemUtils.cleanDirectory(archiveFolder);

        logger.info("Cleaned archive folder [{}] for archivable [{}]", archiveFolder, archivable);

    }

    @Override
    public void cleanArchiveRoot() {
        final File archiveRoot = new File(this.getArchiveRootPath());

        FileSystemUtils.cleanDirectory(archiveRoot);

        logger.info("Cleaned archive root folder [{}]", archiveRoot);
    }

    @Override
    public void storeInArchive(final T archivable, final File file) {
        Validate.notNull(archivable);
        Validate.notNull(file);

        final File folder = this.provideArchiveFolder(archivable);
        final File ret = new File(folder, file.getName());

        FileSystemUtils.copyFile(file, ret);

        logger.info("Stored file [{}] for [{}]", ret, archivable);
    }

    @Override
    public void storeInArchive(final T archivable, final String filename, final InputStream inputStream) {
        Validate.notNull(archivable);
        Validate.notNull(filename);
        Validate.notNull(inputStream);

        final File archiveFile = new File(this.getArchiveFolderPath(archivable), filename);
        FileIOUtils.writeFile(inputStream, archiveFile);

        logger.info("Stored input stream into [{}] for [{}]", archiveFile, archivable);

    }

    @Override
    public void storeFolderContentInArchive(final T archivable, final File folder) {
        Validate.notNull(archivable);
        Validate.notNull(folder);

        FileSystemUtils.copyFolder(folder, this.provideArchiveFolder(archivable));
    }

    protected File provideArchiveFolder(final T archivable) {
        Validate.notNull(archivable);

        if (archivable.getArchiveId() == null) {
            throw new IllegalArgumentException("Cannot provide archive folder for an archivable without id " + archivable);
        }

        final File ret = new File(this.getArchiveFolderPath(archivable));

        if (!ret.exists()) {
            FileSystemUtils.provideFolder(ret);
        }

        return ret;

    }
}