adding user authentication

src/infrastructure/repositories/file_path_resolver.rs

@@ -4,7 +4,7 @@ use async_trait::async_trait;
 
 use crate::domain::services::path_service::{PathService, StoragePath};
 use crate::application::services::storage_mediator::StorageMediator;
-use crate::infrastructure::services::id_mapping_service::{IdMappingService, IdMappingError};
+use crate::application::ports::outbound::IdMappingPort;
 use crate::domain::repositories::file_repository::FileRepositoryError;
 use crate::common::errors::DomainError;
 use crate::application::ports::storage_ports::FilePathResolutionPort;
@@ -13,7 +13,7 @@ use crate::application::ports::storage_ports::FilePathResolutionPort;
 pub struct FilePathResolver {
     path_service: Arc<PathService>,
     storage_mediator: Arc<dyn StorageMediator>,
-    id_mapping_service: Arc<IdMappingService>,
+    id_mapping_service: Arc<dyn crate::application::ports::outbound::IdMappingPort>,
 }
 
 impl FilePathResolver {
@@ -21,7 +21,7 @@ impl FilePathResolver {
     pub fn new(
         path_service: Arc<PathService>,
         storage_mediator: Arc<dyn StorageMediator>,
-        id_mapping_service: Arc<IdMappingService>,
+        id_mapping_service: Arc<dyn crate::application::ports::outbound::IdMappingPort>,
     ) -> Self {
         Self {
             path_service,
@@ -30,11 +30,52 @@ impl FilePathResolver {
         }
     }
     
+    /// Crea un resolver de rutas de prueba
+    pub fn default_stub() -> Self {
+        let path_service = Arc::new(PathService::new(PathBuf::from("./storage")));
+        
+        // Create dummy implementation of IdMappingPort
+        struct DummyIdMappingService;
+        #[async_trait::async_trait]
+        impl crate::application::ports::outbound::IdMappingPort for DummyIdMappingService {
+            async fn get_or_create_id(&self, _path: &StoragePath) -> Result<String, DomainError> {
+                Ok("dummy-id".to_string())
+            }
+            
+            async fn get_path_by_id(&self, _id: &str) -> Result<StoragePath, DomainError> {
+                Ok(StoragePath::from_string("/"))
+            }
+            
+            async fn update_path(&self, _id: &str, _new_path: &StoragePath) -> Result<(), DomainError> {
+                Ok(())
+            }
+            
+            async fn remove_id(&self, _id: &str) -> Result<(), DomainError> {
+                Ok(())
+            }
+            
+            async fn save_changes(&self) -> Result<(), DomainError> {
+                Ok(())
+            }
+        }
+        
+        Self {
+            path_service: path_service.clone(),
+            storage_mediator: Arc::new(crate::application::services::storage_mediator::FileSystemStorageMediator::new_stub()),
+            id_mapping_service: Arc::new(DummyIdMappingService) as Arc<dyn crate::application::ports::outbound::IdMappingPort>,
+        }
+    }
+    
     /// Resuelve una ruta de dominio a una ruta física absoluta
     pub fn resolve_storage_path(&self, storage_path: &StoragePath) -> PathBuf {
         self.path_service.resolve_path(storage_path)
     }
     
+    /// Resuelve la ruta de un archivo (alias para resolve_storage_path)
+    pub fn resolve_file_path(&self, storage_path: &StoragePath) -> PathBuf {
+        self.resolve_storage_path(storage_path)
+    }
+    
     /// Resuelve una ruta PathBuf a una ruta física absoluta (legacy)
     pub fn resolve_legacy_path(&self, relative_path: &std::path::Path) -> PathBuf {
         self.storage_mediator.resolve_path(relative_path)
@@ -43,31 +84,31 @@ impl FilePathResolver {
     /// Obtiene la ruta de un archivo por su ID
     pub async fn get_path_by_id(&self, id: &str) -> Result<StoragePath, FileRepositoryError> {
         self.id_mapping_service.get_path_by_id(id).await
-            .map_err(FileRepositoryError::from)
+            .map_err(|e| FileRepositoryError::IdMappingError(e.to_string()))
     }
     
     /// Actualiza la ruta para un ID existente
     pub async fn update_path(&self, id: &str, storage_path: &StoragePath) -> Result<(), FileRepositoryError> {
         self.id_mapping_service.update_path(id, storage_path).await
-            .map_err(FileRepositoryError::from)
+            .map_err(|e| FileRepositoryError::IdMappingError(e.to_string()))
     }
     
     /// Obtiene o crea un ID para una ruta
     pub async fn get_or_create_id(&self, storage_path: &StoragePath) -> Result<String, FileRepositoryError> {
         self.id_mapping_service.get_or_create_id(storage_path).await
-            .map_err(FileRepositoryError::from)
+            .map_err(|e| FileRepositoryError::IdMappingError(e.to_string()))
     }
     
     /// Elimina un ID del mapeo
     pub async fn remove_id(&self, id: &str) -> Result<(), FileRepositoryError> {
         self.id_mapping_service.remove_id(id).await
-            .map_err(FileRepositoryError::from)
+            .map_err(|e| FileRepositoryError::IdMappingError(e.to_string()))
     }
     
     /// Guarda cambios pendientes
     pub async fn save_changes(&self) -> Result<(), FileRepositoryError> {
-        self.id_mapping_service.save_pending_changes().await
-            .map_err(FileRepositoryError::from)
+        self.id_mapping_service.save_changes().await
+            .map_err(|e| FileRepositoryError::IdMappingError(e.to_string()))
     }
 }