adding search engine

src/interfaces/api/handlers/mod.rs

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

src/interfaces/api/handlers/search_handler.rs

@@ -0,0 +1,225 @@
+use axum::{
+    extract::{State, Query, Json},
+    response::IntoResponse,
+    http::StatusCode,
+};
+use serde_json::json;
+use tracing::{info, error};
+
+use crate::application::dtos::search_dto::SearchCriteriaDto;
+use crate::common::di::AppState;
+
+/**
+ * Manejador para las operaciones de búsqueda a través de la API.
+ * 
+ * Este manejador expone endpoints relacionados con la funcionalidad de búsqueda,
+ * permitiendo a los usuarios buscar archivos y carpetas usando diversos criterios.
+ */
+pub struct SearchHandler;
+
+impl SearchHandler {
+    /**
+     * Realiza una búsqueda basada en los criterios proporcionados como parámetros de consulta.
+     * 
+     * Este endpoint permite búsquedas simples directamente con parámetros URL.
+     * 
+     * @param state Estado de la aplicación con servicios
+     * @param query_params Parámetros de búsqueda como query string
+     * @return Respuesta HTTP con los resultados de la búsqueda
+     */
+    pub async fn search_files_get(
+        State(state): State<AppState>,
+        Query(params): Query<SearchParams>,
+    ) -> impl IntoResponse {
+        info!("API: Búsqueda de archivos con parámetros: {:?}", params);
+        
+        // Extraer el servicio de búsqueda o devolver error si no está disponible
+        let search_service = match &state.applications.search_service {
+            Some(service) => service,
+            None => {
+                error!("Servicio de búsqueda no disponible");
+                return (
+                    StatusCode::SERVICE_UNAVAILABLE,
+                    Json(json!({
+                        "error": "Search service is not available"
+                    }))
+                ).into_response();
+            }
+        };
+        
+        // Convertir parámetros de búsqueda a DTO
+        let search_criteria = SearchCriteriaDto {
+            name_contains: params.query,
+            file_types: params.type_filter.map(|t| t.split(',').map(|s| s.trim().to_string()).collect()),
+            created_after: params.created_after,
+            created_before: params.created_before,
+            modified_after: params.modified_after,
+            modified_before: params.modified_before,
+            min_size: params.min_size,
+            max_size: params.max_size,
+            folder_id: params.folder_id,
+            recursive: params.recursive.unwrap_or(true),
+            limit: params.limit.unwrap_or(100),
+            offset: params.offset.unwrap_or(0),
+        };
+        
+        // Realizar la búsqueda
+        match search_service.search(search_criteria).await {
+            Ok(results) => {
+                info!("Búsqueda completada, {} archivos y {} carpetas encontrados", 
+                     results.files.len(), results.folders.len());
+                (StatusCode::OK, Json(results)).into_response()
+            },
+            Err(err) => {
+                error!("Error en búsqueda: {}", err);
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(json!({
+                        "error": format!("Search error: {}", err)
+                    }))
+                ).into_response()
+            }
+        }
+    }
+    
+    /**
+     * Realiza una búsqueda avanzada basada en un objeto de criterios JSON completo.
+     * 
+     * Este endpoint permite búsquedas más complejas con todos los criterios posibles
+     * proporcionados en el cuerpo de la solicitud.
+     * 
+     * @param state Estado de la aplicación con servicios
+     * @param criteria Criterios de búsqueda completos
+     * @return Respuesta HTTP con los resultados de la búsqueda
+     */
+    pub async fn search_files_post(
+        State(state): State<AppState>,
+        Json(criteria): Json<SearchCriteriaDto>,
+    ) -> impl IntoResponse {
+        info!("API: Búsqueda avanzada de archivos");
+        
+        // Extraer el servicio de búsqueda o devolver error si no está disponible
+        let search_service = match &state.applications.search_service {
+            Some(service) => service,
+            None => {
+                error!("Servicio de búsqueda no disponible");
+                return (
+                    StatusCode::SERVICE_UNAVAILABLE,
+                    Json(json!({
+                        "error": "Search service is not available"
+                    }))
+                ).into_response();
+            }
+        };
+        
+        // Realizar la búsqueda
+        match search_service.search(criteria).await {
+            Ok(results) => {
+                info!("Búsqueda completada, {} archivos y {} carpetas encontrados", 
+                     results.files.len(), results.folders.len());
+                (StatusCode::OK, Json(results)).into_response()
+            },
+            Err(err) => {
+                error!("Error en búsqueda: {}", err);
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(json!({
+                        "error": format!("Search error: {}", err)
+                    }))
+                ).into_response()
+            }
+        }
+    }
+    
+    /**
+     * Limpia la caché de resultados de búsqueda.
+     * 
+     * Este endpoint es útil para forzar búsquedas frescas después de cambios
+     * significativos en el sistema de archivos.
+     * 
+     * @param state Estado de la aplicación con servicios
+     * @return Respuesta HTTP indicando éxito o error
+     */
+    pub async fn clear_search_cache(
+        State(state): State<AppState>,
+    ) -> impl IntoResponse {
+        info!("API: Limpiando caché de búsqueda");
+        
+        // Extraer el servicio de búsqueda o devolver error si no está disponible
+        let search_service = match &state.applications.search_service {
+            Some(service) => service,
+            None => {
+                error!("Servicio de búsqueda no disponible");
+                return (
+                    StatusCode::SERVICE_UNAVAILABLE,
+                    Json(json!({
+                        "error": "Search service is not available"
+                    }))
+                ).into_response();
+            }
+        };
+        
+        // Limpiar la caché
+        match search_service.clear_search_cache().await {
+            Ok(_) => {
+                info!("Caché de búsqueda limpiada correctamente");
+                (
+                    StatusCode::OK,
+                    Json(json!({
+                        "message": "Search cache cleared successfully"
+                    }))
+                ).into_response()
+            },
+            Err(err) => {
+                error!("Error al limpiar caché de búsqueda: {}", err);
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(json!({
+                        "error": format!("Error clearing search cache: {}", err)
+                    }))
+                ).into_response()
+            }
+        }
+    }
+}
+
+/// Parámetros de búsqueda para el endpoint GET
+#[derive(Debug, serde::Deserialize)]
+pub struct SearchParams {
+    /// Texto a buscar en nombres de archivos y carpetas
+    pub query: Option<String>,
+    
+    /// Filtro por tipos de archivo (extensiones separadas por comas)
+    #[serde(rename = "type")]
+    pub type_filter: Option<String>,
+    
+    /// Filtrar elementos creados después de esta fecha (timestamp)
+    pub created_after: Option<u64>,
+    
+    /// Filtrar elementos creados antes de esta fecha (timestamp)
+    pub created_before: Option<u64>,
+    
+    /// Filtrar elementos modificados después de esta fecha (timestamp)
+    pub modified_after: Option<u64>,
+    
+    /// Filtrar elementos modificados antes de esta fecha (timestamp)
+    pub modified_before: Option<u64>,
+    
+    /// Tamaño mínimo en bytes
+    pub min_size: Option<u64>,
+    
+    /// Tamaño máximo en bytes
+    pub max_size: Option<u64>,
+    
+    /// ID de carpeta para limitar la búsqueda
+    pub folder_id: Option<String>,
+    
+    /// Búsqueda recursiva en subcarpetas
+    pub recursive: Option<bool>,
+    
+    /// Límite de resultados para paginación
+    pub limit: Option<usize>,
+    
+    /// Desplazamiento para paginación
+    pub offset: Option<usize>,
+}

