adding user authentication

2025-03-20 09:22:31 +01:00
parent 961545aef7
commit cafad0fbfd
69 changed files with 6483 additions and 106 deletions
@@ -61,4 +61,26 @@ impl From<FileDto> for File {
            dto.modified_at
        )
    }
+}
+
+impl FileDto {
+    /// Creates an empty file DTO for stub implementations
+    pub fn empty() -> Self {
+        Self {
+            id: "stub-id".to_string(),
+            name: "stub-file".to_string(),
+            path: "/stub/path".to_string(),
+            size: 0,
+            mime_type: "application/octet-stream".to_string(),
+            folder_id: None,
+            created_at: 0,
+            modified_at: 0,
+        }
+    }
+}
+
+impl Default for FileDto {
+    fn default() -> Self {
+        Self::empty()
+    }
 }
@@ -80,4 +80,25 @@ impl From<FolderDto> for Folder {
            dto.modified_at
        )
    }
+}
+
+impl FolderDto {
+    /// Creates an empty folder DTO for stub implementations
+    pub fn empty() -> Self {
+        Self {
+            id: "stub-id".to_string(),
+            name: "stub-folder".to_string(),
+            path: "/stub/path".to_string(),
+            parent_id: None,
+            created_at: 0,
+            modified_at: 0,
+            is_root: true,
+        }
+    }
+}
+
+impl Default for FolderDto {
+    fn default() -> Self {
+        Self::empty()
+    }
 }
@@ -2,4 +2,5 @@ pub mod file_dto;
 pub mod folder_dto;
 pub mod i18n_dto;
 pub mod pagination;
+pub mod user_dto;

