adding favorite feature

src/application/dtos/favorites_dto.rs

@@ -0,0 +1,21 @@
+use serde::{Deserialize, Serialize};
+use chrono::{DateTime, Utc};
+
+/// DTO for favorites item
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FavoriteItemDto {
+    /// Unique identifier for the favorite entry
+    pub id: String,
+    
+    /// User ID who owns this favorite
+    pub user_id: String,
+    
+    /// ID of the favorited item (file or folder)
+    pub item_id: String,
+    
+    /// Type of the item ('file' or 'folder')
+    pub item_type: String,
+    
+    /// When the item was added to favorites
+    pub created_at: DateTime<Utc>,
+}

src/application/dtos/mod.rs

@@ -6,4 +6,5 @@ pub mod user_dto;
 pub mod trash_dto;
 pub mod search_dto;
 pub mod share_dto;
+pub mod favorites_dto;
 

src/application/ports/favorites_ports.rs

@@ -0,0 +1,19 @@
+use async_trait::async_trait;
+use crate::common::errors::Result;
+use crate::application::dtos::favorites_dto::FavoriteItemDto;
+
+/// Defines operations for managing user favorites
+#[async_trait]
+pub trait FavoritesUseCase: Send + Sync {
+    /// Get all favorites for a user
+    async fn get_favorites(&self, user_id: &str) -> Result<Vec<FavoriteItemDto>>;
+    
+    /// Add an item to user's favorites
+    async fn add_to_favorites(&self, user_id: &str, item_id: &str, item_type: &str) -> Result<()>;
+    
+    /// Remove an item from user's favorites
+    async fn remove_from_favorites(&self, user_id: &str, item_id: &str, item_type: &str) -> Result<bool>;
+    
+    /// Check if an item is in user's favorites
+    async fn is_favorite(&self, user_id: &str, item_id: &str, item_type: &str) -> Result<bool>;
+}

src/application/ports/mod.rs

@@ -4,4 +4,5 @@ pub mod file_ports;
 pub mod storage_ports;
 pub mod auth_ports;
 pub mod trash_ports;
-pub mod share_ports;
+pub mod share_ports;
+pub mod favorites_ports;

src/application/services/favorites_service.rs

