koprogo_api/infrastructure/web/handlers/

local_exchange_handlers.rs

use crate::application::dto::{
    CancelExchangeDto, CompleteExchangeDto, CreateLocalExchangeDto, DeleteExchangeDto,
    RateExchangeDto, RequestExchangeDto,
};
use crate::domain::entities::ExchangeType;
use crate::infrastructure::web::classification_erreurs;
use crate::infrastructure::web::middleware::scope_guard::{
    verify_building_org_access, verify_exchange_org_access, verify_owner_org_access,
};
use crate::infrastructure::web::{AppState, AuthenticatedUser};
use actix_web::{delete, get, post, put, web, HttpResponse, Responder, ResponseError};
use uuid::Uuid;

/// POST /api/v1/exchanges
/// Create a new exchange offer
#[post("/exchanges")]
pub async fn create_exchange(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    request: web::Json<CreateLocalExchangeDto>,
) -> impl Responder {
    match data
        .local_exchange_use_cases
        .create_exchange(auth.user_id, request.into_inner())
        .await
    {
        Ok(exchange) => HttpResponse::Created().json(exchange),
        Err(e) => {
            // Story 5.3 (#587), INV-4 : ce refus (fiche copropriétaire
            // absente — cas notamment d'un syndic pur) est un 403, jamais un
            // 400 générique. Même classification que shared_object_handlers,
            // pour que le frontend n'ait pas deux comportements différents
            // pour le même refus selon le module.
            if classification_erreurs::est_refus_owner_requis(&e)
                || classification_erreurs::est_interdit(&e)
            {
                HttpResponse::Forbidden().json(serde_json::json!({"error": e}))
            } else {
                HttpResponse::BadRequest().json(serde_json::json!({"error": e}))
            }
        }
    }
}

/// GET /api/v1/exchanges/:id
/// Get exchange by ID
#[get("/exchanges/{id}")]
pub async fn get_exchange(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    id: web::Path<Uuid>,
) -> impl Responder {
    // Cloisonnement : cet échange relève d'une ACP précise (#772).
    if let Err(err) = verify_exchange_org_access(
        &auth,
        *id,
        &data.local_exchange_use_cases,
        &data.building_use_cases,
        &data.acp_use_cases,
    )
    .await
    {
        return err.error_response();
    }

    match data
        .local_exchange_use_cases
        .get_exchange(id.into_inner())
        .await
    {
        Ok(exchange) => HttpResponse::Ok().json(exchange),
        Err(e) => HttpResponse::NotFound().json(serde_json::json!({"error": e})),
    }
}

/// GET /api/v1/buildings/:building_id/exchanges
/// List all exchanges for a building
#[get("/buildings/{building_id}/exchanges")]
pub async fn list_building_exchanges(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    building_id: web::Path<Uuid>,
) -> impl Responder {
    // Cloisonnement : l'immeuble visé doit relever d'une ACP que cet
    // utilisateur a le droit de voir. Sans ce contrôle, l'identité était prise
    // en paramètre puis ignorée — `_auth` — et n'importe quel utilisateur
    // authentifié lisait les échanges de n'importe quel immeuble (#772).
    if let Err(err) = verify_building_org_access(
        &auth,
        *building_id,
        &data.building_use_cases,
        &data.acp_use_cases,
    )
    .await
    {
        return err.error_response();
    }

    match data
        .local_exchange_use_cases
        .list_building_exchanges(building_id.into_inner())
        .await
    {
        Ok(exchanges) => HttpResponse::Ok().json(exchanges),
        Err(e) => HttpResponse::BadRequest().json(serde_json::json!({"error": e})),
    }
}

