configuring backend topology

2025-03-28 12:38:48 +01:00
parent da520db0b3
commit 3a4cb75ac7
21 changed files with 2048 additions and 103 deletions
@@ -5,6 +5,7 @@ pub mod batch_handler;
 pub mod auth_handler;
 pub mod trash_handler;
 pub mod search_handler;
+pub mod share_handler;

 /// Tipo de resultado para controladores de API
 pub type ApiResult<T> = Result<T, (axum::http::StatusCode, String)>;
@@ -0,0 +1,181 @@
+use std::sync::Arc;
+
+use axum::{
+    extract::{Path, Query, State},
+    http::StatusCode,
+    response::IntoResponse,
+    Json,
+};
+use serde::Deserialize;
+use serde_json::json;
+
+use crate::{
+    application::{
+        dtos::share_dto::{CreateShareDto, UpdateShareDto}, 
+        ports::share_ports::ShareUseCase
+    },
+    common::errors::{DomainError, ErrorKind},
+};
+
+#[derive(Debug, Deserialize)]
+pub struct GetSharesQuery {
+    pub page: Option<usize>,
+    pub per_page: Option<usize>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct VerifyPasswordRequest {
+    pub password: String,
+}
+
+/// Create a new shared link
+pub async fn create_shared_link(
+    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    Json(dto): Json<CreateShareDto>,
+) -> impl IntoResponse {
+    // For now, we'll use a default user ID until auth is implemented
+    let user_id = "default-user";
+    match share_use_case.create_shared_link(&user_id, dto).await {
+        Ok(share) => (StatusCode::CREATED, Json(share)).into_response(),
+        Err(err) => {
+            let status = match err.kind {
+                ErrorKind::NotFound => StatusCode::NOT_FOUND,
+                ErrorKind::InvalidInput => StatusCode::BAD_REQUEST,
+                _ => StatusCode::INTERNAL_SERVER_ERROR,
+            };
+            (status, Json(json!({ "error": err.to_string() }))).into_response()
+        }
+    }
+}
+
+/// Get information about a specific shared link by ID
+pub async fn get_shared_link(
+    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    Path(id): Path<String>,
+) -> impl IntoResponse {
+    match share_use_case.get_shared_link(&id).await {
+        Ok(share) => (StatusCode::OK, Json(share)).into_response(),
+        Err(err) => {
+            let status = match err.kind {
+                ErrorKind::NotFound => StatusCode::NOT_FOUND,
+                _ => StatusCode::INTERNAL_SERVER_ERROR,
+            };
+            (status, Json(json!({ "error": err.to_string() }))).into_response()
+        }
+    }
+}
+
+/// Get all shared links created by the current user
+pub async fn get_user_shares(
+    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    Query(query): Query<GetSharesQuery>,
+) -> impl IntoResponse {
+    // For now, we'll use a default user ID until auth is implemented
+    let user_id = "default-user";
+    let page = query.page.unwrap_or(1);
+    let per_page = query.per_page.unwrap_or(20);
+    
+    match share_use_case.get_user_shared_links(&user_id, page, per_page).await {
+        Ok(shares) => (StatusCode::OK, Json(shares)).into_response(),
+        Err(err) => (StatusCode::INTERNAL_SERVER_ERROR, Json(json!({ "error": err.to_string() }))).into_response()
+    }
+}
+
+/// Update a shared link's properties
+pub async fn update_shared_link(
+    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    Path(id): Path<String>,
+    Json(dto): Json<UpdateShareDto>,
+) -> impl IntoResponse {
+    match share_use_case.update_shared_link(&id, dto).await {
+        Ok(share) => (StatusCode::OK, Json(share)).into_response(),
+        Err(err) => {
+            let status = match err.kind {
+                ErrorKind::NotFound => StatusCode::NOT_FOUND,
+                ErrorKind::AccessDenied => StatusCode::FORBIDDEN,
+                ErrorKind::InvalidInput => StatusCode::BAD_REQUEST,
+                _ => StatusCode::INTERNAL_SERVER_ERROR,
+            };
+            (status, Json(json!({ "error": err.to_string() }))).into_response()
+        }
+    }
+}
+
+/// Delete a shared link
+pub async fn delete_shared_link(
+    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    Path(id): Path<String>,
+) -> impl IntoResponse {
+    match share_use_case.delete_shared_link(&id).await {
+        Ok(_) => StatusCode::NO_CONTENT.into_response(),
+        Err(err) => {
+            let status = match err.kind {
+                ErrorKind::NotFound => StatusCode::NOT_FOUND,
+                ErrorKind::AccessDenied => StatusCode::FORBIDDEN,
+                _ => StatusCode::INTERNAL_SERVER_ERROR,
+            };
+            (status, Json(json!({ "error": err.to_string() }))).into_response()
+        }
+    }
+}
+
+/// Access a shared item via its token
+pub async fn access_shared_item(
+    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    Path(token): Path<String>,
+) -> impl IntoResponse {
+    // Register the access
+    let _ = share_use_case.register_shared_link_access(&token).await;
+    
+    // Get the shared link
+    match share_use_case.get_shared_link_by_token(&token).await {
+        Ok(item) => (StatusCode::OK, Json(item)).into_response(),
+        Err(err) => {
+            let status = match err.kind {
+                ErrorKind::NotFound => StatusCode::NOT_FOUND,
+                ErrorKind::AccessDenied => {
+                    if err.message.contains("expired") {
+                        StatusCode::GONE // HTTP 410 Gone for expired links
+                    } else if err.message.contains("password") {
+                        return (StatusCode::UNAUTHORIZED, Json(json!({ 
+                            "error": "Password required", 
+                            "requiresPassword": true 
+                        }))).into_response();
+                    } else {
+                        StatusCode::FORBIDDEN
+                    }
+                },
+                _ => StatusCode::INTERNAL_SERVER_ERROR,
+            };
+            
+            (status, Json(json!({ "error": err.to_string() }))).into_response()
+        }
+    }
+}
+
+/// Verify password for a password-protected shared item
+pub async fn verify_shared_item_password(
+    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    Path(token): Path<String>,
+    Json(req): Json<VerifyPasswordRequest>,
+) -> impl IntoResponse {
+    match share_use_case.verify_shared_link_password(&token, &req.password).await {
+        Ok(item) => (StatusCode::OK, Json(item)).into_response(),
+        Err(err) => {
+            let status = match err.kind {
+                ErrorKind::NotFound => StatusCode::NOT_FOUND,
+                ErrorKind::AccessDenied => {
+                    if err.message.contains("expired") {
+                        StatusCode::GONE
+                    } else if err.message.contains("password") {
+                        StatusCode::UNAUTHORIZED
+                    } else {
+                        StatusCode::FORBIDDEN
+                    }
+                },
+                _ => StatusCode::INTERNAL_SERVER_ERROR,
+            };
+            (status, Json(json!({ "error": err.to_string() }))).into_response()
+        }
+    }
+}
@@ -24,10 +24,12 @@ use crate::application::services::i18n_application_service::I18nApplicationServi
 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::interfaces::api::handlers::folder_handler::FolderHandler;
 use crate::interfaces::api::handlers::file_handler::FileHandler;
 use crate::interfaces::api::handlers::i18n_handler::I18nHandler;
+// Eliminamos la importación de ShareHandler ya que ahora usamos directamente el servicio
 use crate::interfaces::api::handlers::batch_handler::{
    self, BatchHandlerState
 };
@@ -40,6 +42,7 @@ pub fn create_api_routes(
    i18n_service: Option<Arc<I18nApplicationService>>,
    trash_service: Option<Arc<dyn TrashUseCase>>,
    search_service: Option<Arc<dyn SearchUseCase>>,
+    share_service: Option<Arc<dyn ShareUseCase>>,
 ) -> Router<crate::common::di::AppState> {
    // Create a simplified AppState for the trash view
    // Setup required components for repository construction
@@ -72,7 +75,7 @@ pub fn create_api_routes(
        path_service.clone(),
    ));
    
-    let app_state = crate::common::di::AppState {
+    let mut app_state = crate::common::di::AppState {
        core: crate::common::di::CoreServices {
            path_service: path_service.clone(),
            cache_manager: Arc::new(crate::infrastructure::services::cache_manager::StorageCacheManager::default()),
@@ -102,10 +105,12 @@ 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
        },
        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
    };
    // Inicializar el servicio de operaciones por lotes
    let batch_service = Arc::new(BatchOperationService::default(
@@ -284,12 +289,49 @@ pub fn create_api_routes(
        Router::new()
    };
    
+    // Implementaciones directas de handlers para compartir, sin depender de ShareHandler
+    
+    // Create routes for shared resources if the service is available
+    let share_router = if let Some(share_service) = share_service.clone() {
+        use crate::interfaces::api::handlers::share_handler;
+        
+        Router::new()
+            .route("/", post(share_handler::create_shared_link))
+            .route("/", get(share_handler::get_user_shares))
+            .route("/{id}", get(share_handler::get_shared_link))
+            .route("/{id}", put(share_handler::update_shared_link))
+            .route("/{id}", delete(share_handler::delete_shared_link))
+            .with_state(share_service.clone())
+    } else {
+        Router::new()
+    };
+    
+    // Public route for accessing shared links
+    let public_share_router = if let Some(share_service) = share_service.clone() {
+        use crate::interfaces::api::handlers::share_handler;
+        
+        Router::new()
+            .route("/{token}", get(share_handler::access_shared_item))
+            .route("/{token}/verify", post(share_handler::verify_shared_item_password))
+            .with_state(share_service.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("/search", search_router);
+        .nest("/search", search_router)
+        .nest("/shares", share_router)
+        .nest("/s", public_share_router)
+        ;
+    
+    // Store the share service in app_state for future use
+    if let Some(share_service) = share_service.clone() {
+        app_state.share_service = Some(share_service);
+    }
        
    // Re-enable trash routes to make the trash view work
    if let Some(_trash_service_ref) = trash_service.clone() {