@@ -0,0 +1,191 @@
+use std::sync::Arc;
+use async_trait::async_trait;
+use sqlx::{PgPool, Row};
+use tracing::{info, error};
+use uuid::Uuid;
+use crate::common::errors::{Result, DomainError, ErrorKind};
+use crate::application::ports::favorites_ports::FavoritesUseCase;
+use crate::application::dtos::favorites_dto::FavoriteItemDto;
+
+/// Implementation of the FavoritesUseCase for managing user favorites
+pub struct FavoritesService {
+    db_pool: Arc<PgPool>,
+}
+
+impl FavoritesService {
+    /// Create a new FavoritesService with the given database pool
+    pub fn new(db_pool: Arc<PgPool>) -> Self {
+        Self { db_pool }
+    }
+}
+
+#[async_trait]
+impl FavoritesUseCase for FavoritesService {
+    /// Get all favorites for a user
+    async fn get_favorites(&self, user_id: &str) -> Result<Vec<FavoriteItemDto>> {
+        info!("Getting favorites for user: {}", user_id);
+        
+        // Parse user ID as UUID
+        let user_uuid = Uuid::parse_str(user_id)?;
+        
+        // Execute raw query to avoid sqlx macros issues
+        let rows = sqlx::query(
+            r#"
+            SELECT 
+                id::TEXT as "id", 
+                user_id::TEXT as "user_id", 
+                item_id as "item_id", 
+                item_type as "item_type", 
+                created_at as "created_at"
+            FROM auth.user_favorites 
+            WHERE user_id = $1
+            ORDER BY created_at DESC
+            "#
+        )
+        .bind(user_uuid)
+        .fetch_all(&*self.db_pool)
+        .await
+        .map_err(|e| {
+            error!("Database error fetching favorites: {}", e);
+            DomainError::new(
+                ErrorKind::InternalError,
+                "Favorites",
+                format!("Failed to fetch favorites: {}", e)
+            )
+        })?;
+        
+        // Map rows to DTOs
+        let mut favorites = Vec::with_capacity(rows.len());
+        for row in rows {
+            favorites.push(FavoriteItemDto {
+                id: row.get("id"),
+                user_id: row.get("user_id"),
+                item_id: row.get("item_id"),
+                item_type: row.get("item_type"),
+                created_at: row.get("created_at"),
+            });
+        }
+        
+        info!("Retrieved {} favorites for user {}", favorites.len(), user_id);
+        Ok(favorites)
+    }
+    
+    /// Add an item to user's favorites
+    async fn add_to_favorites(&self, user_id: &str, item_id: &str, item_type: &str) -> Result<()> {
+        info!("Adding {} '{}' to favorites for user {}", item_type, item_id, user_id);
+        
+        // Validate item_type
+        if item_type != "file" && item_type != "folder" {
+            return Err(DomainError::new(
+                ErrorKind::InvalidInput,
+                "Favorites",
+                "Item type must be 'file' or 'folder'"
+            ));
+        }
+        
+        // Parse user ID as UUID
+        let user_uuid = Uuid::parse_str(user_id)?;
+        
+        // Execute raw query to avoid sqlx macros issues
+        sqlx::query(
+            r#"
+            INSERT INTO auth.user_favorites (user_id, item_id, item_type)
+            VALUES ($1, $2, $3)
+            ON CONFLICT (user_id, item_id, item_type) DO NOTHING
+            "#
+        )
+        .bind(user_uuid)
+        .bind(item_id)
+        .bind(item_type)
+        .execute(&*self.db_pool)
+        .await
+        .map_err(|e| {
+            error!("Database error adding favorite: {}", e);
+            DomainError::new(
+                ErrorKind::InternalError,
+                "Favorites",
+                format!("Failed to add to favorites: {}", e)
+            )
+        })?;
+        
+        info!("Successfully added {} '{}' to favorites for user {}", item_type, item_id, user_id);
+        Ok(())
+    }
+    
+    /// Remove an item from user's favorites
+    async fn remove_from_favorites(&self, user_id: &str, item_id: &str, item_type: &str) -> Result<bool> {
+        info!("Removing {} '{}' from favorites for user {}", item_type, item_id, user_id);
+        
+        // Parse user ID as UUID
+        let user_uuid = Uuid::parse_str(user_id)?;
+        
+        // Execute raw query to avoid sqlx macros issues
+        let result = sqlx::query(
+            r#"
+            DELETE FROM auth.user_favorites
+            WHERE user_id = $1 AND item_id = $2 AND item_type = $3
+            "#
+        )
+        .bind(user_uuid)
+        .bind(item_id)
+        .bind(item_type)
+        .execute(&*self.db_pool)
+        .await
+        .map_err(|e| {
+            error!("Database error removing favorite: {}", e);
+            DomainError::new(
+                ErrorKind::InternalError,
+                "Favorites",
+                format!("Failed to remove from favorites: {}", e)
+            )
+        })?;
+        
+        let removed = result.rows_affected() > 0;
+        info!(
+            "{} {} '{}' from favorites for user {}", 
+            if removed { "Successfully removed" } else { "Did not find" },
+            item_type, 
+            item_id, 
+            user_id
+        );
+        
+        Ok(removed)
+    }
+    
+    /// Check if an item is in user's favorites
+    async fn is_favorite(&self, user_id: &str, item_id: &str, item_type: &str) -> Result<bool> {
+        info!("Checking if {} '{}' is favorite for user {}", item_type, item_id, user_id);
+        
+        // Parse user ID as UUID
+        let user_uuid = Uuid::parse_str(user_id)?;
+        
+        // Execute raw query to avoid sqlx macros issues
+        let row = sqlx::query(
+            r#"
+            SELECT EXISTS (
+                SELECT 1 FROM auth.user_favorites
+                WHERE user_id = $1 AND item_id = $2 AND item_type = $3
+            ) AS "is_favorite"
+            "#
+        )
+        .bind(user_uuid)
+        .bind(item_id)
+        .bind(item_type)
+        .fetch_one(&*self.db_pool)
+        .await
+        .map_err(|e| {
+            error!("Database error checking favorite status: {}", e);
+            DomainError::new(
+                ErrorKind::InternalError,
+                "Favorites",
+                format!("Failed to check favorite status: {}", e)
+            )
+        })?;
+        
+        // Get the boolean value from the row
+        let is_favorite: bool = row.try_get("is_favorite")
+            .unwrap_or(false);
+        
+        Ok(is_favorite)
+    }
+}