/// GET /api/v1/buildings/:building_id/exchanges/available
/// List available exchanges (status = Offered)
#[get("/buildings/{building_id}/exchanges/available")]
pub async fn list_available_exchanges(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    building_id: web::Path<Uuid>,
) -> impl Responder {
    // Cloisonnement : l'immeuble visé doit relever d'une ACP que cet
    // utilisateur a le droit de voir. Sans ce contrôle, l'identité était prise
    // en paramètre puis ignorée — `_auth` — et n'importe quel utilisateur
    // authentifié lisait les échanges de n'importe quel immeuble (#772).
    if let Err(err) = verify_building_org_access(
        &auth,
        *building_id,
        &data.building_use_cases,
        &data.acp_use_cases,
    )
    .await
    {
        return err.error_response();
    }

    match data
        .local_exchange_use_cases
        .list_available_exchanges(building_id.into_inner())
        .await
    {
        Ok(exchanges) => HttpResponse::Ok().json(exchanges),
        Err(e) => HttpResponse::BadRequest().json(serde_json::json!({"error": e})),
    }
}

/// GET /api/v1/owners/:owner_id/exchanges
/// List exchanges for an owner (as provider OR requester)
#[get("/owners/{owner_id}/exchanges")]
pub async fn list_owner_exchanges(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    owner_id: web::Path<Uuid>,
) -> impl Responder {
    // Cloisonnement : le copropriétaire visé doit relever d'une organisation
    // que cet utilisateur a le droit de voir. Ces routes disent ce qu'une
    // personne nommée a échangé, rendu, et combien de crédits elle détient —
    // son activité dans la copropriété, jour après jour (#772).
    if let Err(err) = verify_owner_org_access(&auth, *owner_id, &data.owner_use_cases).await {
        return err.error_response();
    }

    let owner_id = owner_id.into_inner();

    // Authorization: users can only see their own exchanges
    // Fetch owner to verify user_id mapping
    let owner = match data.owner_use_cases.get_owner(owner_id).await {
        Ok(Some(owner)) => owner,
        Ok(None) => {
            return HttpResponse::NotFound().json(serde_json::json!({
                "error": format!("Owner not found: {}", owner_id)
            }))
        }
        Err(e) => {
            return HttpResponse::InternalServerError().json(serde_json::json!({
                "error": format!("Failed to fetch owner: {}", e)
            }))
        }
    };

    // Check if the authenticated user owns this owner record
    let owner_user_id = owner
        .user_id
        .as_ref()
        .and_then(|id| Uuid::parse_str(id).ok());
    if owner_user_id != Some(auth.user_id) {
        return HttpResponse::Forbidden().json(serde_json::json!({
            "error": "You can only view your own exchanges"
        }));
    }

    match data
        .local_exchange_use_cases
        .list_owner_exchanges(owner_id)
        .await
    {
        Ok(exchanges) => HttpResponse::Ok().json(exchanges),
        Err(e) => HttpResponse::BadRequest().json(serde_json::json!({"error": e})),
    }
}

/// GET /api/v1/buildings/:building_id/exchanges/type/:exchange_type
/// List exchanges by type (Service, ObjectLoan, SharedPurchase)
#[get("/buildings/{building_id}/exchanges/type/{exchange_type}")]
pub async fn list_exchanges_by_type(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    path: web::Path<(Uuid, String)>,
) -> impl Responder {
    // Cloisonnement : l'immeuble visé doit relever d'une ACP que cet
    // utilisateur a le droit de voir. Sans ce contrôle, l'identité était prise
    // en paramètre puis ignorée — `_auth` — et n'importe quel utilisateur
    // authentifié lisait les échanges de n'importe quel immeuble (#772).
    if let Err(err) =
        verify_building_org_access(&auth, path.0, &data.building_use_cases, &data.acp_use_cases)
            .await
    {
        return err.error_response();
    }

    let (building_id, exchange_type_str) = path.into_inner();

    // Parse exchange type
    let exchange_type = match exchange_type_str.as_str() {
        "Service" => ExchangeType::Service,
        "ObjectLoan" => ExchangeType::ObjectLoan,
        "SharedPurchase" => ExchangeType::SharedPurchase,
        _ => {
            return HttpResponse::BadRequest().json(serde_json::json!({
                "error": "Invalid exchange type. Must be Service, ObjectLoan, or SharedPurchase"
            }));
        }
    };

    match data
        .local_exchange_use_cases
        .list_exchanges_by_type(building_id, exchange_type)
        .await
    {
        Ok(exchanges) => HttpResponse::Ok().json(exchanges),
        Err(e) => HttpResponse::BadRequest().json(serde_json::json!({"error": e})),
    }
}