@@ -0,0 +1,67 @@
+use serde::{Serialize, Deserialize};
+use chrono::{DateTime, Utc};
+use crate::domain::entities::user::{User, UserRole};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct UserDto {
+    pub id: String,
+    pub username: String,
+    pub email: String,
+    pub role: String,
+    pub storage_quota_bytes: i64,
+    pub storage_used_bytes: i64,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+    pub last_login_at: Option<DateTime<Utc>>,
+    pub active: bool,
+}
+
+impl From<User> for UserDto {
+    fn from(user: User) -> Self {
+        Self {
+            id: user.id().to_string(),
+            username: user.username().to_string(),
+            email: user.email().to_string(),
+            role: format!("{}", user.role()),
+            storage_quota_bytes: user.storage_quota_bytes(),
+            storage_used_bytes: user.storage_used_bytes(),
+            created_at: user.created_at(),
+            updated_at: user.updated_at(),
+            last_login_at: user.last_login_at(),
+            active: user.is_active(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct LoginDto {
+    pub username: String,
+    pub password: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RegisterDto {
+    pub username: String,
+    pub email: String,
+    pub password: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct AuthResponseDto {
+    pub user: UserDto,
+    pub access_token: String,
+    pub refresh_token: String,
+    pub token_type: String,
+    pub expires_in: i64,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ChangePasswordDto {
+    pub current_password: String,
+    pub new_password: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RefreshTokenDto {
+    pub refresh_token: String,
+}
@@ -0,0 +1,46 @@
+use async_trait::async_trait;
+use crate::domain::entities::user::User;
+use crate::domain::entities::session::Session;
+use crate::common::errors::DomainError;
+
+#[async_trait]
+pub trait UserStoragePort: Send + Sync + 'static {
+    /// Crea un nuevo usuario 
+    async fn create_user(&self, user: User) -> Result<User, DomainError>;
+    
+    /// Obtiene un usuario por ID
+    async fn get_user_by_id(&self, id: &str) -> Result<User, DomainError>;
+    
+    /// Obtiene un usuario por nombre de usuario
+    async fn get_user_by_username(&self, username: &str) -> Result<User, DomainError>;
+    
+    /// Obtiene un usuario por correo electrónico
+    async fn get_user_by_email(&self, email: &str) -> Result<User, DomainError>;
+    
+    /// Actualiza un usuario existente
+    async fn update_user(&self, user: User) -> Result<User, DomainError>;
+    
+    /// Actualiza solo el uso de almacenamiento de un usuario
+    async fn update_storage_usage(&self, user_id: &str, usage_bytes: i64) -> Result<(), DomainError>;
+    
+    /// Lista usuarios con paginación
+    async fn list_users(&self, limit: i64, offset: i64) -> Result<Vec<User>, DomainError>;
+    
+    /// Cambia la contraseña de un usuario
+    async fn change_password(&self, user_id: &str, password_hash: &str) -> Result<(), DomainError>;
+}
+
+#[async_trait]
+pub trait SessionStoragePort: Send + Sync + 'static {
+    /// Crea una nueva sesión
+    async fn create_session(&self, session: Session) -> Result<Session, DomainError>;
+    
+    /// Obtiene una sesión por token de actualización
+    async fn get_session_by_refresh_token(&self, refresh_token: &str) -> Result<Session, DomainError>;
+    
+    /// Revoca una sesión específica
+    async fn revoke_session(&self, session_id: &str) -> Result<(), DomainError>;
+    
+    /// Revoca todas las sesiones de un usuario
+    async fn revoke_all_user_sessions(&self, user_id: &str) -> Result<u64, DomainError>;
+}
@@ -46,7 +46,7 @@ pub trait FileManagementUseCase: Send + Sync + 'static {
 }

 /// Factory para crear implementaciones de casos de uso de archivos
-pub trait FileUseCaseFactory {
+pub trait FileUseCaseFactory: Send + Sync + 'static {
    fn create_file_upload_use_case(&self) -> Arc<dyn FileUploadUseCase>;
    fn create_file_retrieval_use_case(&self) -> Arc<dyn FileRetrievalUseCase>;
    fn create_file_management_use_case(&self) -> Arc<dyn FileManagementUseCase>;
@@ -1,4 +1,5 @@
 pub mod inbound;
 pub mod outbound;
 pub mod file_ports;
-pub mod storage_ports;
+pub mod storage_ports;
+pub mod auth_ports;
@@ -0,0 +1,275 @@
+use std::sync::Arc;
+use crate::domain::entities::user::{User, UserRole};
+use crate::domain::entities::session::Session;
+use crate::domain::services::auth_service::AuthService;
+use crate::application::ports::auth_ports::{UserStoragePort, SessionStoragePort};
+use crate::application::dtos::user_dto::{UserDto, RegisterDto, LoginDto, AuthResponseDto, ChangePasswordDto, RefreshTokenDto};
+use crate::common::errors::{DomainError, ErrorKind};
+
+pub struct AuthApplicationService {
+    user_storage: Arc<dyn UserStoragePort>,
+    session_storage: Arc<dyn SessionStoragePort>,
+    auth_service: Arc<AuthService>,
+}
+
+impl AuthApplicationService {
+    pub fn new(
+        user_storage: Arc<dyn UserStoragePort>,
+        session_storage: Arc<dyn SessionStoragePort>,
+        auth_service: Arc<AuthService>,
+    ) -> Self {
+        Self {
+            user_storage,
+            session_storage,
+            auth_service,
+        }
+    }
+    
+    pub async fn register(&self, dto: RegisterDto) -> Result<UserDto, DomainError> {
+        // Verificar usuario duplicado
+        if self.user_storage.get_user_by_username(&dto.username).await.is_ok() {
+            return Err(DomainError::new(
+                ErrorKind::AlreadyExists,
+                "User",
+                format!("El usuario '{}' ya existe", dto.username)
+            ));
+        }
+        
+        if self.user_storage.get_user_by_email(&dto.email).await.is_ok() {
+            return Err(DomainError::new(
+                ErrorKind::AlreadyExists,
+                "User",
+                format!("El email '{}' ya está registrado", dto.email)
+            ));
+        }
+        
+        // Cuota predeterminada: 1GB (ajustable según plan)
+        let default_quota = 1024 * 1024 * 1024; // 1GB
+        
+        // Crear usuario
+        let user = User::new(
+            dto.username,
+            dto.email,
+            dto.password,
+            UserRole::User, // Por defecto: usuario normal
+            default_quota,
+        ).map_err(|e| DomainError::new(
+            ErrorKind::InvalidInput,
+            "User",
+            format!("Error al crear usuario: {}", e)
+        ))?;
+        
+        // Guardar usuario
+        let created_user = self.user_storage.create_user(user).await?;
+        
+        tracing::info!("Usuario registrado: {}", created_user.id());
+        Ok(UserDto::from(created_user))
+    }
+    
+    pub async fn login(&self, dto: LoginDto) -> Result<AuthResponseDto, DomainError> {
+        // Buscar usuario
+        let mut user = self.user_storage
+            .get_user_by_username(&dto.username)
+            .await
+            .map_err(|_| DomainError::new(
+                ErrorKind::AccessDenied,
+                "Auth",
+                "Credenciales inválidas"
+            ))?;
+        
+        // Verificar si usuario está activo
+        if !user.is_active() {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Auth",
+                "Cuenta desactivada"
+            ));
+        }
+        
+        // Verificar contraseña
+        let is_valid = user.verify_password(&dto.password)
+            .map_err(|_| DomainError::new(
+                ErrorKind::AccessDenied,
+                "Auth",
+                "Credenciales inválidas"
+            ))?;
+            
+        if !is_valid {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Auth",
+                "Credenciales inválidas"
+            ));
+        }
+        
+        // Actualizar último login
+        user.register_login();
+        self.user_storage.update_user(user.clone()).await?;
+        
+        // Generar tokens
+        let access_token = self.auth_service.generate_access_token(&user)
+            .map_err(DomainError::from)?;
+        
+        let refresh_token = self.auth_service.generate_refresh_token();
+        
+        // Guardar sesión
+        let session = Session::new(
+            user.id().to_string(),
+            refresh_token.clone(),
+            None, // IP (se puede añadir desde la capa HTTP)
+            None, // User-Agent (se puede añadir desde la capa HTTP)
+            self.auth_service.refresh_token_expiry_days(),
+        );
+        
+        self.session_storage.create_session(session).await?;
+        
+        // Respuesta de autenticación
+        Ok(AuthResponseDto {
+            user: UserDto::from(user),
+            access_token,
+            refresh_token,
+            token_type: "Bearer".to_string(),
+            expires_in: self.auth_service.refresh_token_expiry_secs(),
+        })
+    }
+    
+    pub async fn refresh_token(&self, dto: RefreshTokenDto) -> Result<AuthResponseDto, DomainError> {
+        // Obtener sesión válida
+        let session = self.session_storage
+            .get_session_by_refresh_token(&dto.refresh_token)
+            .await?;
+        
+        // Verificar si la sesión está expirada o revocada
+        if session.is_expired() || session.is_revoked() {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Auth",
+                "Sesión expirada o inválida"
+            ));
+        }
+        
+        // Obtener usuario
+        let user = self.user_storage
+            .get_user_by_id(session.user_id())
+            .await?;
+        
+        // Verificar si usuario está activo
+        if !user.is_active() {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Auth",
+                "Cuenta desactivada"
+            ));
+        }
+        
+        // Revocar sesión actual
+        self.session_storage.revoke_session(session.id()).await?;
+        
+        // Generar nuevos tokens
+        let access_token = self.auth_service.generate_access_token(&user)
+            .map_err(DomainError::from)?;
+        
+        let new_refresh_token = self.auth_service.generate_refresh_token();
+        
+        // Crear nueva sesión
+        let new_session = Session::new(
+            user.id().to_string(),
+            new_refresh_token.clone(),
+            None,
+            None,
+            self.auth_service.refresh_token_expiry_days(),
+        );
+        
+        self.session_storage.create_session(new_session).await?;
+        
+        Ok(AuthResponseDto {
+            user: UserDto::from(user),
+            access_token,
+            refresh_token: new_refresh_token,
+            token_type: "Bearer".to_string(),
+            expires_in: self.auth_service.refresh_token_expiry_secs(),
+        })
+    }
+    
+    pub async fn logout(&self, user_id: &str, refresh_token: &str) -> Result<(), DomainError> {
+        // Obtener sesión
+        let session = match self.session_storage.get_session_by_refresh_token(refresh_token).await {
+            Ok(s) => s,
+            // Si la sesión no existe, consideramos el logout como exitoso
+            Err(_) => return Ok(()),
+        };
+        
+        // Verificar que la sesión pertenece al usuario
+        if session.user_id() != user_id {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Auth",
+                "La sesión no pertenece al usuario"
+            ));
+        }
+        
+        // Revocar sesión
+        self.session_storage.revoke_session(session.id()).await?;
+        
+        Ok(())
+    }
+    
+    pub async fn logout_all(&self, user_id: &str) -> Result<u64, DomainError> {
+        // Revocar todas las sesiones del usuario
+        let revoked_count = self.session_storage.revoke_all_user_sessions(user_id).await?;
+        
+        Ok(revoked_count)
+    }
+    
+    pub async fn change_password(&self, user_id: &str, dto: ChangePasswordDto) -> Result<(), DomainError> {
+        // Obtener usuario
+        let mut user = self.user_storage.get_user_by_id(user_id).await?;
+        
+        // Verificar contraseña actual
+        let is_valid = user.verify_password(&dto.current_password)
+            .map_err(|_| DomainError::new(
+                ErrorKind::AccessDenied,
+                "Auth",
+                "Contraseña actual incorrecta"
+            ))?;
+            
+        if !is_valid {
+            return Err(DomainError::new(
+                ErrorKind::AccessDenied,
+                "Auth",
+                "Contraseña actual incorrecta"
+            ));
+        }
+        
+        // Actualizar contraseña
+        user.update_password(dto.new_password.clone())
+            .map_err(|e| DomainError::new(
+                ErrorKind::InvalidInput,
+                "User",
+                format!("Error al cambiar contraseña: {}", e)
+            ))?;
+        
+        // Guardar usuario actualizado
+        self.user_storage.update_user(user).await?;
+        
+        // Opcional: revocar todas las sesiones para forzar re-login con nueva contraseña
+        self.session_storage.revoke_all_user_sessions(user_id).await?;
+        
+        Ok(())
+    }
+    
+    pub async fn get_user(&self, user_id: &str) -> Result<UserDto, DomainError> {
+        let user = self.user_storage.get_user_by_id(user_id).await?;
+        Ok(UserDto::from(user))
+    }
+    
+    // Alias for consistency with handler method
+    pub async fn get_user_by_id(&self, user_id: &str) -> Result<UserDto, DomainError> {
+        self.get_user(user_id).await
+    }
+    
+    pub async fn list_users(&self, limit: i64, offset: i64) -> Result<Vec<UserDto>, DomainError> {
+        let users = self.user_storage.list_users(limit, offset).await?;
+        Ok(users.into_iter().map(UserDto::from).collect())
+    }
+}
@@ -16,6 +16,13 @@ impl FileManagementService {
    pub fn new(file_repository: Arc<dyn FileWritePort>) -> Self {
        Self { file_repository }
    }
+    
+    /// Crea un stub para pruebas
+    pub fn default_stub() -> Self {
+        Self {
+            file_repository: Arc::new(crate::infrastructure::repositories::FileFsWriteRepository::default_stub())
+        }
+    }
 }

 #[async_trait]
