Refonte du créateur de badges et nombre de badges par bénévole

Créateur de badges refait d'après la maquette : champs sur le recto et le
verso (BadgeField.face, verso placé en miroir dans le PDF pour le
recto-verso), fond de zone, réduction automatique du texte, photo ovale,
initiales sans photo, nom sur deux lignes (migration 0026) ; éditeur en
trois colonnes (champs, aperçu recto/verso avec de vrais bénévoles,
inspecteur), formats prédéfinis, annuler, flèches, zoom, repères de
découpe, dépôt d'image sur l'aperçu, contrôle de tous les badges avant
génération.

Nombre de badges par bénévole (Volunteer.badge_count, 1 par défaut,
migration 0027) : champ sur la fiche, autant d'exemplaires sur les
planches, total affiché à la génération, colonne dans l'export Excel.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

backend/app/badges/pdf.py

@@ -8,11 +8,12 @@ Format du badge : dérivé de l'image de fond du recto (pas de format fixe
 imposé) — voir `image_size_mm`. Tant qu'aucune image n'est importée,
 `DEFAULT_BADGE_WIDTH_MM`/`DEFAULT_BADGE_HEIGHT_MM` (CR80, 85,6 × 54 mm — la
 taille standard des badges/cartes d'événement) servent de repère à
-l'éditeur. Planche : grille sur page A4 portrait. Le verso est identique
-pour tous les bénévoles : la planche imprime toutes les pages de recto
-(personnalisées) puis, pour chacune, la page de verso correspondante (même
-disposition, même image répétée à chaque emplacement rempli) — impression
-recto-verso classique, page de verso n directement après la page de recto n.
+l'éditeur. Planche : grille sur page A4 portrait. Chaque page de recto est
+suivie de sa page de verso (même image de fond à chaque emplacement rempli,
+plus les champs du verso de chaque bénévole) — impression recto-verso
+classique, retournement sur le bord long : sur la page de verso, chaque
+badge est placé en miroir horizontal (colonne `cols - 1 - col`, même rangée)
+pour tomber exactement derrière son recto — voir `_cell_origin`.
 """
 
 import io
@@ -36,6 +37,13 @@ _LINE_HEIGHT_FACTOR = 1.25
 _CELL_PAD_X_MM = 0.8
 _CELL_PAD_Y_MM = 0.5
 _TABLE_LINE_WIDTH_PT = 0.4
+# Réduction automatique de la taille du texte (`auto_fit`) : pas et plancher.
+_AUTO_FIT_STEP_PT = 0.5
+_AUTO_FIT_MIN_PT = 4.0
+# Photo absente ou illisible : initiales sur ce fond, à cette taille (part de
+# la largeur du cadre).
+_INITIALS_BG = "#E7E0CE"
+_INITIALS_SIZE_RATIO = 0.28
 
 # Résolution supposée d'une image de fond importée, pour convertir ses pixels
 # en millimètres réels (donc en taille de badge) — 300 dpi est la résolution
@@ -73,14 +81,21 @@ class BadgeTable:
 @dataclass(frozen=True)
 class BadgeFieldSpec:
     """Un champ déjà résolu en texte (plusieurs lignes séparées par `\\n`
-    possibles — ex. un poste par ligne avec son horaire), positionné depuis
-    le coin haut-gauche du badge (comme dans l'éditeur visuel du front-end).
+    possibles — ex. prénom puis nom), positionné depuis le coin haut-gauche
+    du badge (comme dans l'éditeur visuel du front-end).
 
     `is_photo` : le champ est la photo du bénévole (`image`, ses octets
-    bruts tels que stockés) plutôt qu'un texte — `text` et le style sont
-    alors ignorés. Sans photo (`image` à `None`), rien n'est dessiné.
+    bruts tels que stockés) plutôt qu'un texte, découpée selon
+    `photo_shape` (`RECT`/`OVAL`). Sans photo (ou photo illisible), les
+    initiales du bénévole (`text`) sont imprimées à la place, sur un fond
+    neutre de la même forme.
 
-    `table` : le champ est un tableau (`text` ignoré) — voir `_draw_table`."""
+    `table` : le champ est un tableau (`text` ignoré) — voir `_draw_table`.
+
+    `bg_color` : fond plein de la zone du champ (`None` = transparent ;
+    ignoré pour la photo). `auto_fit` : réduit la taille du texte jusqu'à ce
+    que tout tienne dans le cadre (sinon, les lignes en trop ne sont pas
+    imprimées). `valign` : `TOP` ou `MIDDLE` (centré verticalement)."""
 
     text: str
     x_mm: float
@@ -94,13 +109,19 @@ class BadgeFieldSpec:
     is_photo: bool = False
     image: bytes | None = None
     table: BadgeTable | None = None
+    bg_color: str | None = None
+    auto_fit: bool = False
+    valign: str = "TOP"  # "TOP" | "MIDDLE"
+    photo_shape: str = "RECT"  # "RECT" | "OVAL"
 
 
 @dataclass(frozen=True)
 class BadgeSpec:
-    """Un badge = un bénévole, avec ses champs déjà résolus."""
+    """Un badge = un bénévole, avec ses champs déjà résolus : `fields` pour
+    le recto, `back_fields` pour le verso."""
 
     fields: tuple[BadgeFieldSpec, ...]
+    back_fields: tuple[BadgeFieldSpec, ...] = ()
 
 
 def _grid_size(badge_width_mm: float, badge_height_mm: float) -> tuple[int, int]:
@@ -112,11 +133,22 @@ def _grid_size(badge_width_mm: float, badge_height_mm: float) -> tuple[int, int]
 
 
 def _cell_origin(
-    index: int, cols: int, badge_width_mm: float, badge_height_mm: float
+    index: int,
+    cols: int,
+    badge_width_mm: float,
+    badge_height_mm: float,
+    mirrored: bool = False,
 ) -> tuple[float, float]:
     """Coin bas-gauche (repère PDF) de l'emplacement `index` sur la page,
-    en mm depuis le coin bas-gauche de la page."""
+    en mm depuis le coin bas-gauche de la page.
+
+    `mirrored` : page de verso. Une feuille retournée sur son bord long
+    inverse gauche et droite : le verso du badge de la colonne `col` doit
+    être imprimé en colonne `cols - 1 - col` (même rangée) pour tomber
+    derrière son recto — y compris sur une dernière planche incomplète."""
     col, row = index % cols, index // cols
+    if mirrored:
+        col = cols - 1 - col
     x0 = _MARGIN_MM + col * (badge_width_mm + _GUTTER_MM)
     y0 = _PAGE_HEIGHT_MM - _MARGIN_MM - (row + 1) * badge_height_mm - row * _GUTTER_MM
     return x0, y0
@@ -169,23 +201,73 @@ def _fit_photo(image: bytes, width_mm: float, height_mm: float) -> bytes | None:
     return out.getvalue()
 
 
+def _frame_rect(
+    f: BadgeFieldSpec, x0_mm: float, y0_mm: float, badge_height_mm: float
+) -> tuple[float, float, float, float]:
+    """Cadre du champ en points, repère PDF : (gauche, bas, largeur,
+    hauteur). `f.y_mm` est le haut du cadre depuis le HAUT du badge ;
+    reportlab dessine depuis le BAS de la page."""
+    return (
+        (x0_mm + f.x_mm) * mm,
+        (y0_mm + badge_height_mm - f.y_mm - f.height_mm) * mm,
+        f.width_mm * mm,
+        f.height_mm * mm,
+    )
+
+
+def _shape_path(c: canvas.Canvas, shape: str, x: float, y: float, w: float, h: float):
+    path = c.beginPath()
+    if shape == "OVAL":
+        path.ellipse(x, y, w, h)
+    else:
+        path.rect(x, y, w, h)
+    return path
+
+
+def initials(first_name: str, last_name: str) -> str:
+    """Initiales imprimées à la place d'une photo absente : première lettre
+    du prénom et du nom, en majuscules."""
+    return "".join(part.strip()[:1] for part in (first_name, last_name)).upper()
+
+
+def _draw_initials(c: canvas.Canvas, f: BadgeFieldSpec, x: float, y: float, w: float, h: float):
+    c.setFillColor(HexColor(_INITIALS_BG))
+    c.drawPath(_shape_path(c, f.photo_shape, x, y, w, h), stroke=0, fill=1)
+    if not f.text:
+        return
+    size = max(_AUTO_FIT_MIN_PT, w * _INITIALS_SIZE_RATIO)
+    c.setFont("Helvetica-Bold", size)
+    c.setFillColor(HexColor(f.color))
+    # Ligne de base décalée d'environ un tiers de la taille : centre
+    # visuel des majuscules (hauteur de capitale ≈ 0,7 × la taille).
+    c.drawCentredString(x + w / 2, y + h / 2 - size * 0.35, f.text)
+
+
 def _draw_photo(
     c: canvas.Canvas, f: BadgeFieldSpec, x0_mm: float, y0_mm: float, badge_height_mm: float
 ) -> None:
-    if not f.image:
-        return
-    photo = _fit_photo(f.image, f.width_mm, f.height_mm)
+    x, y, w, h = _frame_rect(f, x0_mm, y0_mm, badge_height_mm)
+    photo = _fit_photo(f.image, f.width_mm, f.height_mm) if f.image else None
+    c.saveState()
     if photo is None:
+        _draw_initials(c, f, x, y, w, h)
+    else:
+        if f.photo_shape == "OVAL":
+            # Découpe en ellipse inscrite dans le cadre.
+            c.clipPath(_shape_path(c, "OVAL", x, y, w, h), stroke=0, fill=0)
+        c.drawImage(ImageReader(io.BytesIO(photo)), x, y, width=w, height=h)
+    c.restoreState()
+
+
+def _draw_zone_background(
+    c: canvas.Canvas, f: BadgeFieldSpec, x0_mm: float, y0_mm: float, badge_height_mm: float
+) -> None:
+    if not f.bg_color:
         return
-    c.drawImage(
-        ImageReader(io.BytesIO(photo)),
-        (x0_mm + f.x_mm) * mm,
-        # `f.y_mm` est le haut du cadre depuis le HAUT du badge ; reportlab
-        # place l'image par son coin bas-gauche, depuis le BAS de la page.
-        (y0_mm + badge_height_mm - f.y_mm - f.height_mm) * mm,
-        width=f.width_mm * mm,
-        height=f.height_mm * mm,
-    )
+    c.saveState()
+    c.setFillColor(HexColor(f.bg_color))
+    c.rect(*_frame_rect(f, x0_mm, y0_mm, badge_height_mm), stroke=0, fill=1)
+    c.restoreState()
 
 
 def wrap_text(text: str, font_name: str, font_size: float, max_width_pt: float) -> list[str]:
@@ -242,6 +324,45 @@ def _column_widths(natural: list[float], available: float) -> list[float]:
     return widths
 
 
+_TableLine = tuple[list[list[str]], str, bool, float]
+
+
+def _table_layout(
+    table: BadgeTable, width_pt: float, font_size: float
+) -> tuple[list[float], list[_TableLine]]:
+    """Largeurs des colonnes et lignes du tableau à `font_size` : pour
+    chaque ligne, (texte replié de chaque cellule, police, en-tête de
+    section ?, hauteur en points)."""
+    regular, bold = "Helvetica", "Helvetica-Bold"
+    pad_x, pad_y = _CELL_PAD_X_MM * mm, _CELL_PAD_Y_MM * mm
+    line_height = font_size * _LINE_HEIGHT_FACTOR
+    body = [row for section in table.sections for row in section.rows]
+    columns = max(len(row) for row in body) if body else 1
+    natural = [
+        max(stringWidth(row[col], regular, font_size) for row in body) + 2 * pad_x
+        for col in range(columns)
+    ] if body else [0.0]
+    widths = _column_widths(natural, width_pt)
+    total_width = sum(widths)
+
+    # Un en-tête n'a qu'une cellule, sur toute la largeur.
+    cells_to_draw = []
+    for section in table.sections:
+        cells_to_draw.append(((section.title,), bold, True))
+        cells_to_draw.extend((row, regular, False) for row in section.rows)
+
+    lines: list[_TableLine] = []
+    for cells, font, is_title in cells_to_draw:
+        cell_widths = [total_width] if is_title else widths
+        wrapped = [
+            wrap_text(text, font, font_size, max(1.0, cell_widths[col] - 2 * pad_x))
+            for col, text in enumerate(cells)
+        ]
+        row_height = max(len(w) for w in wrapped) * line_height + 2 * pad_y
+        lines.append((wrapped, font, is_title, row_height))
+    return widths, lines
+
+
 def _draw_table(
     c: canvas.Canvas, f: BadgeFieldSpec, x0_mm: float, y0_mm: float, badge_height_mm: float
 ) -> None:
@@ -250,52 +371,43 @@ def _draw_table(
     filets à la couleur du champ, texte de chaque cellule replié dans sa
     colonne (`wrap_text`). Une ligne qui ne tient plus dans la hauteur du
     cadre n'est pas dessinée, ni les suivantes — comme les lignes d'un champ
-    texte."""
+    texte — sauf avec `auto_fit`, qui réduit la taille du texte jusqu'à ce
+    que toutes les lignes tiennent (plancher `_AUTO_FIT_MIN_PT`)."""
     table = f.table
     if table is None or not table.sections:
         return
-    regular, bold = "Helvetica", "Helvetica-Bold"
     pad_x, pad_y = _CELL_PAD_X_MM * mm, _CELL_PAD_Y_MM * mm
-    line_height = f.font_size * _LINE_HEIGHT_FACTOR
-    body = [row for section in table.sections for row in section.rows]
-    columns = max(len(row) for row in body) if body else 1
-    natural = [
-        max(stringWidth(row[col], regular, f.font_size) for row in body) + 2 * pad_x
-        for col in range(columns)
-    ] if body else [0.0]
-    widths = _column_widths(natural, f.width_mm * mm)
+    width_pt, height_pt = f.width_mm * mm, f.height_mm * mm
+    font_size = f.font_size
+    widths, lines_to_draw = _table_layout(table, width_pt, font_size)
+    if f.auto_fit:
+        while (
+            sum(line[3] for line in lines_to_draw) > height_pt + 0.01
+            and font_size - _AUTO_FIT_STEP_PT >= _AUTO_FIT_MIN_PT
+        ):
+            font_size -= _AUTO_FIT_STEP_PT
+            widths, lines_to_draw = _table_layout(table, width_pt, font_size)
+    line_height = font_size * _LINE_HEIGHT_FACTOR
     total_width = sum(widths)
 
-    # (cellules, police, en-tête de section ?) — un en-tête n'a qu'une
-    # cellule, sur toute la largeur.
-    lines_to_draw = []
-    for section in table.sections:
-        lines_to_draw.append(((section.title,), bold, True))
-        lines_to_draw.extend((row, regular, False) for row in section.rows)
-
     left = (x0_mm + f.x_mm) * mm
     top = (y0_mm + badge_height_mm - f.y_mm) * mm
-    bottom_limit = top - f.height_mm * mm
+    bottom_limit = top - height_pt
     color = HexColor(f.color)
     c.setFillColor(color)
     c.setStrokeColor(color)
     c.setLineWidth(_TABLE_LINE_WIDTH_PT)
 
     y = top
-    for cells, font, is_title in lines_to_draw:
+    for wrapped, font, is_title, row_height in lines_to_draw:
         cell_widths = [total_width] if is_title else widths
-        wrapped = [
-            wrap_text(text, font, f.font_size, max(1.0, cell_widths[col] - 2 * pad_x))
-            for col, text in enumerate(cells)
-        ]
-        row_height = max(len(lines) for lines in wrapped) * line_height + 2 * pad_y
         if y - row_height < bottom_limit - 0.01:
             break  # la ligne déborderait du cadre du champ
-        c.setFont(font, f.font_size)
+        c.setFont(font, font_size)
         x = left
         for col, lines in enumerate(wrapped):
             for i, line in enumerate(lines):
-                baseline = y - pad_y - f.font_size * 0.85 - i * line_height
+                baseline = y - pad_y - font_size * 0.85 - i * line_height
                 c.drawString(x + pad_x, baseline, line)
             x += cell_widths[col]
         if not is_title:
@@ -312,6 +424,71 @@ def _draw_table(
     c.rect(left, y, total_width, top - y, stroke=1, fill=0)
 
 
+def _lines_that_fit(font_size: float, height_mm: float) -> int:
+    """Nombre de lignes de texte qui tiennent dans `height_mm` (première
+    ligne de base à 0,85 × la taille sous le haut du cadre, puis un
+    interligne par ligne)."""
+    font_size_mm = font_size / mm
+    first = font_size_mm * 0.85
+    if first > height_mm + 1e-9:
+        return 0
+    return 1 + int((height_mm - first) / (font_size_mm * _LINE_HEIGHT_FACTOR) + 1e-9)
+
+
+def fit_text(
+    text: str, font_name: str, font_size: float, width_mm: float, height_mm: float,
+    auto_fit: bool,
+) -> tuple[float, list[str]]:
+    """Taille retenue et lignes à imprimer d'un champ texte. Sans
+    `auto_fit` : la taille du champ, lignes en trop retirées. Avec : taille
+    réduite par pas de `_AUTO_FIT_STEP_PT` (plancher `_AUTO_FIT_MIN_PT`)
+    jusqu'à ce que toutes les lignes repliées tiennent dans le cadre."""
+    lines = wrap_text(text, font_name, font_size, width_mm * mm)
+    if auto_fit:
+        while (
+            len(lines) > _lines_that_fit(font_size, height_mm)
+            and font_size - _AUTO_FIT_STEP_PT >= _AUTO_FIT_MIN_PT
+        ):
+            font_size -= _AUTO_FIT_STEP_PT
+            lines = wrap_text(text, font_name, font_size, width_mm * mm)
+    return font_size, lines[: _lines_that_fit(font_size, height_mm)]
+
+
+def _draw_text(
+    c: canvas.Canvas, f: BadgeFieldSpec, x0_mm: float, y0_mm: float, badge_height_mm: float
+) -> None:
+    font_name = "Helvetica-Bold" if f.bold else "Helvetica"
+    font_size, lines = fit_text(
+        f.text, font_name, f.font_size, f.width_mm, f.height_mm, f.auto_fit
+    )
+    if not lines:
+        return
+    c.setFont(font_name, font_size)
+    c.setFillColor(HexColor(f.color))
+    left_x = x0_mm + f.x_mm
+    # `font_size` est en points (unité reportlab) ; le reste du calcul
+    # travaille en mm ⇒ on convertit d'abord (1 pt = 1/mm mm, `mm` étant
+    # ici le facteur de conversion pt/mm de reportlab).
+    font_size_mm = font_size / mm
+    line_height_mm = font_size_mm * _LINE_HEIGHT_FACTOR
+    # `f.y_mm` est depuis le HAUT du badge (repère écran) ; reportlab
+    # dessine depuis le BAS de la page.
+    top_y = y0_mm + badge_height_mm - f.y_mm
+    if f.valign == "MIDDLE":
+        # Hauteur du bloc : interlignes entre les lignes + une hauteur de
+        # caractère pour la dernière.
+        block = (len(lines) - 1) * line_height_mm + font_size_mm
+        top_y -= max(0.0, (f.height_mm - block) / 2)
+    for i, line in enumerate(lines):
+        baseline_y = top_y - font_size_mm * 0.85 - i * line_height_mm
+        if f.align == "CENTER":
+            c.drawCentredString((left_x + f.width_mm / 2) * mm, baseline_y * mm, line)
+        elif f.align == "RIGHT":
+            c.drawRightString((left_x + f.width_mm) * mm, baseline_y * mm, line)
+        else:
+            c.drawString(left_x * mm, baseline_y * mm, line)
+
+
 def _draw_fields(
     c: canvas.Canvas,
     fields: tuple[BadgeFieldSpec, ...],
@@ -323,33 +500,11 @@ def _draw_fields(
         if f.is_photo:
             _draw_photo(c, f, x0_mm, y0_mm, badge_height_mm)
             continue
+        _draw_zone_background(c, f, x0_mm, y0_mm, badge_height_mm)
         if f.table is not None:
             _draw_table(c, f, x0_mm, y0_mm, badge_height_mm)
-            continue
-        font_name = "Helvetica-Bold" if f.bold else "Helvetica"
-        c.setFont(font_name, f.font_size)
-        c.setFillColor(HexColor(f.color))
-        left_x = x0_mm + f.x_mm
-        # `f.font_size` est en points (unité reportlab) ; le reste du calcul
-        # travaille en mm ⇒ on convertit d'abord (1 pt = 1/mm mm, `mm` étant
-        # ici le facteur de conversion pt/mm de reportlab).
-        font_size_mm = f.font_size / mm
-        line_height_mm = font_size_mm * _LINE_HEIGHT_FACTOR
-        # `f.y_mm` est depuis le HAUT du badge (repère écran) ; reportlab
-        # dessine depuis le BAS de la page.
-        top_y = y0_mm + badge_height_mm - f.y_mm
-        bottom_limit = top_y - f.height_mm
-        lines = wrap_text(f.text, font_name, f.font_size, f.width_mm * mm)
-        for i, line in enumerate(lines):
-            baseline_y = top_y - font_size_mm * 0.85 - i * line_height_mm
-            if baseline_y < bottom_limit:
-                break  # la ligne déborderait de la boîte du champ
-            if f.align == "CENTER":
-                c.drawCentredString((left_x + f.width_mm / 2) * mm, baseline_y * mm, line)
-            elif f.align == "RIGHT":
-                c.drawRightString((left_x + f.width_mm) * mm, baseline_y * mm, line)
-            else:
-                c.drawString(left_x * mm, baseline_y * mm, line)
+        else:
+            _draw_text(c, f, x0_mm, y0_mm, badge_height_mm)
 
 
 def generate_badge_sheets_pdf(
@@ -374,9 +529,10 @@ def generate_badge_sheets_pdf(
             _draw_fields(c, badge.fields, x0, y0, badge_height_mm)
         c.showPage()
 
-        for i in range(len(page_badges)):
-            x0, y0 = _cell_origin(i, cols, badge_width_mm, badge_height_mm)
+        for i, badge in enumerate(page_badges):
+            x0, y0 = _cell_origin(i, cols, badge_width_mm, badge_height_mm, mirrored=True)
             _draw_background(c, back_image, x0, y0, badge_width_mm, badge_height_mm)
+            _draw_fields(c, badge.back_fields, x0, y0, badge_height_mm)
         c.showPage()
     c.save()
     return buffer.getvalue()