/// POST /api/v1/exchanges/:id/request
/// Request an exchange (Offered → Requested)
#[post("/exchanges/{id}/request")]
pub async fn request_exchange(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    id: web::Path<Uuid>,
    request: web::Json<RequestExchangeDto>,
) -> impl Responder {
    // Cloisonnement : cet échange doit relever d'une ACP que cet utilisateur a
    // le droit de voir. La route n'ayant pas d'immeuble en chemin, la chaîne
    // échange → immeuble → ACP est remontée par le garde.
    //
    // Les deux notations comptent particulièrement : une note engage la
    // réputation d'un voisin dans sa propre copropriété (#772).
    if let Err(err) = verify_exchange_org_access(
        &auth,
        *id,
        &data.local_exchange_use_cases,
        &data.building_use_cases,
        &data.acp_use_cases,
    )
    .await
    {
        return err.error_response();
    }

    match data
        .local_exchange_use_cases
        .request_exchange(id.into_inner(), auth.user_id, request.into_inner())
        .await
    {
        Ok(exchange) => HttpResponse::Ok().json(exchange),
        Err(e) => HttpResponse::BadRequest().json(serde_json::json!({"error": e})),
    }
}

/// POST /api/v1/exchanges/:id/start
/// Start an exchange (Requested → InProgress)
/// Only provider can start
#[post("/exchanges/{id}/start")]
pub async fn start_exchange(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    id: web::Path<Uuid>,
) -> impl Responder {
    // Cloisonnement : cet échange doit relever d'une ACP que cet utilisateur a
    // le droit de voir. La route n'ayant pas d'immeuble en chemin, la chaîne
    // échange → immeuble → ACP est remontée par le garde.
    //
    // Les deux notations comptent particulièrement : une note engage la
    // réputation d'un voisin dans sa propre copropriété (#772).
    if let Err(err) = verify_exchange_org_access(
        &auth,
        *id,
        &data.local_exchange_use_cases,
        &data.building_use_cases,
        &data.acp_use_cases,
    )
    .await
    {
        return err.error_response();
    }

    match data
        .local_exchange_use_cases
        .start_exchange(id.into_inner(), auth.user_id)
        .await
    {
        Ok(exchange) => HttpResponse::Ok().json(exchange),
        Err(e) => HttpResponse::BadRequest().json(serde_json::json!({"error": e})),
    }
}

/// POST /api/v1/exchanges/:id/complete
/// Complete an exchange (InProgress → Completed)
/// Updates credit balances automatically
#[post("/exchanges/{id}/complete")]
pub async fn complete_exchange(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    id: web::Path<Uuid>,
    request: web::Json<CompleteExchangeDto>,
) -> impl Responder {
    // Cloisonnement : cet échange doit relever d'une ACP que cet utilisateur a
    // le droit de voir. La route n'ayant pas d'immeuble en chemin, la chaîne
    // échange → immeuble → ACP est remontée par le garde.
    //
    // Les deux notations comptent particulièrement : une note engage la
    // réputation d'un voisin dans sa propre copropriété (#772).
    if let Err(err) = verify_exchange_org_access(
        &auth,
        *id,
        &data.local_exchange_use_cases,
        &data.building_use_cases,
        &data.acp_use_cases,
    )
    .await
    {
        return err.error_response();
    }

    match data
        .local_exchange_use_cases
        .complete_exchange(id.into_inner(), auth.user_id, request.into_inner())
        .await
    {
        Ok(exchange) => HttpResponse::Ok().json(exchange),
        Err(e) => HttpResponse::BadRequest().json(serde_json::json!({"error": e})),
    }
}

