benevoles/backend/app/api/notifications.py

"""Envoi d'emails d'information aux bénévoles (récapitulatif de planning)."""

import logging
import uuid
from collections import defaultdict

from fastapi import APIRouter, BackgroundTasks, Depends
from sqlmodel import Session, select

from app.api.deps import get_edition
from app.api.schemas import (
    PlanningNotificationRequest,
    PlanningNotificationResult,
)
from app.auth.deps import require_coordinator
from app.auth.magic_link import build_magic_link_url, issue_magic_link_token
from app.db import get_session
from app.email import edition_logo, render_planning, send_many
from app.i18n import t
from app.models import Account, Assignment, Edition, Position, Shift, Volunteer

logger = logging.getLogger("app.notifications")

router = APIRouter(
    prefix="/editions/{edition_id}/notifications", tags=["notifications"]
)

_LOGIN_PLACEHOLDER = "{lien_connexion}"


def _login_link(session: Session, edition: Edition, volunteer: Volunteer) -> str:
    """Lien magique personnel si le bénévole a un compte, sinon l'accueil."""
    account = session.exec(
        select(Account)
        .where(Account.edition_id == edition.id)
        .where(Account.volunteer_id == volunteer.id)
        .where(Account.password_hash.is_(None))
    ).first()
    if account is None:
        return build_magic_link_url("").split("?")[0]
    return build_magic_link_url(issue_magic_link_token(session, account))


@router.post("/planning", response_model=PlanningNotificationResult)
def send_planning_notification(
    payload: PlanningNotificationRequest,
    background: BackgroundTasks,
    edition: Edition = Depends(get_edition),
    _guard: Account = Depends(require_coordinator),
    session: Session = Depends(get_session),
) -> PlanningNotificationResult:
    subject_template = payload.subject or t("email.planning.default_subject")
    body_template = payload.body or t("email.planning.default_body")
    wants_login_link = _LOGIN_PLACEHOLDER in subject_template or (
        _LOGIN_PLACEHOLDER in body_template
    )

    stmt = select(Volunteer).where(Volunteer.edition_id == edition.id)
    if payload.volunteer_ids is not None:
        stmt = stmt.where(Volunteer.id.in_(payload.volunteer_ids))
    volunteers = list(session.exec(stmt.order_by(Volunteer.last_name)))

    positions = {
        p.id: p
        for p in session.exec(
            select(Position).where(Position.edition_id == edition.id)
        )
    }
    shifts_by_volunteer: dict[uuid.UUID, list[Shift]] = defaultdict(list)
    for volunteer_id, shift in session.exec(
        select(Assignment.volunteer_id, Shift)
        .join(Shift, Shift.id == Assignment.shift_id)
        .where(Assignment.edition_id == edition.id)
    ):
        shifts_by_volunteer[volunteer_id].append(shift)

    items: list[tuple[str, str, str]] = []
    recipients: list[uuid.UUID] = []
    skipped_no_email = 0
    for volunteer in volunteers:
        if not volunteer.email:
            skipped_no_email += 1
            continue
        shifts = sorted(
            shifts_by_volunteer.get(volunteer.id, []),
            key=lambda s: s.starts_at,
        )
        minutes = sum(
            (s.ends_at - s.starts_at).total_seconds() / 60 for s in shifts
        )
        shifts_text = "\n".join(
            t(
                "email.planning.shift_line",
                position=positions[s.position_id].name,
                start=s.starts_at.strftime("%d/%m %H:%M"),
                end=s.ends_at.strftime("%d/%m %H:%M"),
            )
            for s in shifts
        ) or t("email.planning.no_shifts")
        subject, body = render_planning(
            subject_template=subject_template,
            body_template=body_template,
            first_name=volunteer.first_name,
            last_name=volunteer.last_name,
            shift_count=len(shifts),
            hours=round(minutes / 60, 1),
            shifts_text=shifts_text,
            login_link=(
                _login_link(session, edition, volunteer)
                if wants_login_link
                else ""
            ),
        )
        items.append((volunteer.email, subject, body))
        recipients.append(volunteer.id)

    session.commit()  # persiste les éventuels MagicLinkToken émis
    logger.info(
        "Récapitulatif de planning (édition %s) : %d emails en file, %d bénévoles sans email",
        edition.id,
        len(items),
        skipped_no_email,
    )
    background.add_task(send_many, items, logo=edition_logo(session, edition.id))
    return PlanningNotificationResult(
        queued=len(items),
        skipped_no_email=skipped_no_email,
        recipients=recipients,
    )