adding several features

src/common/di.rs

@@ -0,0 +1,190 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+use async_trait::async_trait;
+
+use crate::domain::services::path_service::PathService;
+use crate::infrastructure::repositories::folder_fs_repository::FolderFsRepository;
+use crate::infrastructure::repositories::file_fs_repository::FileFsRepository;
+use crate::infrastructure::services::file_system_i18n_service::FileSystemI18nService;
+use crate::infrastructure::services::id_mapping_service::IdMappingService;
+use crate::infrastructure::services::cache_manager::StorageCacheManager;
+use crate::application::services::folder_service::FolderService;
+use crate::application::services::file_service::FileService;
+use crate::application::services::i18n_application_service::I18nApplicationService;
+use crate::application::services::storage_mediator::{StorageMediator, FileSystemStorageMediator};
+use crate::application::ports::inbound::{FileUseCase, FolderUseCase, UseCaseFactory};
+use crate::application::ports::outbound::{FileStoragePort, FolderStoragePort};
+use crate::common::errors::DomainError;
+use crate::domain::services::i18n_service::I18nService;
+
+/// Fábrica para los diferentes componentes de la aplicación
+#[allow(dead_code)]
+pub struct AppServiceFactory {
+    storage_path: PathBuf,
+    locales_path: PathBuf,
+}
+
+impl AppServiceFactory {
+    /// Crea una nueva fábrica de servicios
+    #[allow(dead_code)]
+    pub fn new(storage_path: PathBuf, locales_path: PathBuf) -> Self {
+        Self {
+            storage_path,
+            locales_path,
+        }
+    }
+    
+    /// Inicializa los servicios base del sistema
+    #[allow(dead_code)]
+    pub async fn create_core_services(&self) -> Result<CoreServices, DomainError> {
+        // Path service
+        let path_service = Arc::new(PathService::new(self.storage_path.clone()));
+        
+        // Cache manager
+        // TTL values in milliseconds and max entries for cache
+        let file_ttl_ms = 60_000; // 1 minute for files
+        let dir_ttl_ms = 120_000; // 2 minutes for directories
+        let max_entries = 10_000; // Maximum cache entries
+        let cache_manager = Arc::new(StorageCacheManager::new(file_ttl_ms, dir_ttl_ms, max_entries));
+        
+        // Iniciar tarea de limpieza de caché en segundo plano
+        let cache_manager_clone = cache_manager.clone();
+        tokio::spawn(async move {
+            StorageCacheManager::start_cleanup_task(cache_manager_clone).await;
+        });
+        
+        // ID mapping service
+        let id_mapping_path = self.storage_path.join("folder_ids.json");
+        let id_mapping_service = Arc::new(
+            IdMappingService::new(id_mapping_path).await?
+        );
+        
+        Ok(CoreServices {
+            path_service,
+            cache_manager,
+            id_mapping_service,
+        })
+    }
+    
+    /// Inicializa los servicios de repositorio
+    #[allow(dead_code)]
+    pub fn create_repository_services(&self, core: &CoreServices) -> RepositoryServices {
+        // Storage mediator - create first because it's needed by folder repository
+        // (temporarily using a placeholder for folder repository, will update later)
+        let placeholder_folder_repo = Arc::new(FolderFsRepository::new_stub());
+        
+        let storage_mediator = Arc::new(FileSystemStorageMediator::new(
+            placeholder_folder_repo.clone(),
+            core.path_service.clone(),
+            core.id_mapping_service.clone()
+        ));
+        
+        // Folder repository
+        let folder_repository = Arc::new(FolderFsRepository::new(
+            self.storage_path.clone(),
+            storage_mediator.clone(),
+            core.id_mapping_service.clone(),
+            core.path_service.clone(),
+        ));
+        
+        // Create a file metadata cache with default configuration
+        let metadata_cache = Arc::new(
+            crate::infrastructure::services::file_metadata_cache::FileMetadataCache::default_with_config(
+                crate::common::config::AppConfig::default()
+            )
+        );
+        
+        // File repository
+        let file_repository = Arc::new(FileFsRepository::new(
+            self.storage_path.clone(), 
+            storage_mediator.clone(),
+            core.id_mapping_service.clone(),
+            core.path_service.clone(),
+            metadata_cache,
+        ));
+        
+        // I18n repository
+        let i18n_repository = Arc::new(FileSystemI18nService::new(
+            self.locales_path.clone()
+        ));
+        
+        RepositoryServices {
+            folder_repository,
+            file_repository,
+            i18n_repository,
+            storage_mediator,
+        }
+    }
+    
+    /// Inicializa los servicios de aplicación
+    #[allow(dead_code)]
+    pub fn create_application_services(&self, repos: &RepositoryServices) -> ApplicationServices {
+        // Servicios principales
+        let folder_service = Arc::new(FolderService::new(
+            repos.folder_repository.clone()
+        ));
+        
+        let file_service = Arc::new(FileService::new(
+            repos.file_repository.clone()
+        ));
+        
+        let i18n_service = Arc::new(I18nApplicationService::new(
+            repos.i18n_repository.clone()
+        ));
+        
+        ApplicationServices {
+            folder_service,
+            file_service,
+            i18n_service,
+        }
+    }
+}
+
+/// Contenedor para servicios base
+#[allow(dead_code)]
+pub struct CoreServices {
+    pub path_service: Arc<PathService>,
+    pub cache_manager: Arc<StorageCacheManager>,
+    pub id_mapping_service: Arc<IdMappingService>,
+}
+
+/// Contenedor para servicios de repositorio
+#[allow(dead_code)]
+pub struct RepositoryServices {
+    pub folder_repository: Arc<dyn FolderStoragePort>,
+    pub file_repository: Arc<dyn FileStoragePort>,
+    pub i18n_repository: Arc<dyn I18nService>,
+    pub storage_mediator: Arc<dyn StorageMediator>,
+}
+
+/// Contenedor para servicios de aplicación
+#[allow(dead_code)]
+pub struct ApplicationServices {
+    pub folder_service: Arc<dyn FolderUseCase>,
+    pub file_service: Arc<dyn FileUseCase>,
+    pub i18n_service: Arc<I18nApplicationService>,
+}
+
+/// Fábrica de casos de uso para la inyección de dependencias
+#[allow(dead_code)]
+pub struct AppUseCaseFactory {
+    services: ApplicationServices,
+}
+
+impl AppUseCaseFactory {
+    #[allow(dead_code)]
+    pub fn new(services: ApplicationServices) -> Self {
+        Self { services }
+    }
+}
+
+#[async_trait]
+impl UseCaseFactory for AppUseCaseFactory {
+    fn create_file_use_case(&self) -> Arc<dyn FileUseCase> {
+        self.services.file_service.clone()
+    }
+    
+    fn create_folder_use_case(&self) -> Arc<dyn FolderUseCase> {
+        self.services.folder_service.clone()
+    }
+}