/// POST /api/v1/exchanges/:id/cancel
/// Cancel an exchange
#[post("/exchanges/{id}/cancel")]
pub async fn cancel_exchange(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    id: web::Path<Uuid>,
    request: web::Json<CancelExchangeDto>,
) -> impl Responder {
    // Cloisonnement : cet échange doit relever d'une ACP que cet utilisateur a
    // le droit de voir. La route n'ayant pas d'immeuble en chemin, la chaîne
    // échange → immeuble → ACP est remontée par le garde.
    //
    // Les deux notations comptent particulièrement : une note engage la
    // réputation d'un voisin dans sa propre copropriété (#772).
    if let Err(err) = verify_exchange_org_access(
        &auth,
        *id,
        &data.local_exchange_use_cases,
        &data.building_use_cases,
        &data.acp_use_cases,
    )
    .await
    {
        return err.error_response();
    }

    match data
        .local_exchange_use_cases
        .cancel_exchange(
            id.into_inner(),
            auth.user_id,
            &auth.role,
            request.into_inner(),
        )
        .await
    {
        Ok(exchange) => HttpResponse::Ok().json(exchange),
        Err(e) => {
            if classification_erreurs::est_motif_manquant(&e) {
                HttpResponse::UnprocessableEntity().json(serde_json::json!({"error": e}))
            } else if classification_erreurs::est_interdit(&e) {
                HttpResponse::Forbidden().json(serde_json::json!({"error": e}))
            } else if classification_erreurs::est_introuvable(&e) {
                HttpResponse::NotFound().json(serde_json::json!({"error": e}))
            } else {
                HttpResponse::BadRequest().json(serde_json::json!({"error": e}))
            }
        }
    }
}

/// PUT /api/v1/exchanges/:id/rate-provider
/// Rate the provider (by requester)
#[put("/exchanges/{id}/rate-provider")]
pub async fn rate_provider(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    id: web::Path<Uuid>,
    request: web::Json<RateExchangeDto>,
) -> impl Responder {
    // Cloisonnement : cet échange doit relever d'une ACP que cet utilisateur a
    // le droit de voir. La route n'ayant pas d'immeuble en chemin, la chaîne
    // échange → immeuble → ACP est remontée par le garde.
    //
    // Les deux notations comptent particulièrement : une note engage la
    // réputation d'un voisin dans sa propre copropriété (#772).
    if let Err(err) = verify_exchange_org_access(
        &auth,
        *id,
        &data.local_exchange_use_cases,
        &data.building_use_cases,
        &data.acp_use_cases,
    )
    .await
    {
        return err.error_response();
    }

    match data
        .local_exchange_use_cases
        .rate_provider(id.into_inner(), auth.user_id, request.into_inner())
        .await
    {
        Ok(exchange) => HttpResponse::Ok().json(exchange),
        Err(e) => HttpResponse::BadRequest().json(serde_json::json!({"error": e})),
    }
}

/// PUT /api/v1/exchanges/:id/rate-requester
/// Rate the requester (by provider)
#[put("/exchanges/{id}/rate-requester")]
pub async fn rate_requester(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    id: web::Path<Uuid>,
    request: web::Json<RateExchangeDto>,
) -> impl Responder {
    // Cloisonnement : cet échange doit relever d'une ACP que cet utilisateur a
    // le droit de voir. La route n'ayant pas d'immeuble en chemin, la chaîne
    // échange → immeuble → ACP est remontée par le garde.
    //
    // Les deux notations comptent particulièrement : une note engage la
    // réputation d'un voisin dans sa propre copropriété (#772).
    if let Err(err) = verify_exchange_org_access(
        &auth,
        *id,
        &data.local_exchange_use_cases,
        &data.building_use_cases,
        &data.acp_use_cases,
    )
    .await
    {
        return err.error_response();
    }

    match data
        .local_exchange_use_cases
        .rate_requester(id.into_inner(), auth.user_id, request.into_inner())
        .await
    {
        Ok(exchange) => HttpResponse::Ok().json(exchange),
        Err(e) => HttpResponse::BadRequest().json(serde_json::json!({"error": e})),
    }
}

