koprogo_api/infrastructure/web/handlers/

meeting_handlers.rs

use crate::application::dto::{
    AddAgendaItemRequest, AttachMinutesRequest, CompleteMeetingRequest, CreateMeetingRequest,
    PageRequest, PageResponse, RescheduleMeetingRequest, UpdateMeetingRequest,
    ValidateQuorumRequest,
};
use crate::infrastructure::audit::{AuditEventType, AuditLogEntry};
use crate::infrastructure::web::classification_erreurs;
use crate::infrastructure::web::middleware::scope_guard::verify_acp_org_access;
use crate::infrastructure::web::middleware::scope_guard::verify_building_org_access;
use crate::infrastructure::web::{AppState, AuthenticatedUser};
use actix_web::{delete, get, post, put, web, HttpResponse, Responder, ResponseError};
use uuid::Uuid;

/// Cloisonne une assemblée AVANT de la muter (#864).
///
/// ── Ce que ces quatre routes laissaient passer ────────────────────────────
///
/// `cancel_meeting`, `complete_meeting`, `reschedule_meeting` et
/// `validate_meeting_quorum` prenaient `AuthenticatedUser` et ne s'en
/// servaient que pour journaliser après coup. `get_meeting`, dans ce même
/// fichier, remonte pourtant la chaîne `meeting → building → acp →
/// organization` depuis le hotfix #603 : le chemin existait, il n'était pas
/// emprunté par les écritures.
///
/// ── Pourquoi une assemblée n'est pas un enregistrement comme un autre ─────
///
/// Annuler l'AG d'une autre copropriété, la reporter, ou en valider le
/// quorum touche à l'Art. 3.87 : la tenue de l'assemblée, ses délais, et la
/// validité de ce qui s'y vote. Une AG annulée par un tiers est une AG qui
/// n'a pas eu lieu, et les décisions qu'elle aurait prises n'existent pas.
///
/// Rend `Some(réponse)` quand l'appel doit être refusé, `None` sinon.
async fn verify_meeting_org_access(
    state: &web::Data<AppState>,
    user: &AuthenticatedUser,
    id: Uuid,
) -> Option<HttpResponse> {
    let meeting = match state.meeting_use_cases.get_meeting(id).await {
        Ok(Some(m)) => m,
        Ok(None) => {
            return Some(HttpResponse::NotFound().json(serde_json::json!({
                "error": "Meeting not found"
            })))
        }
        Err(err) => {
            return Some(HttpResponse::InternalServerError().json(serde_json::json!({
                "error": err.to_string()
            })))
        }
    };

    // Même chaîne que `get_meeting` : l'assemblée ne porte pas d'organisation,
    // elle porte un immeuble, qui porte une ACP, qui porte l'organisation.
    let building = match state
        .building_use_cases
        .get_building(meeting.building_id)
        .await
    {
        Ok(Some(b)) => b,
        // Pas d'immeuble résoluble : on REFUSE, on ne laisse pas passer.
        //
        // `get_meeting` fait l'inverse — son `if let Ok(Some(building))`
        // laisse filer la lecture quand l'immeuble est introuvable. Sur une
        // lecture c'est une fuite ; sur une écriture ce serait un blanc-seing,
        // et l'asymétrie est volontaire.
        _ => {
            return Some(HttpResponse::Forbidden().json(serde_json::json!({
                "error": "Impossible de rattacher cette assemblée à une ACP"
            })))
        }
    };

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

    match verify_acp_org_access(user, acp_id, &state.acp_use_cases).await {
        Ok(()) => None,
        Err(err) => Some(err.error_response()),
    }
}

