adding pdf and image viewer

src/infrastructure/repositories/mod.rs

@@ -21,4 +21,3 @@ pub use file_path_resolver::FilePathResolver;
 pub use file_fs_read_repository::FileFsReadRepository;
 pub use file_fs_write_repository::FileFsWriteRepository;
 pub use pg::{UserPgRepository, SessionPgRepository};
-pub use share_fs_repository::ShareFsRepository;

src/infrastructure/services/mod.rs

@@ -5,4 +5,5 @@ pub mod cache_manager;
 pub mod file_metadata_cache;
 pub mod compression_service;
 pub mod buffer_pool;
-pub mod trash_cleanup_service;
+pub mod trash_cleanup_service;
+pub mod zip_service;

src/infrastructure/services/zip_service.rs

@@ -0,0 +1,228 @@
+use std::io::{Cursor, Read, Write};
+use zip::{ZipWriter, write::SimpleFileOptions};
+use thiserror::Error;
+use tracing::*;
+use crate::{
+    application::dtos::file_dto::FileDto,
+    application::dtos::folder_dto::FolderDto,
+    application::ports::inbound::{FileUseCase, FolderUseCase},
+    common::errors::{Result, DomainError, ErrorKind},
+};
+use std::sync::Arc;
+
+/// Error relacionado con la creación de archivos ZIP
+#[derive(Debug, Error)]
+pub enum ZipError {
+    #[error("Error de IO: {0}")]
+    IoError(#[from] std::io::Error),
+    
+    #[error("Error de ZIP: {0}")]
+    ZipError(#[from] zip::result::ZipError),
+    
+    #[error("Error al leer el archivo: {0}")]
+    FileReadError(String),
+    
+    #[error("Error al obtener contenido de carpeta: {0}")]
+    FolderContentsError(String),
+    
+    #[error("Carpeta no encontrada: {0}")]
+    FolderNotFound(String),
+}
+
+// Implementar From<ZipError> para DomainError para permitir el uso de ?
+impl From<ZipError> for DomainError {
+    fn from(err: ZipError) -> Self {
+        DomainError::new(ErrorKind::InternalError, "zip_service", err.to_string())
+    }
+}
+
+// Implementar From<zip::result::ZipError> para DomainError directamente
+impl From<zip::result::ZipError> for DomainError {
+    fn from(err: zip::result::ZipError) -> Self {
+        DomainError::new(ErrorKind::InternalError, "zip_service", err.to_string())
+    }
+}
+
+/// Servicio para crear archivos ZIP
+pub struct ZipService {
+    file_service: Arc<dyn FileUseCase>,
+    folder_service: Arc<dyn FolderUseCase>,
+}
+
+impl ZipService {
+    /// Crea una nueva instancia del servicio ZIP con una referencia al servicio de archivos
+    pub fn new(file_service: Arc<dyn FileUseCase>, folder_service: Arc<dyn FolderUseCase>) -> Self {
+        Self {
+            file_service,
+            folder_service,
+        }
+    }
+    
+    /// Crea un archivo ZIP con el contenido de una carpeta y todas sus subcarpetas
+    /// Retorna los bytes del ZIP
+    pub async fn create_folder_zip(&self, folder_id: &str, folder_name: &str) -> Result<Vec<u8>> {
+        info!("Creando ZIP para carpeta: {} (ID: {})", folder_name, folder_id);
+        
+        // Verificar si la carpeta existe
+        let folder = match self.folder_service.get_folder(folder_id).await {
+            Ok(folder) => folder,
+            Err(e) => {
+                error!("Error al obtener carpeta {}: {}", folder_id, e);
+                return Err(ZipError::FolderNotFound(folder_id.to_string()).into());
+            }
+        };
+        
+        // Crear un buffer en memoria para el ZIP
+        let buf = Cursor::new(Vec::new());
+        let mut zip = ZipWriter::new(buf);
+        
+        // Establecer opciones de compresión
+        let options = SimpleFileOptions::default()
+            .compression_method(zip::CompressionMethod::Deflated)
+            .unix_permissions(0o755);
+        
+        // Objeto para seguir las carpetas procesadas y evitar ciclos
+        let mut processed_folders = std::collections::HashSet::new();
+        
+        // Procesamos la carpeta raíz y construimos el ZIP
+        self.process_folder_recursively(
+            &mut zip,
+            &folder,
+            folder_name,
+            &options,
+            &mut processed_folders
+        ).await?;
+        
+        // Finalizar el ZIP y obtener los bytes
+        let mut zip_buf = zip.finish()?;
+        
+        let mut bytes = Vec::new();
+        match zip_buf.read_to_end(&mut bytes) {
+            Ok(_) => Ok(bytes),
+            Err(e) => {
+                error!("Error al leer ZIP finalizado: {}", e);
+                Err(ZipError::IoError(e).into())
+            }
+        }
+    }
+    
+    // Implementación alternativa para evitar recursión en async
+    async fn process_folder_recursively(
+        &self,
+        zip: &mut ZipWriter<Cursor<Vec<u8>>>,
+        folder: &FolderDto,
+        path: &str,
+        options: &SimpleFileOptions,
+        processed_folders: &mut std::collections::HashSet<String>
+    ) -> Result<()> {
+        // Estructura para representar el trabajo pendiente
+        struct PendingFolder {
+            folder: FolderDto,
+            path: String,
+        }
+        
+        // Cola de trabajo para procesamiento iterativo
+        let mut work_queue = vec![PendingFolder {
+            folder: folder.clone(),
+            path: path.to_string(),
+        }];
+        
+        // Procesar la cola mientras haya elementos
+        while let Some(current) = work_queue.pop() {
+            let folder_id = current.folder.id.to_string();
+            
+            // Evitar ciclos
+            if processed_folders.contains(&folder_id) {
+                continue;
+            }
+            
+            processed_folders.insert(folder_id.clone());
+            
+            // Crear la entrada de directorio en el ZIP
+            let folder_path = format!("{}/", current.path);
+            match zip.add_directory(&folder_path, *options) {
+                Ok(_) => debug!("Carpeta agregada al ZIP: {}", folder_path),
+                Err(e) => {
+                    warn!("No se pudo agregar carpeta al ZIP (puede que ya exista): {}", e);
+                    // Continuamos aunque falle crear el directorio (podría estar duplicado)
+                }
+            }
+            
+            // Agregar archivos de la carpeta al ZIP
+            let files = match self.file_service.list_files(Some(&folder_id)).await {
+                Ok(files) => files,
+                Err(e) => {
+                    error!("Error al listar archivos en carpeta {}: {}", folder_id, e);
+                    return Err(ZipError::FolderContentsError(format!("Error al listar archivos: {}", e)).into());
+                }
+            };
+            
+            // Agregar cada archivo al ZIP
+            for file in files {
+                self.add_file_to_zip(zip, &file, &folder_path, options).await?;
+            }
+            
+            // Procesar subcarpetas
+            let subfolders = match self.folder_service.list_folders(Some(&folder_id)).await {
+                Ok(folders) => folders,
+                Err(e) => {
+                    error!("Error al listar subcarpetas en {}: {}", folder_id, e);
+                    return Err(ZipError::FolderContentsError(format!("Error al listar subcarpetas: {}", e)).into());
+                }
+            };
+            
+            // Agregar subcarpetas a la cola
+            for subfolder in subfolders {
+                let subfolder_path = format!("{}/{}", current.path, subfolder.name);
+                work_queue.push(PendingFolder {
+                    folder: subfolder,
+                    path: subfolder_path,
+                });
+            }
+        }
+        
+        Ok(())
+    }
+    
+    // Agrega un archivo al ZIP
+    async fn add_file_to_zip(
+        &self,
+        zip: &mut ZipWriter<Cursor<Vec<u8>>>,
+        file: &FileDto,
+        folder_path: &str,
+        options: &SimpleFileOptions,
+    ) -> Result<()> {
+        let file_path = format!("{}{}", folder_path, file.name);
+        info!("Agregando archivo al ZIP: {}", file_path);
+        
+        // Obtener el contenido del archivo
+        let file_id = file.id.to_string();
+        let content = match self.file_service.get_file_content(&file_id).await {
+            Ok(content) => content,
+            Err(e) => {
+                error!("Error al leer contenido del archivo {}: {}", file_id, e);
+                return Err(ZipError::FileReadError(format!("Error al leer archivo {}: {}", file_id, e)).into());
+            }
+        };
+        
+        // Escribir archivo al ZIP
+        match zip.start_file_from_path(std::path::Path::new(&file_path), *options) {
+            Ok(_) => {
+                match zip.write_all(&content) {
+                    Ok(_) => {
+                        debug!("Archivo agregado al ZIP: {}", file_path);
+                        Ok(())
+                    },
+                    Err(e) => {
+                        error!("Error al escribir contenido del archivo {}: {}", file_path, e);
+                        Err(ZipError::IoError(e).into())
+                    }
+                }
+            },
+            Err(e) => {
+                error!("Error al iniciar archivo en ZIP {}: {}", file_path, e);
+                Err(ZipError::ZipError(e).into())
+            }
+        }
+    }
+}