/// DELETE /api/v1/exchanges/:id
/// Delete an exchange (provider, or community moderator with a reason)
#[delete("/exchanges/{id}")]
pub async fn delete_exchange(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    id: web::Path<Uuid>,
    // Corps optionnel : le provider qui supprime sa propre offre n'a rien à
    // motiver et peut continuer à appeler cette route sans corps JSON. Un
    // corps MALFORMÉ tombe aussi dans `None` (limite connue d'`Option<Json<T>>`,
    // cf. `quote_handlers::submit_quote`) — sans risque ici : ça retombe sur
    // "pas de motif fourni", refusé en 422 pour un modérateur, sans effet pour
    // le provider qui n'en a pas besoin.
    body: Option<web::Json<DeleteExchangeDto>>,
) -> impl Responder {
    let reason = body.and_then(|b| b.into_inner().reason);

    match data
        .local_exchange_use_cases
        .delete_exchange(id.into_inner(), auth.user_id, &auth.role, reason)
        .await
    {
        Ok(_) => HttpResponse::NoContent().finish(),
        Err(e) => {
            if classification_erreurs::est_motif_manquant(&e) {
                HttpResponse::UnprocessableEntity().json(serde_json::json!({"error": e}))
            } else if classification_erreurs::est_interdit(&e) {
                HttpResponse::Forbidden().json(serde_json::json!({"error": e}))
            } else if classification_erreurs::est_introuvable(&e) {
                HttpResponse::NotFound().json(serde_json::json!({"error": e}))
            } else {
                HttpResponse::BadRequest().json(serde_json::json!({"error": e}))
            }
        }
    }
}

/// GET /api/v1/owners/:owner_id/buildings/:building_id/credit-balance
/// Get credit balance for an owner in a building
/// Note: owner_id can be the actual owner ID or the user ID (frontend sends user ID)
#[get("/owners/{owner_id}/buildings/{building_id}/credit-balance")]
pub async fn get_credit_balance(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    path: web::Path<(Uuid, Uuid)>,
) -> impl Responder {
    // Cloisonnement : le copropriétaire visé doit relever d'une organisation
    // que cet utilisateur a le droit de voir. Ces routes disent ce qu'une
    // personne nommée a échangé, rendu, et combien de crédits elle détient —
    // son activité dans la copropriété, jour après jour (#772).
    if let Err(err) = verify_owner_org_access(&auth, path.0, &data.owner_use_cases).await {
        return err.error_response();
    }

    let (path_id, building_id) = path.into_inner();

    // Try to find owner by ID first, then by user_id as fallback
    // (frontend sends user_id from auth store, not owner_id)
    let owner = match data.owner_use_cases.get_owner(path_id).await {
        Ok(Some(owner)) => owner,
        Ok(None) => {
            // Fallback: treat path_id as user_id and look up owner
            match data.owner_use_cases.find_owner_by_user_id(path_id).await {
                Ok(Some(owner)) => owner,
                Ok(None) => {
                    return HttpResponse::NotFound().json(serde_json::json!({
                        "error": format!("Owner not found for id: {}", path_id)
                    }))
                }
                Err(e) => {
                    return HttpResponse::InternalServerError().json(serde_json::json!({
                        "error": format!("Failed to fetch owner: {}", e)
                    }))
                }
            }
        }
        Err(e) => {
            return HttpResponse::InternalServerError().json(serde_json::json!({
                "error": format!("Failed to fetch owner: {}", e)
            }))
        }
    };

    // Authorization: users can only view their own credit balance
    let owner_user_id = owner
        .user_id
        .as_ref()
        .and_then(|id| Uuid::parse_str(id).ok());
    if owner_user_id != Some(auth.user_id) {
        return HttpResponse::Forbidden().json(serde_json::json!({
            "error": "You can only view your own credit balance"
        }));
    }

    let owner_uuid = match Uuid::parse_str(&owner.id) {
        Ok(id) => id,
        Err(_) => {
            return HttpResponse::InternalServerError().json(serde_json::json!({
                "error": "Invalid owner ID format"
            }))
        }
    };

    match data
        .local_exchange_use_cases
        .get_credit_balance(owner_uuid, building_id)
        .await
    {
        Ok(balance) => HttpResponse::Ok().json(balance),
        Err(e) => HttpResponse::BadRequest().json(serde_json::json!({"error": e})),
    }
}