/// POST /meetings/{id}/validate-quorum — Art. 3.87 §5 CC
/// Validates quorum (>50% millièmes présents + procurations).
/// If quorum not reached, automatically schedules a 2nd convocation 15 days later.
#[post("/meetings/{id}/validate-quorum")]
pub async fn validate_meeting_quorum(
    state: web::Data<AppState>,
    user: AuthenticatedUser,
    id: web::Path<Uuid>,
    request: web::Json<ValidateQuorumRequest>,
) -> impl Responder {
    let meeting_id = id.into_inner();
    let req = request.into_inner();

    // Cloisonnement AVANT la mutation (#864).
    if let Some(refus) = verify_meeting_org_access(&state, &user, meeting_id).await {
        return refus;
    }

    match state
        .meeting_use_cases
        .validate_quorum(meeting_id, req.present_quotas, req.total_quotas)
        .await
    {
        Ok((quorum_reached, meeting)) => {
            AuditLogEntry::new(
                AuditEventType::MeetingQuorumValidated,
                Some(user.user_id),
                user.organization_id,
            )
            .with_resource("Meeting", meeting_id)
            .with_metadata(serde_json::json!({
                "quorum_reached": quorum_reached,
                "present_quotas": req.present_quotas,
                "total_quotas": req.total_quotas,
                "quorum_percentage": meeting.quorum_percentage,
                "auto_second_convocation": !quorum_reached,
            }))
            .log();

            HttpResponse::Ok().json(serde_json::json!({
                "quorum_reached": quorum_reached,
                "meeting": meeting,
                "message": if quorum_reached {
                    "Quorum atteint (Art. 3.87 §5 CC). Les votes peuvent commencer."
                } else {
                    "Quorum non atteint. Une 2ème convocation a été planifiée automatiquement (Art. 3.87 §5 CC)."
                }
            }))
        }
        Err(err) => HttpResponse::BadRequest().json(serde_json::json!({
            "error": err
        })),
    }
}

#[post("/meetings")]
pub async fn create_meeting(
    state: web::Data<AppState>,
    user: AuthenticatedUser, // JWT-extracted user info (SECURE!)
    mut request: web::Json<CreateMeetingRequest>,
) -> impl Responder {
    // Override the organization_id from request with the one from JWT token
    // This prevents users from creating meetings in other organizations
    let organization_id = match user.require_organization() {
        Ok(org_id) => org_id,
        Err(e) => {
            return HttpResponse::Unauthorized().json(serde_json::json!({
                "error": e.to_string()
            }))
        }
    };
    request.organization_id = organization_id;

    // Isolation multi-tenant à l'ÉCRITURE (ADR-0045). L'affectation de
    // `organization_id` depuis le jeton protège l'ESTAMPILLE, pas le
    // RATTACHEMENT : elle empêche d'écrire au nom d'autrui, pas d'écrire dans
    // le dossier d'autrui. L'immeuble visé doit relever d'une ACP confiée à ce
    // syndic.
    if let Err(err) = verify_building_org_access(
        &user,
        request.building_id,
        &state.building_use_cases,
        &state.acp_use_cases,
    )
    .await
    {
        return err.error_response();
    }

    match state
        .meeting_use_cases
        .create_meeting(request.into_inner())
        .await
    {
        Ok(meeting) => {
            // Audit log: successful meeting creation
            AuditLogEntry::new(
                AuditEventType::MeetingCreated,
                Some(user.user_id),
                Some(organization_id),
            )
            .with_resource("Meeting", meeting.id)
            .log();

            HttpResponse::Created().json(meeting)
        }
        Err(err) => {
            // Audit log: failed meeting creation
            AuditLogEntry::new(
                AuditEventType::MeetingCreated,
                Some(user.user_id),
                Some(organization_id),
            )
            .with_error(err.clone())
            .log();

            HttpResponse::BadRequest().json(serde_json::json!({
                "error": err
            }))
        }
    }
}

#[get("/meetings/{id}")]
pub async fn get_meeting(
    state: web::Data<AppState>,
    user: AuthenticatedUser,
    id: web::Path<Uuid>,
) -> impl Responder {
    match state.meeting_use_cases.get_meeting(*id).await {
        Ok(Some(meeting)) => {
            // Hotfix #603 — multi-tenant isolation via ACP→organization resolution.
            if let Ok(Some(building)) = state
                .building_use_cases
                .get_building(meeting.building_id)
                .await
            {
                let acp_id = match Uuid::parse_str(&building.acp_id) {
                    Ok(id) => id,
                    Err(_) => {
                        return HttpResponse::InternalServerError().json(serde_json::json!({
                            "error": "Invalid building.acp_id format"
                        }));
                    }
                };
                if let Err(err) = verify_acp_org_access(&user, acp_id, &state.acp_use_cases).await {
                    return err.error_response();
                }
            }
            HttpResponse::Ok().json(meeting)
        }
        Ok(None) => HttpResponse::NotFound().json(serde_json::json!({
            "error": "Meeting not found"
        })),
        Err(err) => HttpResponse::InternalServerError().json(serde_json::json!({
            "error": err
        })),
    }
}

