zip.hpp

Go to the documentation of this file.

#ifndef IV_SRC_UTILS_ZIP_HPP_
#define IV_SRC_UTILS_ZIP_HPP_
 
#include "core/file.hpp"
#include "utils/Calendar.hpp"
 
#include <algorithm>
#include <fmt/core.h>
#include <string>
#include <vector>
#include <zip.h>
 
namespace iv::zip
{
 
static bool compressFolders(const std::vector<std::string> &folders, std::string_view zipSaveFolder,
                            std::string_view zipPrefix, std::string_view zipExtension)
{
    std::string dateString = iv::utils::Calendar().strTime(iv::eTimeFormat::BackupFormat);
    std::string compressFile = fmt::format("{}/{}_{}.{}", zipSaveFolder, zipPrefix, dateString, zipExtension);
 
    if (iv::file::exists(zipSaveFolder) && iv::file::isFile(zipSaveFolder))
    {
        throw iv::exception::FileNameNotAvailable(fmt::format("The name is occupied by a file: {}", zipSaveFolder));
    }
 
    if (not iv::file::exists(zipSaveFolder))
    {
        iv::file::createDirectory(zipSaveFolder);
    }
 
    zip_t *zip = zip_open(compressFile.c_str(), ZIP_CREATE | ZIP_TRUNCATE, nullptr);
 
    if (not zip)
    {
        //TODO: Ha que usar las excepciones de la librería o crear una si no hay que encaje
        //        throw std::runtime_error("Error al abrir el archivo zip");
    }
 
    //TODO: ¿Vas a ser tú quien acabe con el perrito?
    //Dibujamos en terminal un perrito
    std::cout << "🐶" << std::endl;
    //Dibujamos en terminal un gatito
    std::cout << "🐱" << std::endl;
    //Dibujamos en terminal un ratoncito
    std::cout << "🐭" << std::endl;
    //TODO:[MÁXIMA_PRIORIDAD] Estudiar si el perrito y sus amigos son una comunicación externa y se se debería cifrar
 
    for (const auto &folderSave: folders)
    {
        std::string pathToFolder {folderSave.substr(0, folderSave.find_last_of('/'))};
 
        for (const auto &fileFolderSave: std::filesystem::recursive_directory_iterator(folderSave))
        {
            if (fileFolderSave.is_regular_file())
            {
                std::string relativePath {std::filesystem::relative(fileFolderSave.path(), pathToFolder).string()};
                zip_source_t *source {zip_source_file(zip, fileFolderSave.path().c_str(), 0, 0)};
 
                if (source == nullptr)
                {
                    throw iv::exception::LibZipError("Error creating the file source.");
                }
 
                if (zip_file_add(zip, relativePath.c_str(), source, ZIP_FL_OVERWRITE) < 0)
                {
                    zip_source_free(source);
                    throw iv::exception::LibZipError(
                            fmt::format("Error adding the file to the zip file: {}", fileFolderSave.path().string()));
                }
            }
            else if (fileFolderSave.is_directory() and fs::is_empty(fileFolderSave.path()))
            {
                zip_dir_add(zip, fileFolderSave.path().c_str(), ZIP_FL_ENC_UTF_8);
            }
        }
    }
 
    if (zip_close(zip) < 0)
    {
        throw iv::exception::LibZipError("Error closing the zip file.");
    }
 
    return true;
}
 
static bool
extractCompressedFolders(const std::string &compressedFile,
                         const std::unordered_map<std::string, std::string> &compressedFoldersExtractionPaths)
{
    zip_t *zip {zip_open(compressedFile.c_str(), ZIP_RDONLY, nullptr)};
 
    if (zip == nullptr)
    {
        throw iv::exception::LibZipError(fmt::format("Error opening {} file.", compressedFile));
    }
 
    // Iterate every file inside the ZIP file
    int64_t numEntries {zip_get_num_entries(zip, 0)};
 
    for (int64_t entryIteration = 0; entryIteration < numEntries; ++entryIteration)
    {
        zip_stat_t stat;
        zip_stat_index(zip, static_cast<zip_uint64_t>(entryIteration), 0, &stat);
 
        std::string entryName {stat.name};// Nombre del fichero dentro del ZIP
        std::string extractingFolderName {entryName.substr(0, entryName.find_first_of('/'))};
        std::string pathSaveName;// Path donde se extraerá el contenido del fichero
 
        auto it =
                std::find_if(compressedFoldersExtractionPaths.begin(), compressedFoldersExtractionPaths.end(),
                             [&extractingFolderName](const auto &pair) { return pair.first == extractingFolderName; });
 
        if (it != compressedFoldersExtractionPaths.end())
        {
            pathSaveName = iv::file::makePath(it->second, entryName);
        }
        else
        {
            pathSaveName = entryName;
        }
 
        if (pathSaveName.back() == '/')
        {
            // If it's a directory
            iv::file::createDirectory(pathSaveName);
        }
        else
        {
            // Create the directory where the file will be extracted
            std::string folderSaveExtractedFile {pathSaveName.substr(0, pathSaveName.find_last_of('/'))};
            iv::file::createDirectory(folderSaveExtractedFile);
 
            // Abre el fichero dentro del ZIP
            zip_file_t *fileInZip {zip_fopen_index(zip, static_cast<zip_uint64_t>(entryIteration), 0)};
 
            if (fileInZip == nullptr)
            {
                throw iv::exception::LibZipError(fmt::format("Error opening file {} inside the ZIP file.", entryName));
            }
            //
            // Crea el fichero extraído
            FILE *extractedFile {fopen(pathSaveName.c_str(), "wb")};
            //
            if (extractedFile == nullptr)
            {
                zip_fclose(fileInZip);
                throw iv::exception::FileNameNotAvailable(fmt::format("Error creating {} file.", pathSaveName));
            }
 
            //Leer y escribir los datos del archivo
            char buffer[1024];
            zip_int64_t bytesRead;
 
            while ((bytesRead = zip_fread(fileInZip, buffer, sizeof(buffer))) > 0)
            {
                fwrite(buffer, 1, static_cast<size_t>(bytesRead), extractedFile);
            }
 
            fclose(extractedFile);
 
            //Cerrar los archivos fclose(extractedFile);
            zip_fclose(fileInZip);
        }
    }
    //Cerrar el ZIP zip_close(zip);
    return true;
}
 
}// namespace iv::zip
 
#endif//IV_SRC_UTILS_ZIP_HPP_