/// GET /api/v1/buildings/:building_id/leaderboard
/// Get leaderboard (top contributors)
#[get("/buildings/{building_id}/leaderboard")]
pub async fn get_leaderboard(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    building_id: web::Path<Uuid>,
    query: web::Query<std::collections::HashMap<String, String>>,
) -> impl Responder {
    // Cloisonnement : l'immeuble visé doit relever d'une ACP que cet
    // utilisateur a le droit de voir. Sans ce contrôle, l'identité était prise
    // en paramètre puis ignorée — `_auth` — et n'importe quel utilisateur
    // authentifié lisait les échanges de n'importe quel immeuble (#772).
    if let Err(err) = verify_building_org_access(
        &auth,
        *building_id,
        &data.building_use_cases,
        &data.acp_use_cases,
    )
    .await
    {
        return err.error_response();
    }

    let limit = query
        .get("limit")
        .and_then(|l| l.parse::<i32>().ok())
        .unwrap_or(10);

    match data
        .local_exchange_use_cases
        .get_leaderboard(building_id.into_inner(), limit)
        .await
    {
        Ok(leaderboard) => HttpResponse::Ok().json(leaderboard),
        Err(e) => HttpResponse::BadRequest().json(serde_json::json!({"error": e})),
    }
}

/// GET /api/v1/buildings/:building_id/sel-statistics
/// Get SEL statistics for a building
#[get("/buildings/{building_id}/sel-statistics")]
pub async fn get_sel_statistics(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    building_id: web::Path<Uuid>,
) -> impl Responder {
    // Cloisonnement : l'immeuble visé doit relever d'une ACP que cet
    // utilisateur a le droit de voir. Sans ce contrôle, l'identité était prise
    // en paramètre puis ignorée — `_auth` — et n'importe quel utilisateur
    // authentifié lisait les échanges de n'importe quel immeuble (#772).
    if let Err(err) = verify_building_org_access(
        &auth,
        *building_id,
        &data.building_use_cases,
        &data.acp_use_cases,
    )
    .await
    {
        return err.error_response();
    }

    match data
        .local_exchange_use_cases
        .get_statistics(building_id.into_inner())
        .await
    {
        Ok(stats) => HttpResponse::Ok().json(stats),
        Err(e) => HttpResponse::BadRequest().json(serde_json::json!({"error": e})),
    }
}

/// GET /api/v1/owners/:owner_id/exchange-summary
/// Get owner exchange summary
#[get("/owners/{owner_id}/exchange-summary")]
pub async fn get_owner_summary(
    data: web::Data<AppState>,
    auth: AuthenticatedUser,
    owner_id: web::Path<Uuid>,
) -> impl Responder {
    // Cloisonnement : le copropriétaire visé doit relever d'une organisation
    // que cet utilisateur a le droit de voir. Ces routes disent ce qu'une
    // personne nommée a échangé, rendu, et combien de crédits elle détient —
    // son activité dans la copropriété, jour après jour (#772).
    if let Err(err) = verify_owner_org_access(&auth, *owner_id, &data.owner_use_cases).await {
        return err.error_response();
    }

    let owner_id = owner_id.into_inner();

    // Authorization: users can only view their own exchange summary
    let owner = match data.owner_use_cases.get_owner(owner_id).await {
        Ok(Some(owner)) => owner,
        Ok(None) => {
            return HttpResponse::NotFound().json(serde_json::json!({
                "error": format!("Owner not found: {}", owner_id)
            }))
        }
        Err(e) => {
            return HttpResponse::InternalServerError().json(serde_json::json!({
                "error": format!("Failed to fetch owner: {}", e)
            }))
        }
    };

    let owner_user_id = owner
        .user_id
        .as_ref()
        .and_then(|id| Uuid::parse_str(id).ok());
    if owner_user_id != Some(auth.user_id) {
        return HttpResponse::Forbidden().json(serde_json::json!({
            "error": "You can only view your own exchange summary"
        }));
    }

    match data
        .local_exchange_use_cases
        .get_owner_summary(owner_id)
        .await
    {
        Ok(summary) => HttpResponse::Ok().json(summary),
        Err(e) => HttpResponse::BadRequest().json(serde_json::json!({"error": e})),
    }
}