#[get("/meetings")]
pub async fn list_meetings(
    state: web::Data<AppState>,
    user: AuthenticatedUser,
    page_request: web::Query<PageRequest>,
) -> impl Responder {
    let organization_id = user.organization_id;

    match state
        .meeting_use_cases
        .list_meetings_paginated(&page_request, organization_id)
        .await
    {
        Ok((meetings, total)) => {
            let response =
                PageResponse::new(meetings, page_request.page, page_request.per_page, total);
            HttpResponse::Ok().json(response)
        }
        Err(err) => HttpResponse::InternalServerError().json(serde_json::json!({
            "error": err
        })),
    }
}

#[get("/buildings/{building_id}/meetings")]
pub async fn list_meetings_by_building(
    state: web::Data<AppState>,
    user: AuthenticatedUser,
    building_id: web::Path<Uuid>,
) -> impl Responder {
    // Hotfix #603 — multi-tenant isolation via ACP→organization resolution.
    match state.building_use_cases.get_building(*building_id).await {
        Ok(Some(building)) => {
            let acp_id = match Uuid::parse_str(&building.acp_id) {
                Ok(id) => id,
                Err(_) => {
                    return HttpResponse::InternalServerError().json(serde_json::json!({
                        "error": "Invalid building.acp_id format"
                    }));
                }
            };
            if let Err(err) = verify_acp_org_access(&user, acp_id, &state.acp_use_cases).await {
                return err.error_response();
            }
        }
        Ok(None) => {
            return HttpResponse::NotFound().json(serde_json::json!({
                "error": "Building not found"
            }));
        }
        Err(err) => {
            return HttpResponse::InternalServerError().json(serde_json::json!({
                "error": err
            }));
        }
    }

    match state
        .meeting_use_cases
        .list_meetings_by_building(*building_id)
        .await
    {
        Ok(meetings) => HttpResponse::Ok().json(meetings),
        Err(err) => HttpResponse::InternalServerError().json(serde_json::json!({
            "error": err
        })),
    }
}

#[put("/meetings/{id}")]
pub async fn update_meeting(
    state: web::Data<AppState>,
    user: AuthenticatedUser,
    id: web::Path<Uuid>,
    request: web::Json<UpdateMeetingRequest>,
) -> impl Responder {
    // Aucune identité n'était exigée ici : ce gestionnaire ne prenait ni
    // `AuthenticatedUser`, ni jeton lu à la main. N'importe qui pouvait donc
    // modifier n'importe quelle assemblée générale sur simple connaissance de son identifiant.
    //
    // Le cliquet d'identité de #772 ne pouvait pas le voir : il compte les
    // routes qui PRENNENT `AuthenticatedUser` sans s'en servir. Une route qui
    // ne le prend pas du tout lui échappait entièrement. Cf. #845.
    if let Err(err) =
        crate::infrastructure::web::middleware::scope_guard::verify_meeting_org_access(
            &user,
            *id,
            &state.meeting_use_cases,
            &state.building_use_cases,
            &state.acp_use_cases,
        )
        .await
    {
        return err.error_response();
    }

    match state
        .meeting_use_cases
        .update_meeting(*id, request.into_inner())
        .await
    {
        Ok(meeting) => HttpResponse::Ok().json(meeting),
        Err(err) => HttpResponse::BadRequest().json(serde_json::json!({
            "error": err
        })),
    }
}

#[post("/meetings/{id}/agenda")]
pub async fn add_agenda_item(
    state: web::Data<AppState>,
    id: web::Path<Uuid>,
    request: web::Json<AddAgendaItemRequest>,
    user: AuthenticatedUser,
) -> impl Responder {
    // Route imbriquee non gardee au releve du 2026-09-06 (issue #772).
    if let Err(err) =
        crate::infrastructure::web::middleware::scope_guard::verify_meeting_org_access(
            &user,
            *id,
            &state.meeting_use_cases,
            &state.building_use_cases,
            &state.acp_use_cases,
        )
        .await
    {
        return err.error_response();
    }

    match state
        .meeting_use_cases
        .add_agenda_item(*id, request.into_inner())
        .await
    {
        Ok(meeting) => HttpResponse::Ok().json(meeting),
        Err(err) => HttpResponse::BadRequest().json(serde_json::json!({
            "error": err
        })),
    }
}