@@ -18,6 +18,13 @@ impl FileRetrievalService {
    pub fn new(file_repository: Arc<dyn FileReadPort>) -> Self {
        Self { file_repository }
    }
+    
+    /// Crea un stub para pruebas
+    pub fn default_stub() -> Self {
+        Self {
+            file_repository: Arc::new(crate::infrastructure::repositories::FileFsReadRepository::default_stub())
+        }
+    }
 }

 #[async_trait]
@@ -79,6 +79,51 @@ impl FileService {
        Self { file_repository }
    }
    
+    /// Creates a stub implementation for testing and middleware
+    pub fn new_stub() -> impl FileUseCase {
+        struct FileServiceStub;
+        
+        #[async_trait]
+        impl FileUseCase for FileServiceStub {
+            async fn upload_file(
+                &self,
+                _name: String,
+                _folder_id: Option<String>,
+                _content_type: String,
+                _content: Vec<u8>,
+            ) -> Result<FileDto, DomainError> {
+                Ok(FileDto::empty())
+            }
+            
+            async fn get_file(&self, _id: &str) -> Result<FileDto, DomainError> {
+                Ok(FileDto::empty())
+            }
+            
+            async fn list_files(&self, _folder_id: Option<&str>) -> Result<Vec<FileDto>, DomainError> {
+                Ok(vec![])
+            }
+            
+            async fn delete_file(&self, _id: &str) -> Result<(), DomainError> {
+                Ok(())
+            }
+            
+            async fn get_file_content(&self, _id: &str) -> Result<Vec<u8>, DomainError> {
+                Ok(vec![])
+            }
+            
+            async fn get_file_stream(&self, _id: &str) -> Result<Box<dyn Stream<Item = Result<Bytes, std::io::Error>> + Send>, DomainError> {
+                let empty_stream = futures::stream::empty();
+                Ok(Box::new(empty_stream))
+            }
+            
+            async fn move_file(&self, _file_id: &str, _folder_id: Option<String>) -> Result<FileDto, DomainError> {
+                Ok(FileDto::empty())
+            }
+        }
+        
+        FileServiceStub
+    }
+    
    /// Uploads a new file from bytes
    pub async fn upload_file_from_bytes(
        &self,
@@ -16,6 +16,13 @@ impl FileUploadService {
    pub fn new(file_repository: Arc<dyn FileWritePort>) -> Self {
        Self { file_repository }
    }
+    
+    /// Crea un stub para pruebas
+    pub fn default_stub() -> Self {
+        Self {
+            file_repository: Arc::new(crate::infrastructure::repositories::FileFsWriteRepository::default_stub())
+        }
+    }
 }

 #[async_trait]
@@ -23,6 +23,14 @@ impl AppFileUseCaseFactory {
            file_write_repository,
        }
    }