src/application/services/mod.rs

@@ -13,6 +13,7 @@ pub mod auth_application_service;
 pub mod trash_service;
 pub mod search_service;
 pub mod share_service;
+pub mod favorites_service;
 
 #[cfg(test)]
 mod trash_service_test;

src/common/di.rs

@@ -21,6 +21,7 @@ use crate::application::ports::trash_ports::TrashUseCase;
 use crate::application::services::storage_mediator::{StorageMediator, FileSystemStorageMediator};
 use crate::application::ports::inbound::{FileUseCase, FolderUseCase, SearchUseCase};
 use crate::application::ports::outbound::{FileStoragePort, FolderStoragePort};
+use crate::application::ports::favorites_ports::FavoritesUseCase;
 use crate::application::ports::file_ports::{FileUploadUseCase, FileRetrievalUseCase, FileManagementUseCase, FileUseCaseFactory};
 use crate::application::ports::storage_ports::{FileReadPort, FileWritePort};
 use crate::infrastructure::repositories::{FileMetadataManager, FilePathResolver, FileFsReadRepository, FileFsWriteRepository};
@@ -240,6 +241,7 @@ impl AppServiceFactory {
             trash_service,
             search_service,
             share_service: None, // No share service by default
+            favorites_service: None // No favorites service by default
         }
     }
 }
@@ -283,6 +285,7 @@ pub struct ApplicationServices {
     pub trash_service: Option<Arc<dyn TrashUseCase>>,
     pub search_service: Option<Arc<dyn SearchUseCase>>,
     pub share_service: Option<Arc<dyn crate::application::ports::share_ports::ShareUseCase>>,
+    pub favorites_service: Option<Arc<dyn FavoritesUseCase>>,
 }
 
 /// Contenedor para servicios de autenticación
@@ -303,6 +306,7 @@ pub struct AppState {
     pub auth_service: Option<AuthServices>,
     pub trash_service: Option<Arc<dyn TrashUseCase>>,
     pub share_service: Option<Arc<dyn crate::application::ports::share_ports::ShareUseCase>>,
+    pub favorites_service: Option<Arc<dyn FavoritesUseCase>>,
 }
 
 impl Default for AppState {
@@ -772,6 +776,7 @@ impl Default for AppState {
             trash_service: None, // No trash service in minimal mode
             search_service: Some(Arc::new(DummySearchUseCase) as Arc<dyn crate::application::ports::inbound::SearchUseCase>),
             share_service: None, // No share service in minimal mode
+            favorites_service: None, // No favorites service in minimal mode
         };
         
         // Return a minimal app state
@@ -783,6 +788,7 @@ impl Default for AppState {
             auth_service: None,
             trash_service: None,
             share_service: None,
+            favorites_service: None,
         }
     }
 }
@@ -801,6 +807,7 @@ impl AppState {
             auth_service: None,
             trash_service: None,
             share_service: None,
+            favorites_service: None,
         }
     }
     
@@ -823,4 +830,9 @@ impl AppState {
         self.share_service = Some(share_service);
         self
     }
+    
+    pub fn with_favorites_service(mut self, favorites_service: Arc<dyn FavoritesUseCase>) -> Self {
+        self.favorites_service = Some(favorites_service);
+        self
+    }
 }

src/common/errors.rs