/// GET /meetings/{id}/completion-checklist — Track H Story H3
/// Retourne la checklist d'invariants Art. 3.87 §3-5 CC + liste des invariants
/// manquants, consommé côté FE par `<MissingInvariantsList>`.
#[get("/meetings/{id}/completion-checklist")]
pub async fn get_meeting_completion_checklist(
    state: web::Data<AppState>,
    user: AuthenticatedUser,
    id: web::Path<Uuid>,
) -> impl Responder {
    // Cloisonnement : la liste des conditions de clôture d'une AG dit où en est
    // la copropriété — convocations envoyées, résolutions votées, PV rédigé.
    // L'identité était prise puis ignorée — `_user` (#772).
    if let Err(err) =
        crate::infrastructure::web::middleware::scope_guard::verify_meeting_org_access(
            &user,
            *id,
            &state.meeting_use_cases,
            &state.building_use_cases,
            &state.acp_use_cases,
        )
        .await
    {
        return err.error_response();
    }

    let meeting_id = id.into_inner();
    match state
        .meeting_use_cases
        .build_completion_checklist(meeting_id)
        .await
    {
        Ok((checklist, missing_json)) => HttpResponse::Ok().json(serde_json::json!({
            "meeting_id": meeting_id,
            "convocations_sent": checklist.convocations_sent,
            "open_resolutions": checklist.open_resolutions,
            "attendance_recorded": checklist.attendance_recorded,
            "attended_quotas": checklist.attended_quotas.to_string(),
            "total_quotas": checklist.total_quotas.to_string(),
            "minutes_draft_exists": checklist.minutes_draft_exists,
            "missing": missing_json,
        })),
        Err(err)
            if classification_erreurs::est_introuvable(&err) || err.contains("not configured") =>
        {
            HttpResponse::NotFound().json(serde_json::json!({ "error": err }))
        }
        Err(err) => HttpResponse::BadRequest().json(serde_json::json!({ "error": err })),
    }
}

#[post("/meetings/{id}/complete")]
pub async fn complete_meeting(
    state: web::Data<AppState>,
    user: AuthenticatedUser,
    id: web::Path<Uuid>,
    request: web::Json<CompleteMeetingRequest>,
) -> impl Responder {
    // Cloisonnement AVANT la mutation (#864).
    if let Some(refus) = verify_meeting_org_access(&state, &user, *id).await {
        return refus;
    }

    match state
        .meeting_use_cases
        .complete_meeting(*id, request.into_inner())
        .await
    {
        Ok(meeting) => {
            // Audit log: successful meeting completion
            AuditLogEntry::new(
                AuditEventType::MeetingCompleted,
                Some(user.user_id),
                user.organization_id,
            )
            .with_resource("Meeting", *id)
            .log();

            HttpResponse::Ok().json(meeting)
        }
        Err(err) => {
            // Audit log: failed meeting completion
            AuditLogEntry::new(
                AuditEventType::MeetingCompleted,
                Some(user.user_id),
                user.organization_id,
            )
            .with_resource("Meeting", *id)
            .with_error(err.clone())
            .log();

            HttpResponse::BadRequest().json(serde_json::json!({
                "error": err
            }))
        }
    }
}

#[post("/meetings/{id}/cancel")]
pub async fn cancel_meeting(
    state: web::Data<AppState>,
    user: AuthenticatedUser,
    id: web::Path<Uuid>,
) -> impl Responder {
    // Cloisonnement AVANT la mutation (#864).
    if let Some(refus) = verify_meeting_org_access(&state, &user, *id).await {
        return refus;
    }

    match state.meeting_use_cases.cancel_meeting(*id).await {
        Ok(meeting) => {
            // `MeetingCancelled`, et non `MeetingCompleted` : une assemblée
            // annulée n'a pas eu lieu. Cf. #780.
            AuditLogEntry::new(
                AuditEventType::MeetingCancelled,
                Some(user.user_id),
                user.organization_id,
            )
            .with_resource("Meeting", *id)
            .log();

            HttpResponse::Ok().json(meeting)
        }
        Err(err) => HttpResponse::BadRequest().json(serde_json::json!({
            "error": err
        })),
    }
}