+    
+    /// Crea un stub para pruebas
+    pub fn default_stub() -> Self {
+        Self {
+            file_read_repository: Arc::new(crate::infrastructure::repositories::FileFsReadRepository::default_stub()),
+            file_write_repository: Arc::new(crate::infrastructure::repositories::FileFsWriteRepository::default_stub()),
+        }
+    }
 }

 impl FileUseCaseFactory for AppFileUseCaseFactory {
@@ -17,6 +17,57 @@ impl FolderService {
    pub fn new(folder_storage: Arc<dyn FolderStoragePort>) -> Self {
        Self { folder_storage }
    }
+    
+    /// Creates a stub implementation for testing and middleware
+    pub fn new_stub() -> impl FolderUseCase {
+        struct FolderServiceStub;
+        
+        #[async_trait]
+        impl FolderUseCase for FolderServiceStub {
+            async fn create_folder(&self, _dto: CreateFolderDto) -> Result<FolderDto, DomainError> {
+                Ok(FolderDto::empty())
+            }
+            
+            async fn get_folder(&self, _id: &str) -> Result<FolderDto, DomainError> {
+                Ok(FolderDto::empty())
+            }
+            
+            async fn get_folder_by_path(&self, _path: &str) -> Result<FolderDto, DomainError> {
+                Ok(FolderDto::empty())
+            }
+            
+            async fn list_folders(&self, _parent_id: Option<&str>) -> Result<Vec<FolderDto>, DomainError> {
+                Ok(vec![])
+            }
+            
+            async fn list_folders_paginated(
+                &self, 
+                _parent_id: Option<&str>,
+                _pagination: &crate::application::dtos::pagination::PaginationRequestDto
+            ) -> Result<crate::application::dtos::pagination::PaginatedResponseDto<FolderDto>, DomainError> {
+                Ok(crate::application::dtos::pagination::PaginatedResponseDto::new(
+                    vec![],
+                    0,
+                    10,
+                    0
+                ))
+            }
+            
+            async fn rename_folder(&self, _id: &str, _dto: RenameFolderDto) -> Result<FolderDto, DomainError> {
+                Ok(FolderDto::empty())
+            }
+            
+            async fn move_folder(&self, _id: &str, _dto: MoveFolderDto) -> Result<FolderDto, DomainError> {
+                Ok(FolderDto::empty())
+            }
+            
+            async fn delete_folder(&self, _id: &str) -> Result<(), DomainError> {
+                Ok(())
+            }
+        }
+        
+        FolderServiceStub
+    }
 }

 #[async_trait]
@@ -9,6 +9,7 @@ pub mod file_upload_service;
 pub mod file_retrieval_service;
 pub mod file_management_service;
 pub mod file_use_case_factory;
+pub mod auth_application_service;

 // Re-exportar para facilitar acceso
 pub use file_upload_service::FileUploadService;