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/tests/test_badges_pdf.py

@@ -236,3 +236,170 @@ def test_table_rows_beyond_the_frame_are_not_drawn():
     few = generate_badge_sheets_pdf([_table_badge(4, height_mm=12)], None, None)
     many = generate_badge_sheets_pdf([_table_badge(50, height_mm=12)], None, None)
     assert abs(len(many) - len(few)) < 50
+
+
+# --------------------------------------------------------------------------- #
+# Éditeur v2 : verso, fond de zone, réduction automatique, photo             #
+# --------------------------------------------------------------------------- #
+from app.badges import pdf as pdf_module  # noqa: E402
+from app.badges.pdf import fit_text, initials  # noqa: E402
+
+
+def _text_field(**kw) -> BadgeFieldSpec:
+    base = dict(
+        text="Alex", x_mm=5, y_mm=5, width_mm=60, height_mm=10,
+        font_size=12, align="LEFT", bold=False, color="#000000",
+    )
+    base.update(kw)
+    return BadgeFieldSpec(**base)
+
+
+def test_cell_origin_mirrors_the_column_on_the_back_page():
+    cols, _ = _grid_size(DEFAULT_BADGE_WIDTH_MM, DEFAULT_BADGE_HEIGHT_MM)
+    w, h = DEFAULT_BADGE_WIDTH_MM, DEFAULT_BADGE_HEIGHT_MM
+    # Retournement bord long : colonne 0 au recto ⇒ dernière colonne au
+    # verso, même rangée.
+    assert _cell_origin(0, cols, w, h, mirrored=True) == _cell_origin(cols - 1, cols, w, h)
+    assert _cell_origin(cols, cols, w, h, mirrored=True) == _cell_origin(
+        2 * cols - 1, cols, w, h
+    )
+
+
+def test_back_page_draws_each_volunteer_back_fields_at_the_mirrored_slot(monkeypatch):
+    calls = []
+    original = pdf_module._draw_fields
+
+    def spy(c, fields, x0, y0, badge_height_mm):
+        calls.append((fields, x0, y0))
+        original(c, fields, x0, y0, badge_height_mm)
+
+    monkeypatch.setattr(pdf_module, "_draw_fields", spy)
+    back = (_text_field(text="Verso Alex"),)
+    # Un seul badge : planche incomplète, le verso doit quand même être en
+    # miroir (colonne de droite).
+    generate_badge_sheets_pdf(
+        [BadgeSpec(fields=(_text_field(),), back_fields=back)], None, None
+    )
+
+    cols, _ = _grid_size(DEFAULT_BADGE_WIDTH_MM, DEFAULT_BADGE_HEIGHT_MM)
+    w, h = DEFAULT_BADGE_WIDTH_MM, DEFAULT_BADGE_HEIGHT_MM
+    (front_fields, fx, fy), (back_fields, bx, by) = calls
+    assert (fx, fy) == _cell_origin(0, cols, w, h)
+    assert back_fields == back
+    assert (bx, by) == _cell_origin(cols - 1, cols, w, h)
+
+
+def test_fit_text_without_auto_fit_drops_the_lines_that_overflow():
+    text = "\n".join(["ligne"] * 10)
+    size, lines = fit_text(text, "Helvetica", 12, 60, 10, auto_fit=False)
+    assert size == 12
+    assert 0 < len(lines) < 10
+
+
+def test_fit_text_with_auto_fit_shrinks_until_every_line_fits():
+    text = "\n".join(["ligne"] * 4)
+    assert len(fit_text(text, "Helvetica", 12, 60, 10, auto_fit=False)[1]) < 4
+    size, lines = fit_text(text, "Helvetica", 12, 60, 10, auto_fit=True)
+    assert 4 < size < 12
+    assert (size * 2) == int(size * 2)  # pas de 0,5 pt
+    assert len(lines) == 4
+
+
+def test_fit_text_auto_fit_stops_at_the_minimum_size():
+    text = "\n".join(["ligne"] * 200)
+    size, lines = fit_text(text, "Helvetica", 12, 60, 10, auto_fit=True)
+    assert size == 4.0
+    assert len(lines) < 200
+
+
+def test_fit_text_auto_fit_keeps_the_size_when_the_text_already_fits():
+    assert fit_text("Alex", "Helvetica", 12, 60, 10, auto_fit=True) == (12, ["Alex"])
+
+
+def _table_lines_drawn(monkeypatch, auto_fit: bool) -> int:
+    drawn = []
+    monkeypatch.setattr(
+        pdf_module.canvas.Canvas, "drawString",
+        lambda self, x, y, text, *a, **k: drawn.append(text),
+    )
+    badge = _table_badge(4, height_mm=20)
+    field = badge.fields[0]
+    badge = BadgeSpec(fields=(BadgeFieldSpec(**{**field.__dict__, "auto_fit": auto_fit}),))
+    generate_badge_sheets_pdf([badge], None, None)
+    return sum(1 for text in drawn if text == "19:00–22:00")
+
+
+def test_table_auto_fit_draws_every_row(monkeypatch):
+    # En-tête + 4 lignes : la dernière ne tient pas à 7 pt dans 20 mm.
+    assert _table_lines_drawn(monkeypatch, auto_fit=False) < 4
+    assert _table_lines_drawn(monkeypatch, auto_fit=True) == 4
+
+
+def _filled_rects(monkeypatch) -> list:
+    fills = []
+    original = pdf_module.canvas.Canvas.rect
+
+    def spy(self, x, y, w, h, stroke=1, fill=0):
+        if fill:
+            fills.append((round(w / mm, 3), round(h / mm, 3)))
+        return original(self, x, y, w, h, stroke=stroke, fill=fill)
+
+    monkeypatch.setattr(pdf_module.canvas.Canvas, "rect", spy)
+    return fills
+
+
+def test_zone_background_fills_the_field_frame(monkeypatch):
+    fills = _filled_rects(monkeypatch)
+    generate_badge_sheets_pdf(
+        [BadgeSpec(fields=(_text_field(bg_color="#FFD23F"),))], None, None
+    )
+    assert fills == [(60, 10)]
+
+
+def test_no_zone_background_by_default(monkeypatch):
+    fills = _filled_rects(monkeypatch)
+    generate_badge_sheets_pdf([BadgeSpec(fields=(_text_field(),))], None, None)
+    assert fills == []
+
+
+def test_middle_aligned_text_is_lower_than_top_aligned_text(monkeypatch):
+    baselines = []
+    monkeypatch.setattr(
+        pdf_module.canvas.Canvas, "drawString",
+        lambda self, x, y, text, *a, **k: baselines.append(y),
+    )
+    for valign in ("TOP", "MIDDLE"):
+        generate_badge_sheets_pdf(
+            [BadgeSpec(fields=(_text_field(height_mm=30, valign=valign),))], None, None
+        )
+    top, middle = baselines
+    assert middle < top
+
+
+def test_initials_are_the_uppercase_first_letters():
+    assert initials("alex", "martin") == "AM"
+    assert initials("Élodie", "de la Tour") == "ÉD"
+
+
+def test_missing_photo_prints_the_initials(monkeypatch):
+    drawn = []
+    monkeypatch.setattr(
+        pdf_module.canvas.Canvas, "drawCentredString",
+        lambda self, x, y, text, *a, **k: drawn.append(text),
+    )
+    for image in (None, b"pas une image"):
+        badge = BadgeSpec(
+            fields=(BadgeFieldSpec(**{**_photo_badge(image).fields[0].__dict__, "text": "AM"}),)
+        )
+        generate_badge_sheets_pdf([badge], None, None)
+    assert drawn == ["AM", "AM"]
+
+
+def test_oval_photo_and_oval_initials_generate_a_valid_pdf():
+    for image in (_jpeg(400, 500), None):
+        field = _photo_badge(image).fields[0]
+        badge = BadgeSpec(
+            fields=(BadgeFieldSpec(**{**field.__dict__, "photo_shape": "OVAL", "text": "AM"}),)
+        )
+        pdf = generate_badge_sheets_pdf([badge], None, None)
+        assert pdf.startswith(b"%PDF")