#[post("/meetings/{id}/reschedule")]
pub async fn reschedule_meeting(
    state: web::Data<AppState>,
    user: AuthenticatedUser,
    id: web::Path<Uuid>,
    request: web::Json<RescheduleMeetingRequest>,
) -> impl Responder {
    // Cloisonnement AVANT la mutation (#864).
    if let Some(refus) = verify_meeting_org_access(&state, &user, *id).await {
        return refus;
    }

    match state
        .meeting_use_cases
        .reschedule_meeting(*id, request.scheduled_date)
        .await
    {
        Ok(meeting) => {
            // `MeetingRescheduled`, et non `MeetingCompleted` : reporter une
            // assemblée n'est pas la clôturer. Cf. #780.
            AuditLogEntry::new(
                AuditEventType::MeetingRescheduled,
                Some(user.user_id),
                user.organization_id,
            )
            .with_resource("Meeting", *id)
            .log();

            HttpResponse::Ok().json(meeting)
        }
        Err(err) => HttpResponse::BadRequest().json(serde_json::json!({
            "error": err
        })),
    }
}

#[delete("/meetings/{id}")]
pub async fn delete_meeting(
    state: web::Data<AppState>,
    user: AuthenticatedUser,
    id: web::Path<Uuid>,
) -> impl Responder {
    // Aucune identité n'était exigée ici : ce gestionnaire ne prenait ni
    // `AuthenticatedUser`, ni jeton lu à la main. N'importe qui pouvait donc
    // supprimer n'importe quelle assemblée générale sur simple connaissance de son identifiant.
    //
    // Le cliquet d'identité de #772 ne pouvait pas le voir : il compte les
    // routes qui PRENNENT `AuthenticatedUser` sans s'en servir. Une route qui
    // ne le prend pas du tout lui échappait entièrement. Cf. #845.
    if let Err(err) =
        crate::infrastructure::web::middleware::scope_guard::verify_meeting_org_access(
            &user,
            *id,
            &state.meeting_use_cases,
            &state.building_use_cases,
            &state.acp_use_cases,
        )
        .await
    {
        return err.error_response();
    }

    match state.meeting_use_cases.delete_meeting(*id).await {
        Ok(true) => HttpResponse::NoContent().finish(),
        Ok(false) => HttpResponse::NotFound().json(serde_json::json!({
            "error": "Meeting not found"
        })),
        Err(err) => HttpResponse::InternalServerError().json(serde_json::json!({
            "error": err
        })),
    }
}

#[post("/meetings/{id}/attach-minutes")]
pub async fn attach_minutes(
    state: web::Data<AppState>,
    user: AuthenticatedUser,
    id: web::Path<Uuid>,
    request: web::Json<AttachMinutesRequest>,
) -> impl Responder {
    let organization_id = match user.require_organization() {
        Ok(org_id) => org_id,
        Err(e) => {
            return HttpResponse::Unauthorized().json(serde_json::json!({
                "error": e.to_string()
            }))
        }
    };

    match state
        .meeting_use_cases
        .attach_minutes(*id, request.document_id)
        .await
    {
        Ok(meeting) => {
            AuditLogEntry::new(
                AuditEventType::MeetingMinutesSent,
                Some(user.user_id),
                Some(organization_id),
            )
            .with_resource("Meeting", *id)
            .log();

            HttpResponse::Ok().json(meeting)
        }
        Err(err) => {
            AuditLogEntry::new(
                AuditEventType::MeetingMinutesSent,
                Some(user.user_id),
                Some(organization_id),
            )
            .with_error(err.clone())
            .log();

            HttpResponse::BadRequest().json(serde_json::json!({
                "error": err
            }))
        }
    }
}

