fix auth errors and add primigenial paper trash

2025-03-24 16:47:42 +01:00
parent 838ae6e0d4
commit 38b0e9594b
58 changed files with 3701 additions and 135 deletions
@@ -0,0 +1,97 @@
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::time;
+use tracing::{debug, error, info, instrument};
+
+use crate::common::errors::Result;
+use crate::domain::repositories::trash_repository::TrashRepository;
+use crate::application::ports::trash_ports::TrashUseCase;
+
+/// Servicio para la limpieza automática de elementos expirados en la papelera
+pub struct TrashCleanupService {
+    trash_service: Arc<dyn TrashUseCase>,
+    trash_repository: Arc<dyn TrashRepository>,
+    cleanup_interval_hours: u64,
+}
+
+impl TrashCleanupService {
+    pub fn new(
+        trash_service: Arc<dyn TrashUseCase>,
+        trash_repository: Arc<dyn TrashRepository>,
+        cleanup_interval_hours: u64,
+    ) -> Self {
+        Self {
+            trash_service,
+            trash_repository,
+            cleanup_interval_hours: cleanup_interval_hours.max(1), // Mínimo 1 hora
+        }
+    }
+    
+    /// Inicia el trabajo de limpieza periódica
+    #[instrument(skip(self))]
+    pub async fn start_cleanup_job(&self) {
+        let trash_repository = self.trash_repository.clone();
+        let trash_service = self.trash_service.clone();
+        let interval_hours = self.cleanup_interval_hours;
+        
+        info!("Iniciando trabajo de limpieza de papelera con intervalo de {} horas", interval_hours);
+        
+        tokio::spawn(async move {
+            let interval_duration = Duration::from_secs(interval_hours * 60 * 60);
+            let mut interval = time::interval(interval_duration);
+            
+            // Primera ejecución inmediata
+            Self::cleanup_expired_items(trash_repository.clone(), trash_service.clone()).await
+                .unwrap_or_else(|e| error!("Error en la limpieza inicial de la papelera: {:?}", e));
+            
+            loop {
+                interval.tick().await;
+                debug!("Ejecutando tarea programada de limpieza de papelera");
+                
+                if let Err(e) = Self::cleanup_expired_items(
+                    trash_repository.clone(), 
+                    trash_service.clone()
+                ).await {
+                    error!("Error en la limpieza programada de la papelera: {:?}", e);
+                }
+            }
+        });
+    }
+    
+    /// Limpia los elementos expirados en la papelera
+    #[instrument(skip(trash_repository, trash_service))]
+    async fn cleanup_expired_items(
+        trash_repository: Arc<dyn TrashRepository>,
+        trash_service: Arc<dyn TrashUseCase>,
+    ) -> Result<()> {
+        debug!("Comenzando limpieza de elementos expirados en la papelera");
+        
+        // Obtener todos los elementos expirados
+        let expired_items = trash_repository.get_expired_items().await?;
+        
+        if expired_items.is_empty() {
+            debug!("No hay elementos expirados para limpiar");
+            return Ok(());
+        }
+        
+        info!("Encontrados {} elementos expirados para eliminar", expired_items.len());
+        
+        // Eliminar cada elemento expirado
+        for item in expired_items {
+            let trash_id = item.id.to_string();
+            let user_id = item.user_id.to_string();
+            
+            debug!("Eliminando elemento expirado: id={}, user={}", trash_id, user_id);
+            
+            // Si falla una eliminación, continuar con las demás
+            if let Err(e) = trash_service.delete_permanently(&trash_id, &user_id).await {
+                error!("Error eliminando elemento expirado {}: {:?}", trash_id, e);
+            } else {
+                debug!("Elemento expirado eliminado correctamente: {}", trash_id);
+            }
+        }
+        
+        info!("Limpieza de papelera completada");
+        Ok(())
+    }
+}