src/interfaces/api/routes.rs

@@ -23,6 +23,7 @@ use crate::application::services::file_service::FileService;
 use crate::application::services::i18n_application_service::I18nApplicationService;
 use crate::application::services::batch_operations::BatchOperationService;
 use crate::application::ports::trash_ports::TrashUseCase;
+use crate::application::ports::inbound::SearchUseCase;
 
 use crate::interfaces::api::handlers::folder_handler::FolderHandler;
 use crate::interfaces::api::handlers::file_handler::FileHandler;
@@ -38,6 +39,7 @@ pub fn create_api_routes(
     file_service: Arc<FileService>,
     i18n_service: Option<Arc<I18nApplicationService>>,
     trash_service: Option<Arc<dyn TrashUseCase>>,
+    search_service: Option<Arc<dyn SearchUseCase>>,
 ) -> Router<crate::common::di::AppState> {
     // Create a simplified AppState for the trash view
     // Setup required components for repository construction
@@ -99,6 +101,7 @@ pub fn create_api_routes(
                 Arc::new(crate::application::services::i18n_application_service::I18nApplicationService::dummy())
             ),
             trash_service: trash_service.clone(), // Include the trash service here too for consistency
+            search_service: search_service.clone(), // Include the search service
         },
         db_pool: None,
         auth_service: None,
@@ -265,11 +268,28 @@ pub fn create_api_routes(
         .route("/folders/get", post(batch_handler::get_folders_batch))
         .with_state(batch_handler_state);
     
+    // Create search routes if the service is available
+    let search_router = if search_service.is_some() {
+        use crate::interfaces::api::handlers::search_handler::SearchHandler;
+        
+        Router::new()
+            // Simple search with query parameters
+            .route("/", get(SearchHandler::search_files_get))
+            // Advanced search with full criteria object
+            .route("/advanced", post(SearchHandler::search_files_post))
+            // Clear search cache
+            .route("/cache", delete(SearchHandler::clear_search_cache))
+            .with_state(app_state.clone())
+    } else {
+        Router::new()
+    };
+    
     // Create a router without the i18n routes
     let mut router = Router::new()
         .nest("/folders", folders_router)
         .nest("/files", files_router)
-        .nest("/batch", batch_router);
+        .nest("/batch", batch_router)
+        .nest("/search", search_router);
         
     // Re-enable trash routes to make the trash view work
     if let Some(trash_service_ref) = trash_service.clone() {