#[get("/meetings/{id}/export-minutes-pdf")]
pub async fn export_meeting_minutes_pdf(
    state: web::Data<AppState>,
    user: AuthenticatedUser,
    id: web::Path<Uuid>,
) -> impl Responder {
    use crate::domain::services::{AttendeeInfo, MeetingMinutesExporter, ResolutionWithVotes};

    let organization_id = match user.require_organization() {
        Ok(org_id) => org_id,
        Err(e) => {
            return HttpResponse::Unauthorized().json(serde_json::json!({
                "error": e.to_string()
            }))
        }
    };

    let meeting_id = *id;

    // 1. Get meeting
    let meeting = match state.meeting_use_cases.get_meeting(meeting_id).await {
        Ok(Some(meeting_dto)) => meeting_dto,
        Ok(None) => {
            return HttpResponse::NotFound().json(serde_json::json!({
                "error": "Meeting not found"
            }))
        }
        Err(err) => {
            return HttpResponse::InternalServerError().json(serde_json::json!({
                "error": err
            }))
        }
    };

    // 2. Get building
    let building = match state
        .building_use_cases
        .get_building(meeting.building_id)
        .await
    {
        Ok(Some(building_dto)) => building_dto,
        Ok(None) => {
            return HttpResponse::NotFound().json(serde_json::json!({
                "error": "Building not found"
            }))
        }
        Err(err) => {
            return HttpResponse::InternalServerError().json(serde_json::json!({
                "error": err
            }))
        }
    };

    // 3. Get resolutions for this meeting
    let resolutions = match state
        .resolution_use_cases
        .get_meeting_resolutions(meeting_id)
        .await
    {
        Ok(resolutions) => resolutions,
        Err(err) => {
            return HttpResponse::InternalServerError().json(serde_json::json!({
                "error": format!("Failed to get resolutions: {}", err)
            }))
        }
    };

    // 4. Get votes for each resolution and collect attendees
    let mut attendees_map = std::collections::HashMap::new();
    let mut resolutions_with_votes = Vec::new();

    for resolution_dto in resolutions {
        // Get votes for this resolution
        let votes_dto = match state
            .resolution_use_cases
            .get_resolution_votes(resolution_dto.id)
            .await
        {
            Ok(votes) => votes,
            Err(err) => {
                return HttpResponse::InternalServerError().json(serde_json::json!({
                    "error": format!("Failed to get votes: {}", err)
                }))
            }
        };

        // Collect attendees from votes
        for vote_dto in &votes_dto {
            if let std::collections::hash_map::Entry::Vacant(e) =
                attendees_map.entry(vote_dto.owner_id)
            {
                // Get owner info
                if let Ok(Some(owner_dto)) =
                    state.owner_use_cases.get_owner(vote_dto.owner_id).await
                {
                    let proxy_for_name = if let Some(proxy_id) = vote_dto.proxy_owner_id {
                        state
                            .owner_use_cases
                            .get_owner(proxy_id)
                            .await
                            .ok()
                            .flatten()
                            .map(|o| format!("{} {}", o.first_name, o.last_name))
                    } else {
                        None
                    };

                    let full_name = format!("{} {}", owner_dto.first_name, owner_dto.last_name);

                    e.insert(AttendeeInfo {
                        owner_id: vote_dto.owner_id,
                        name: full_name,
                        email: owner_dto.email.clone(),
                        voting_power: vote_dto.voting_power,
                        is_proxy: vote_dto.proxy_owner_id.is_some(),
                        proxy_for: proxy_for_name,
                    });
                }
            }
        }

        // Convert DTOs to domain entities for PDF generation
        use crate::domain::entities::{Resolution, Vote};

        let resolution_entity = Resolution {
            prestataire_de_la_mission: None,
            id: resolution_dto.id,
            meeting_id: resolution_dto.meeting_id,
            title: resolution_dto.title,
            description: resolution_dto.description,
            resolution_type: resolution_dto.resolution_type,
            majority_required: resolution_dto.majority_required,
            vote_count_pour: resolution_dto.vote_count_pour,
            vote_count_contre: resolution_dto.vote_count_contre,
            vote_count_abstention: resolution_dto.vote_count_abstention,
            total_voting_power_pour: resolution_dto.total_voting_power_pour,
            total_voting_power_contre: resolution_dto.total_voting_power_contre,
            total_voting_power_abstention: resolution_dto.total_voting_power_abstention,
            status: resolution_dto.status,
            voted_at: resolution_dto.voted_at,
            created_at: resolution_dto.created_at,
            agenda_item_index: None,
            kind: crate::domain::entities::ResolutionKind::Standard,
        };

        let votes: Vec<Vote> = votes_dto
            .iter()
            .map(|v| Vote {
                id: v.id,
                resolution_id: v.resolution_id,
                owner_id: v.owner_id,
                unit_id: v.unit_id,
                vote_choice: v.vote_choice.clone(),
                voting_power: v.voting_power,
                proxy_owner_id: v.proxy_owner_id,
                voted_at: v.voted_at,
                auth_method: v.auth_method,
            })
            .collect();

        resolutions_with_votes.push(ResolutionWithVotes {
            resolution: resolution_entity,
            votes,
        });
    }

    let attendees: Vec<AttendeeInfo> = attendees_map.into_values().collect();

    // Convert DTOs to domain entities
    use crate::domain::entities::{Building, Meeting};

    // Story 1.2 — building.acp_id (was organization_id).
    let building_acp_id = match Uuid::parse_str(&building.acp_id) {
        Ok(id) => id,
        Err(err) => {
            return HttpResponse::InternalServerError().json(serde_json::json!({
                "error": format!("Invalid acp_id: {}", err)
            }))
        }
    };

    // Parse building dates
    use chrono::DateTime;
    let building_created_at = match DateTime::parse_from_rfc3339(&building.created_at) {
        Ok(dt) => dt.with_timezone(&chrono::Utc),
        Err(_) => chrono::Utc::now(),
    };
    let building_updated_at = match DateTime::parse_from_rfc3339(&building.updated_at) {
        Ok(dt) => dt.with_timezone(&chrono::Utc),
        Err(_) => chrono::Utc::now(),
    };

    let building_entity = Building {
        id: match Uuid::parse_str(&building.id) {
            Ok(id) => id,
            Err(err) => {
                return HttpResponse::InternalServerError().json(serde_json::json!({
                    "error": format!("Invalid building id: {}", err)
                }))
            }
        },
        name: building.name,
        address: building.address,
        city: building.city,
        postal_code: building.postal_code,
        country: building.country,
        total_units: building.total_units,
        total_tantiemes: building.total_tantiemes,
        construction_year: building.construction_year,
        syndic_name: None,
        syndic_email: None,
        syndic_phone: None,
        syndic_address: None,
        syndic_office_hours: None,
        syndic_emergency_contact: None,
        slug: None,
        acp_id: building_acp_id,
        created_at: building_created_at,
        updated_at: building_updated_at,
    };

    let meeting_entity = Meeting {
        id: meeting.id,
        // L'assemblée relève de l'ACP de son immeuble (Art. 3.87, ADR-0045).
        acp_id: building_acp_id,
        organization_id,
        building_id: meeting.building_id,
        meeting_type: meeting.meeting_type,
        title: meeting.title,
        description: meeting.description,
        scheduled_date: meeting.scheduled_date,
        location: meeting.location,
        status: meeting.status,
        agenda: meeting.agenda,
        attendees_count: meeting.attendees_count,
        quorum_validated: meeting.quorum_validated,
        quorum_percentage: meeting.quorum_percentage,
        total_quotas: meeting.total_quotas,
        present_quotas: meeting.present_quotas,
        created_at: meeting.created_at,
        updated_at: meeting.updated_at,
        is_second_convocation: false,
        minutes_document_id: None,
        minutes_sent_at: None,
        // Le PV n'a pas besoin de la modalité de tenue de l'AG : cette
        // reconstruction ne sert qu'à générer le document, pas à refléter
        // l'entité persistée (cf. `PostgresMeetingRepository` pour la source
        // de vérité de `mode`/`videoconf_url`).
        mode: crate::domain::entities::MeetingMode::InPerson,
        videoconf_url: None,
    };

    // 5. Generate PDF
    match MeetingMinutesExporter::export_to_pdf(
        &building_entity,
        &meeting_entity,
        &attendees,
        &resolutions_with_votes,
    ) {
        Ok(pdf_bytes) => {
            // Audit log
            AuditLogEntry::new(
                AuditEventType::ReportGenerated,
                Some(user.user_id),
                Some(organization_id),
            )
            .with_resource("Meeting", meeting_id)
            .with_metadata(serde_json::json!({
                "report_type": "meeting_minutes_pdf",
                "building_name": building_entity.name,
                "meeting_date": meeting_entity.scheduled_date.to_rfc3339()
            }))
            .log();

            HttpResponse::Ok()
                .content_type("application/pdf")
                .insert_header((
                    "Content-Disposition",
                    format!(
                        "attachment; filename=\"PV_{}_{}_{}.pdf\"",
                        building_entity.name.replace(' ', "_"),
                        meeting_entity.scheduled_date.format("%Y%m%d"),
                        meeting_entity.id
                    ),
                ))
                .body(pdf_bytes)
        }
        Err(err) => HttpResponse::InternalServerError().json(serde_json::json!({
            "error": format!("Failed to generate PDF: {}", err)
        })),
    }
}