@@ -238,6 +238,8 @@ macro_rules! impl_from_error {
 // Implementación para errores estándar comunes
 impl_from_error!(std::io::Error, "IO");
 impl_from_error!(serde_json::Error, "Serialization");
+impl_from_error!(sqlx::Error, "Database");
+impl_from_error!(uuid::Error, "UUID");
 
 // Error para capas HTTP/API
 #[derive(Debug)]

src/interfaces/api/handlers/favorites_handler.rs

@@ -0,0 +1,118 @@
+use std::sync::Arc;
+use axum::{
+    extract::{Path, State},
+    http::StatusCode,
+    response::IntoResponse,
+    Json,
+};
+use serde::{Deserialize, Serialize};
+use tracing::{error, info};
+use uuid::Uuid;
+
+use crate::application::ports::favorites_ports::FavoritesUseCase;
+use crate::application::dtos::favorites_dto::FavoriteItemDto;
+use crate::common::errors::{Result, DomainError, ErrorKind};
+
+/// Handler for favorite-related API endpoints
+pub async fn get_favorites(
+    State(favorites_service): State<Arc<dyn FavoritesUseCase>>,
+) -> impl IntoResponse {
+    // For demo purposes, we're using a fixed user ID
+    let user_id = "00000000-0000-0000-0000-000000000000";
+    
+    match favorites_service.get_favorites(user_id).await {
+        Ok(favorites) => {
+            info!("Retrieved {} favorites for user", favorites.len());
+            (StatusCode::OK, Json(serde_json::json!(favorites))).into_response()
+        },
+        Err(err) => {
+            error!("Error retrieving favorites: {}", err);
+            (
+                StatusCode::INTERNAL_SERVER_ERROR, 
+                Json(serde_json::json!({
+                    "error": format!("Failed to retrieve favorites: {}", err)
+                }))
+            ).into_response()
+        }
+    }
+}
+
+/// Add an item to user's favorites
+pub async fn add_favorite(
+    State(favorites_service): State<Arc<dyn FavoritesUseCase>>,
+    Path((item_type, item_id)): Path<(String, String)>,
+) -> impl IntoResponse {
+    // For demo purposes, we're using a fixed user ID
+    let user_id = "00000000-0000-0000-0000-000000000000";
+    
+    // Validate item_type
+    if item_type != "file" && item_type != "folder" {
+        return (
+            StatusCode::BAD_REQUEST, 
+            Json(serde_json::json!({
+                "error": "Item type must be 'file' or 'folder'"
+            }))
+        );
+    }
+    
+    match favorites_service.add_to_favorites(user_id, &item_id, &item_type).await {
+        Ok(_) => {
+            info!("Added {} '{}' to favorites", item_type, item_id);
+            (
+                StatusCode::CREATED, 
+                Json(serde_json::json!({
+                    "message": "Item added to favorites"
+                }))
+            )
+        },
+        Err(err) => {
+            error!("Error adding to favorites: {}", err);
+            (
+                StatusCode::INTERNAL_SERVER_ERROR, 
+                Json(serde_json::json!({
+                    "error": format!("Failed to add to favorites: {}", err)
+                }))
+            )
+        }
+    }
+}
+
+/// Remove an item from user's favorites
+pub async fn remove_favorite(
+    State(favorites_service): State<Arc<dyn FavoritesUseCase>>,
+    Path((item_type, item_id)): Path<(String, String)>,
+) -> impl IntoResponse {
+    // For demo purposes, we're using a fixed user ID
+    let user_id = "00000000-0000-0000-0000-000000000000";
+    
+    match favorites_service.remove_from_favorites(user_id, &item_id, &item_type).await {
+        Ok(removed) => {
+            if removed {
+                info!("Removed {} '{}' from favorites", item_type, item_id);
+                (
+                    StatusCode::OK, 
+                    Json(serde_json::json!({
+                        "message": "Item removed from favorites"
+                    }))
+                )
+            } else {
+                info!("Item {} '{}' was not in favorites", item_type, item_id);
+                (
+                    StatusCode::NOT_FOUND, 
+                    Json(serde_json::json!({
+                        "message": "Item was not in favorites"
+                    }))
+                )
+            }
+        },
+        Err(err) => {
+            error!("Error removing from favorites: {}", err);
+            (
+                StatusCode::INTERNAL_SERVER_ERROR, 
+                Json(serde_json::json!({
+                    "error": format!("Failed to remove from favorites: {}", err)
+                }))
+            )
+        }
+    }
+}

src/interfaces/api/handlers/mod.rs

@@ -6,6 +6,7 @@ pub mod auth_handler;
 pub mod trash_handler;
 pub mod search_handler;
 pub mod share_handler;
+pub mod favorites_handler;
 
 /// Tipo de resultado para controladores de API
 pub type ApiResult<T> = Result<T, (axum::http::StatusCode, String)>;

src/interfaces/api/routes.rs

@@ -25,6 +25,7 @@ use crate::application::services::batch_operations::BatchOperationService;
 use crate::application::ports::trash_ports::TrashUseCase;
 use crate::application::ports::inbound::SearchUseCase;
 use crate::application::ports::share_ports::ShareUseCase;
+use crate::application::ports::favorites_ports::FavoritesUseCase;
 
 use crate::interfaces::api::handlers::folder_handler::FolderHandler;
 use crate::interfaces::api::handlers::file_handler::FileHandler;
@@ -43,6 +44,7 @@ pub fn create_api_routes(
     trash_service: Option<Arc<dyn TrashUseCase>>,
     search_service: Option<Arc<dyn SearchUseCase>>,
     share_service: Option<Arc<dyn ShareUseCase>>,
+    favorites_service: Option<Arc<dyn FavoritesUseCase>>,
 ) -> Router<crate::common::di::AppState> {
     // Create a simplified AppState for the trash view
     // Setup required components for repository construction
@@ -106,11 +108,13 @@ pub fn create_api_routes(
             trash_service: trash_service.clone(), // Include the trash service here too for consistency
             search_service: search_service.clone(), // Include the search service
             share_service: share_service.clone(), // Include the share service
+            favorites_service: favorites_service.clone(), // Include the favorites service
         },
         db_pool: None,
         auth_service: None,
         trash_service: trash_service.clone(), // This is the important part - include the trash service
-        share_service: share_service.clone() // Include the share service for routes
+        share_service: share_service.clone(), // Include the share service for routes
+        favorites_service: favorites_service.clone() // Include the favorites service for routes
     };
     // Inicializar el servicio de operaciones por lotes
     let batch_service = Arc::new(BatchOperationService::default(
@@ -324,6 +328,19 @@ pub fn create_api_routes(
     };
 
     // Create a router without the i18n routes
+    // Create routes for favorites if the service is available
+    let favorites_router = if let Some(favorites_service) = favorites_service.clone() {
+        use crate::interfaces::api::handlers::favorites_handler;
+        
+        Router::new()
+            .route("/", get(favorites_handler::get_favorites))
+            .route("/{item_type}/{item_id}", post(favorites_handler::add_favorite))
+            .route("/{item_type}/{item_id}", delete(favorites_handler::remove_favorite))
+            .with_state(favorites_service.clone())
+    } else {
+        Router::new()
+    };
+
     let mut router = Router::new()
         .nest("/folders", folders_router)
         .nest("/files", files_router)
@@ -331,6 +348,7 @@ pub fn create_api_routes(
         .nest("/search", search_router)
         .nest("/shares", share_router)
         .nest("/s", public_share_router)
+        .nest("/favorites", favorites_router)
         ;
     
     // Store the share service in app_state for future use

src/main.rs

@@ -46,6 +46,7 @@ use application::services::file_service::FileService;
 use application::services::i18n_application_service::I18nApplicationService;
 use application::services::storage_mediator::FileSystemStorageMediator;
 use application::services::share_service::ShareService;
+use application::services::favorites_service::FavoritesService;
 use domain::services::path_service::PathService;
 use infrastructure::repositories::folder_fs_repository::FolderFsRepository;
 use infrastructure::repositories::file_fs_repository::FileFsRepository;
@@ -614,6 +615,21 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         None
     };
 
+    // Initialize favorites service if database is available
+    let favorites_service: Option<Arc<dyn application::ports::favorites_ports::FavoritesUseCase>> = 
+    if let Some(ref pool) = db_pool {
+        // Create a new favorites service with the database pool
+        let favorites_service = Arc::new(FavoritesService::new(
+            pool.clone()
+        ));
+        
+        tracing::info!("Favorites service initialized successfully");
+        Some(favorites_service)
+    } else {
+        tracing::info!("Favorites service is disabled (requires database connection)");
+        None
+    };
+
     let application_services = common::di::ApplicationServices {
         folder_service: folder_service.clone(),
         file_service: file_service.clone(),
@@ -625,6 +641,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         trash_service: trash_service.clone(),
         search_service: search_service.clone(),
         share_service: share_service.clone(),
+        favorites_service: favorites_service.clone(),
     };
     
     // Create the AppState without Arc first
@@ -645,11 +662,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         app_state = app_state.with_auth_services(services);
     }
     
+    // Add favorites service if available
+    if let Some(service) = favorites_service.clone() {
+        app_state = app_state.with_favorites_service(service);
+    }
+    
     // Wrap in Arc after all modifications
     let app_state = Arc::new(app_state);
 
     // Build application router
-    let api_routes = create_api_routes(folder_service, file_service, Some(i18n_service), trash_service, search_service, share_service);
+    let api_routes = create_api_routes(folder_service, file_service, Some(i18n_service), trash_service, search_service, share_service, favorites_service);
     let web_routes = create_web_routes();
     
     // Build the app router