Créneaux types : paramétrage + génération auto des créneaux

Le paramétrage des créneaux se fait dans « Règles & édition » : la coordination
définit des créneaux types (DayPart). À la création d'un poste, un créneau à
besoin 0/0 est généré pour chaque jour de l'édition et chaque créneau type ;
les coordinateurs ajustent ensuite min/idéal.

Back-end :
- DayPart CRUD (GET/POST/PATCH/DELETE /editions/{id}/day-parts). Code figé
  après création (slugifié depuis le libellé si absent), unique par édition.
- Shift.day_part_id (nullable, SET NULL) + migration 0004.
- create_position génère les créneaux ; POST .../positions/{pid}/generate-shifts
  recrée les manquants (idempotent, ne touche pas aux besoins déjà réglés).
- 13 tests (day-parts, génération, extension d'édition, ajout de type).

Front-end :
- api/hooks/mock : dayParts CRUD + positions.generateShifts.
- ConfigRules : panneau « Créneaux types » (libellé + horaires éditables,
  ajout, suppression).
- ConfigGrid : bouton « Générer les créneaux » sur l'en-tête du poste.
- GrillePage : case « à définir » (gris, glyphe ·) quand min=idéal=0, avec
  entrée de légende.

155 tests back OK ; typecheck + lint + build + smoke front OK.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017uUsRg7XzopkCPWimwg9ZM

backend/app/api/_shiftgen.py

@@ -0,0 +1,55 @@
+"""Génération des créneaux d'un poste à partir des créneaux types (DayPart)."""
+
+import datetime as dt
+
+from sqlmodel import Session, select
+
+from app.models import DayPart, Edition, Position, Shift
+
+
+def _dates(edition: Edition) -> list[dt.date]:
+    span = (edition.end_date - edition.start_date).days
+    return [edition.start_date + dt.timedelta(days=i) for i in range(span + 1)]
+
+
+def _window(day: dt.date, part: DayPart) -> tuple[dt.datetime, dt.datetime]:
+    start = dt.datetime.combine(day, part.start_time)
+    end_day = (
+        day if part.end_time > part.start_time else day + dt.timedelta(days=1)
+    )
+    return start, dt.datetime.combine(end_day, part.end_time)
+
+
+def generate_missing_shifts(
+    session: Session, edition: Edition, position: Position
+) -> int:
+    """Crée, pour chaque jour de l'édition et chaque créneau type, un créneau à
+    besoin 0/0 s'il n'existe pas déjà. Retourne le nombre créé."""
+    day_parts = list(
+        session.exec(select(DayPart).where(DayPart.edition_id == edition.id))
+    )
+    existing = {
+        (s.day_part_id, s.starts_at.date())
+        for s in session.exec(
+            select(Shift).where(Shift.position_id == position.id)
+        )
+    }
+    created = 0
+    for day in _dates(edition):
+        for part in day_parts:
+            if (part.id, day) in existing:
+                continue
+            start, end = _window(day, part)
+            session.add(
+                Shift(
+                    edition_id=edition.id,
+                    position_id=position.id,
+                    day_part_id=part.id,
+                    starts_at=start,
+                    ends_at=end,
+                    min_staff=0,
+                    ideal_staff=0,
+                )
+            )
+            created += 1
+    return created

backend/app/api/day_parts.py

@@ -0,0 +1,100 @@
+"""CRUD des créneaux types (`DayPart`) d'une édition.
+
+Un poste, à sa création, reçoit un créneau (besoin 0/0) par jour et par créneau
+type. Le `code` sert de clé stable pour l'import des disponibilités : il est
+figé après création."""
+
+import uuid
+
+from fastapi import APIRouter, Depends, HTTPException, Response, status
+from sqlalchemy.exc import IntegrityError
+from sqlmodel import Session, select
+
+from app.api._common import owned_or_404
+from app.api.deps import get_edition
+from app.api.schemas import DayPartCreate, DayPartRead, DayPartUpdate
+from app.auth.deps import current_account_in_edition, require_coordinator
+from app.db import get_session
+from app.importing.text import slug_code
+from app.models import Account, DayPart, Edition
+
+router = APIRouter(
+    prefix="/editions/{edition_id}/day-parts", tags=["day-parts"]
+)
+
+
+@router.get("", response_model=list[DayPartRead])
+def list_day_parts(
+    edition: Edition = Depends(get_edition),
+    _account: Account = Depends(current_account_in_edition),
+    session: Session = Depends(get_session),
+) -> list[DayPart]:
+    return list(
+        session.exec(
+            select(DayPart)
+            .where(DayPart.edition_id == edition.id)
+            .order_by(DayPart.order, DayPart.start_time)
+        )
+    )
+
+
+@router.post("", response_model=DayPartRead, status_code=status.HTTP_201_CREATED)
+def create_day_part(
+    payload: DayPartCreate,
+    edition: Edition = Depends(get_edition),
+    _guard: Account = Depends(require_coordinator),
+    session: Session = Depends(get_session),
+) -> DayPart:
+    code = (payload.code or slug_code(payload.label)).strip()
+    if not code:
+        raise HTTPException(
+            status_code=422, detail={"code": "day_part.code_required"}
+        )
+    day_part = DayPart(
+        edition_id=edition.id,
+        code=code,
+        label=payload.label.strip(),
+        start_time=payload.start_time,
+        end_time=payload.end_time,
+        order=payload.order,
+    )
+    session.add(day_part)
+    try:
+        session.commit()
+    except IntegrityError as exc:
+        session.rollback()
+        raise HTTPException(
+            status_code=409, detail={"code": "day_part.duplicate_code"}
+        ) from exc
+    session.refresh(day_part)
+    return day_part
+
+
+@router.patch("/{day_part_id}", response_model=DayPartRead)
+def update_day_part(
+    day_part_id: uuid.UUID,
+    payload: DayPartUpdate,
+    edition: Edition = Depends(get_edition),
+    _guard: Account = Depends(require_coordinator),
+    session: Session = Depends(get_session),
+) -> DayPart:
+    day_part = owned_or_404(session.get(DayPart, day_part_id), edition.id)
+    for field, value in payload.model_dump(exclude_unset=True).items():
+        setattr(day_part, field, value)
+    session.commit()
+    session.refresh(day_part)
+    return day_part
+
+
+@router.delete("/{day_part_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_day_part(
+    day_part_id: uuid.UUID,
+    edition: Edition = Depends(get_edition),
+    _guard: Account = Depends(require_coordinator),
+    session: Session = Depends(get_session),
+) -> Response:
+    day_part = owned_or_404(session.get(DayPart, day_part_id), edition.id)
+    # Cascade base : disponibilités supprimées, day_part_id des créneaux -> NULL.
+    session.delete(day_part)
+    session.commit()
+    return Response(status_code=status.HTTP_204_NO_CONTENT)

backend/app/api/positions.py

@@ -6,8 +6,14 @@ from fastapi import APIRouter, Depends, Response, status
 from sqlmodel import Session, select
 
 from app.api._common import owned_or_404
+from app.api._shiftgen import generate_missing_shifts
 from app.api.deps import get_edition
-from app.api.schemas import PositionCreate, PositionRead, PositionUpdate
+from app.api.schemas import (
+    GenerateShiftsResult,
+    PositionCreate,
+    PositionRead,
+    PositionUpdate,
+)
 from app.auth.deps import (
     current_account_in_edition,
     ensure_can_write_position,
@@ -31,6 +37,9 @@ def create_position(
 ) -> Position:
     position = Position(edition_id=edition.id, **payload.model_dump())
     session.add(position)
+    session.flush()
+    # Un créneau à besoin 0/0 par jour et par créneau type de l'édition.
+    generate_missing_shifts(session, edition, position)
     session.commit()
     session.refresh(position)
     return position
@@ -78,6 +87,24 @@ def update_position(
     return position
 
 
+@router.post(
+    "/{position_id}/generate-shifts", response_model=GenerateShiftsResult
+)
+def generate_shifts(
+    position_id: uuid.UUID,
+    edition: Edition = Depends(get_edition),
+    account: Account = Depends(current_account_in_edition),
+    session: Session = Depends(get_session),
+) -> GenerateShiftsResult:
+    """(Re)génère les créneaux manquants du poste après un ajout de créneau
+    type ou une extension des dates de l'édition. N'écrase rien d'existant."""
+    position = owned_or_404(session.get(Position, position_id), edition.id)
+    ensure_can_write_position(account, position)
+    created = generate_missing_shifts(session, edition, position)
+    session.commit()
+    return GenerateShiftsResult(created=created)
+
+
 @router.delete("/{position_id}", status_code=status.HTTP_204_NO_CONTENT)
 def delete_position(
     position_id: uuid.UUID,

backend/app/api/schemas.py

@@ -135,6 +135,7 @@ class ShiftRead(ApiModel):
     id: uuid.UUID
     edition_id: uuid.UUID
     position_id: uuid.UUID
+    day_part_id: uuid.UUID | None
     starts_at: dt.datetime
     ends_at: dt.datetime
     min_staff: int
@@ -144,6 +145,41 @@ class ShiftRead(ApiModel):
     updated_at: dt.datetime
 
 
+class GenerateShiftsResult(ApiModel):
+    created: int
+
+
+# --------------------------------------------------------------------------- #
+# DayPart (créneau type)                                                       #
+# --------------------------------------------------------------------------- #
+class DayPartRead(ApiModel):
+    id: uuid.UUID
+    edition_id: uuid.UUID
+    code: str
+    label: str
+    start_time: dt.time
+    end_time: dt.time
+    order: int
+    created_at: dt.datetime
+    updated_at: dt.datetime
+
+
+class DayPartCreate(ApiModel):
+    label: str
+    start_time: dt.time
+    end_time: dt.time
+    # Déduit du label si absent. Immuable ensuite (référencé par l'import).
+    code: str | None = None
+    order: int = 0
+
+
+class DayPartUpdate(ApiModel):
+    label: str | None = None
+    start_time: dt.time | None = None
+    end_time: dt.time | None = None
+    order: int | None = None
+
+
 # --------------------------------------------------------------------------- #
 # Assignment                                                                   #
 # --------------------------------------------------------------------------- #

backend/app/i18n/locales/fr.json

@@ -6,6 +6,8 @@
   "error.validation_failed": "La validation a échoué",
   "error.conflict": "Conflit avec une ressource existante.",
   "edition.dates_inconsistent": "La date de fin doit être postérieure ou égale à la date de début.",
+  "day_part.code_required": "Le code du créneau type ne peut pas être vide.",
+  "day_part.duplicate_code": "Un créneau type porte déjà ce code dans l'édition.",
   "shift.ends_not_after_starts": "La fin du créneau doit être postérieure à son début.",
   "shift.position_wrong_edition": "Le poste n'appartient pas à cette édition.",
   "volunteer.duplicate_email": "Un bénévole avec cet email existe déjà dans l'édition.",

backend/app/main.py

@@ -4,6 +4,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from app.api.accounts import router as account_router
 from app.api.assignments import router as assignment_router
 from app.api.auth import router as auth_router
+from app.api.day_parts import router as day_part_router
 from app.api.editions import router as edition_router
 from app.api.health import router as health_router
 from app.api.imports import router as import_router
@@ -32,6 +33,7 @@ app.add_middleware(
 app.include_router(health_router)
 app.include_router(auth_router)
 app.include_router(edition_router)
+app.include_router(day_part_router)
 app.include_router(account_router)
 app.include_router(import_router)
 app.include_router(volunteer_router)

backend/app/migrations/versions/0004_shift_day_part.py

@@ -0,0 +1,34 @@
+"""Créneau : lien optionnel vers le créneau type (day_part)
+
+Revision ID: 0004_shift_day_part
+Revises: 0003_drop_assignment_status
+Create Date: 2026-09-10
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0004_shift_day_part"
+down_revision: str | None = "0003_drop_assignment_status"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+_FK = "shift_day_part_id_fkey"
+
+
+def upgrade() -> None:
+    op.add_column("shift", sa.Column("day_part_id", sa.Uuid(), nullable=True))
+    op.create_index("ix_shift_day_part_id", "shift", ["day_part_id"])
+    op.create_foreign_key(
+        _FK, "shift", "day_part", ["day_part_id"], ["id"], ondelete="SET NULL"
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint(_FK, "shift", type_="foreignkey")
+    op.drop_index("ix_shift_day_part_id", table_name="shift")
+    op.drop_column("shift", "day_part_id")

backend/app/models/domain.py

@@ -238,6 +238,15 @@ class Shift(TimestampMixin, table=True):
     starts_at: dt.datetime
     # Peut être le lendemain de starts_at (créneau à cheval sur minuit).
     ends_at: dt.datetime
+    # Créneau type dont ce créneau est issu (génération à la création d'un
+    # poste). NULL = créneau ad hoc. SET NULL si le type est supprimé.
+    day_part_id: uuid.UUID | None = Field(
+        default=None,
+        foreign_key="day_part.id",
+        ondelete="SET NULL",
+        nullable=True,
+        index=True,
+    )
     min_staff: int = Field(
         default=0, sa_column=Column(Integer, nullable=False, server_default="0")
     )

backend/tests/test_api_day_parts.py

@@ -0,0 +1,82 @@
+import datetime as dt
+
+from sqlmodel import select
+
+from app.models import Availability, AvailabilityStatus, Role, Shift
+from tests.factories import dt_at, make_position, make_shift, make_volunteer
+
+
+def _url(edition, suffix=""):
+    return f"/editions/{edition.id}/day-parts{suffix}"
+
+
+def test_list_returns_the_three_fixture_types(client, edition):
+    body = client.get(_url(edition)).json()
+    assert [d["code"] for d in body] == ["MORNING", "AFTERNOON", "EVENING"]
+
+
+def test_create_slugs_the_code_from_the_label(client, edition):
+    resp = client.post(
+        _url(edition),
+        json={"label": "Nuit profonde", "start_time": "02:00", "end_time": "06:00", "order": 3},
+    )
+    assert resp.status_code == 201
+    assert resp.json()["code"] == "NUIT_PROFONDE"
+
+
+def test_create_duplicate_code_conflicts(client, edition):
+    body = {
+        "code": "MORNING",
+        "label": "Matin bis",
+        "start_time": "06:00",
+        "end_time": "13:00",
+    }
+    resp = client.post(_url(edition), json=body)
+    assert resp.status_code == 409
+    assert resp.json()["detail"]["code"] == "day_part.duplicate_code"
+
+
+def test_update_day_part(client, edition):
+    dp_id = client.get(_url(edition)).json()[0]["id"]
+    resp = client.patch(
+        _url(edition, f"/{dp_id}"), json={"label": "Tôt le matin", "end_time": "12:00"}
+    )
+    assert resp.status_code == 200
+    assert resp.json()["label"] == "Tôt le matin"
+    assert resp.json()["end_time"] == "12:00:00"
+
+
+def test_delete_unlinks_shifts_and_removes_availabilities(
+    client, edition, session, day_parts
+):
+    morning = day_parts["MORNING"]
+    position = make_position(session, edition)
+    shift = make_shift(
+        session, edition, position, start=dt_at(10, 6), end=dt_at(10, 13)
+    )
+    shift.day_part_id = morning.id
+    volunteer = make_volunteer(session, edition, email="v@e.fr")
+    session.add(
+        Availability(
+            edition_id=edition.id, volunteer_id=volunteer.id,
+            date=dt.date(2026, 7, 10), day_part_id=morning.id,
+            status=AvailabilityStatus.AVAILABLE,
+        )
+    )
+    session.commit()
+
+    assert client.delete(_url(edition, f"/{morning.id}")).status_code == 204
+    session.expire_all()
+    assert session.get(Shift, shift.id).day_part_id is None
+    assert session.exec(select(Availability)).all() == []
+
+
+def test_write_is_coordinator_only(edition, make_account, as_account):
+    lead = make_account(Role.LEAD, email="lead@e.fr")
+    client = as_account(lead)
+    assert client.get(_url(edition)).status_code == 200
+    resp = client.post(
+        _url(edition),
+        json={"label": "X", "start_time": "08:00", "end_time": "09:00"},
+    )
+    assert resp.status_code == 403

backend/tests/test_shift_generation.py

@@ -0,0 +1,72 @@
+"""Génération des créneaux d'un poste à partir des créneaux types."""
+
+
+def _positions_url(edition):
+    return f"/editions/{edition.id}/positions"
+
+
+def _create_position(client, edition, name="Bar"):
+    return client.post(
+        _positions_url(edition), json={"name": name, "category": "BAR"}
+    ).json()
+
+
+def test_creating_a_position_generates_one_shift_per_day_and_type(client, edition):
+    position = _create_position(client, edition)
+    shifts = client.get(
+        f"/editions/{edition.id}/shifts", params={"position_id": position["id"]}
+    ).json()
+    # 4 jours (2026-07-09..12) x 3 créneaux types.
+    assert len(shifts) == 12
+    assert all(s["min_staff"] == 0 and s["ideal_staff"] == 0 for s in shifts)
+    assert all(s["day_part_id"] is not None for s in shifts)
+
+
+def test_generate_is_idempotent(client, edition):
+    position = _create_position(client, edition)
+    resp = client.post(
+        f"{_positions_url(edition)}/{position['id']}/generate-shifts"
+    )
+    assert resp.status_code == 200
+    assert resp.json()["created"] == 0
+
+
+def test_extending_the_edition_then_generating_adds_the_new_days(client, edition):
+    position = _create_position(client, edition)
+    client.patch(f"/editions/{edition.id}", json={"end_date": "2026-07-14"})
+
+    resp = client.post(
+        f"{_positions_url(edition)}/{position['id']}/generate-shifts"
+    )
+    # 2 jours de plus x 3 créneaux types.
+    assert resp.json()["created"] == 6
+    shifts = client.get(
+        f"/editions/{edition.id}/shifts", params={"position_id": position["id"]}
+    ).json()
+    assert len(shifts) == 18
+
+
+def test_adding_a_day_part_then_generating_adds_it_everywhere(client, edition):
+    position = _create_position(client, edition)
+    client.post(
+        f"/editions/{edition.id}/day-parts",
+        json={"label": "Nuit", "start_time": "02:00", "end_time": "05:00"},
+    )
+    resp = client.post(
+        f"{_positions_url(edition)}/{position['id']}/generate-shifts"
+    )
+    assert resp.json()["created"] == 4  # 1 par jour
+
+
+def test_generation_does_not_touch_staffing_already_set(client, edition):
+    position = _create_position(client, edition)
+    shift = client.get(
+        f"/editions/{edition.id}/shifts", params={"position_id": position["id"]}
+    ).json()[0]
+    client.patch(
+        f"/editions/{edition.id}/shifts/{shift['id']}",
+        json={"min_staff": 3, "ideal_staff": 5},
+    )
+    client.post(f"{_positions_url(edition)}/{position['id']}/generate-shifts")
+    again = client.get(f"/editions/{edition.id}/shifts/{shift['id']}").json()
+    assert again["min_staff"] == 3 and again["ideal_staff"] == 5