feat(stations): ricette in lista, reset per riga e cambio stazione al volo

Punto 7 del documento modifiche del 28/07, terza richiesta di Menoncin.

GET /api/stations ora usa StationWithRecipesResponse, che era gia' definita nello
schema senza che nessun endpoint la usasse. Non costa query in piu':
Station.assignments e' gia' selectin-loaded. In lista compaiono le sole ricette
attive, coerente con cio' che l'operatore vede davvero a quella stazione.

DELETE /api/stations/{id}/recipes azzera le assegnazioni di una stazione senza
eliminarla, cosi' si riassegna da capo. E' idempotente: azzerare una stazione gia'
vuota risponde removed=0, non 404. In tabella e' un pulsante per riga, con
conferma perche' l'azione e' distruttiva.

Il cambio stazione al volo (?station=CODE, override in sessione) serve al
collaudo: senza, provare N stazioni richiede N PC. E' dietro il flag
STATION_SWITCH_ENABLED, default 0. Non e' legato al ruolo admin perche'
/measure/select richiede MeasurementTec, e gatearlo su is_admin avrebbe escluso
proprio chi fa il collaudo. In fabbrica l'identita' della stazione viene
dall'installazione locale, e misurare contro le ricette di un'altra stazione
romperebbe in silenzio la tracciabilita': per questo il codice richiesto e'
validato prima di essere memorizzato - un refuso lascia l'operatore sulla
stazione configurata con un messaggio, invece di incastrarlo su una stazione
inesistente - e quando l'override e' attivo la pagina lo dichiara, con il codice
configurato accanto e un link per ripristinare.

Le traduzioni: pybabel update aveva indovinato dieci voci da stringhe simili
marcandole fuzzy, in entrambi i cataloghi. "Azzera Stazione" era diventato "Crea
Stazione", l'opposto, su un dialogo distruttivo. Non si vedeva perche' la
compilazione salta le fuzzy e ricade sul sorgente italiano, ma sarebbe emerso al
primo build con --use-fuzzy. Tradotte per esteso le 17 stringhe nuove in IT ed EN
e tolti i flag.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

src/backend/api/routers/stations.py

@@ -11,6 +11,8 @@ from src.backend.models.api.station import (
     StationResponse,
     StationRecipeAssignmentCreate,
     StationRecipeAssignmentResponse,
+    StationResetResponse,
+    StationWithRecipesResponse,
     RecipeSummary,
 )
 from src.backend.services import station_service
@@ -18,15 +20,36 @@ from src.backend.services import station_service
 router = APIRouter(prefix="/api/stations", tags=["stations"])
 
 
-@router.get("", response_model=list[StationResponse])
+@router.get("", response_model=list[StationWithRecipesResponse])
 async def list_stations(
     active_only: bool = False,
     admin: User = Depends(require_admin_user),
     db: AsyncSession = Depends(get_db),
 ):
-    """List all stations (admin only)."""
+    """List all stations with the recipes assigned to each (admin only).
+
+    The admin station list shows which products a station handles, so the
+    assignments travel with the station instead of needing a call per row.
+    Station.assignments is selectin-loaded, so this costs no extra query.
+
+    Only active recipes are listed, matching what an operator actually sees
+    at that station via /by-code/{code}/recipes.
+    """
     stations = await station_service.list_stations(db, active_only=active_only)
-    return [StationResponse.model_validate(s) for s in stations]
+    return [
+        StationWithRecipesResponse(
+            **StationResponse.model_validate(s).model_dump(),
+            recipes=sorted(
+                (
+                    RecipeSummary.model_validate(a.recipe)
+                    for a in s.assignments
+                    if a.recipe is not None and a.recipe.active
+                ),
+                key=lambda r: r.code,
+            ),
+        )
+        for s in stations
+    ]
 
 
 @router.post("", response_model=StationResponse, status_code=status.HTTP_201_CREATED)
@@ -128,6 +151,22 @@ async def assign_recipe_to_station(
     return StationRecipeAssignmentResponse.model_validate(assignment)
 
 
+@router.delete("/{station_id}/recipes", response_model=StationResetResponse)
+async def reset_station_recipes(
+    station_id: int,
+    admin: User = Depends(require_admin_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Clear every recipe assignment of a station (admin only).
+
+    Backs the per-row reset in the admin list: the station is left with no
+    recipes and can be reassigned from scratch, without deleting the station
+    itself. Idempotent - resetting an already empty station reports removed=0.
+    """
+    removed = await station_service.unassign_all_recipes(db, station_id)
+    return StationResetResponse(station_id=station_id, removed=removed)
+
+
 @router.delete(
     "/{station_id}/recipes/{recipe_id}",
     status_code=status.HTTP_204_NO_CONTENT,

src/backend/models/api/station.py

@@ -57,3 +57,10 @@ class RecipeSummary(BaseModel):
 
 class StationWithRecipesResponse(StationResponse):
     recipes: list[RecipeSummary] = Field(default_factory=list)
+
+
+class StationResetResponse(BaseModel):
+    """Outcome of clearing every recipe assignment of a station."""
+
+    station_id: int
+    removed: int

src/backend/services/station_service.py

@@ -138,6 +138,26 @@ async def unassign_recipe(
     await db.flush()
 
 
+async def unassign_all_recipes(db: AsyncSession, station_id: int) -> int:
+    """Drop every recipe assignment of a station and return how many were removed.
+
+    Used by the per-row reset in the admin station list: the station goes back to
+    having no recipes so it can be reassigned from scratch. Unlike unassign_recipe
+    this is idempotent - resetting an already empty station returns 0 rather than 404.
+    """
+    await get_station(db, station_id)
+    result = await db.execute(
+        select(StationRecipeAssignment).where(
+            StationRecipeAssignment.station_id == station_id
+        )
+    )
+    assignments = list(result.scalars().all())
+    for assignment in assignments:
+        await db.delete(assignment)
+    await db.flush()
+    return len(assignments)
+
+
 async def list_station_recipes(
     db: AsyncSession, station_id: int,
 ) -> list[Recipe]:

src/backend/tests/test_stations_api.py

@@ -201,3 +201,176 @@ async def test_duplicate_assignment_returns_409(
         json={"recipe_id": recipe.id},
     )
     assert second.status_code == 409
+
+
+# ---------------------------------------------------------------------------
+# Station list carries assigned recipes (point 7)
+# ---------------------------------------------------------------------------
+
+
+async def test_list_stations_includes_assigned_recipes(
+    client: AsyncClient, admin_user, db_session,
+):
+    """The admin list shows which recipes a station handles, without a call per row."""
+    recipe = await create_test_recipe(db_session, user_id=admin_user.id, code="REC-LIST")
+    await db_session.commit()
+    created = await client.post(
+        "/api/stations",
+        headers=auth_headers(admin_user),
+        json={"code": "ST-WITHREC", "name": "Con ricette"},
+    )
+    sid = created.json()["id"]
+    await client.post(
+        f"/api/stations/{sid}/recipes",
+        headers=auth_headers(admin_user),
+        json={"recipe_id": recipe.id},
+    )
+
+    resp = await client.get("/api/stations", headers=auth_headers(admin_user))
+    assert resp.status_code == 200
+    station = next(s for s in resp.json() if s["id"] == sid)
+    assert [r["code"] for r in station["recipes"]] == ["REC-LIST"]
+
+
+async def test_list_stations_empty_recipes_when_unassigned(
+    client: AsyncClient, admin_user,
+):
+    created = await client.post(
+        "/api/stations",
+        headers=auth_headers(admin_user),
+        json={"code": "ST-NOREC", "name": "Senza ricette"},
+    )
+    sid = created.json()["id"]
+    resp = await client.get("/api/stations", headers=auth_headers(admin_user))
+    station = next(s for s in resp.json() if s["id"] == sid)
+    assert station["recipes"] == []
+
+
+async def test_list_stations_hides_inactive_recipes(
+    client: AsyncClient, admin_user, db_session,
+):
+    """An assigned but deactivated recipe must not show: the operator won't see it."""
+    recipe = await create_test_recipe(db_session, user_id=admin_user.id, code="REC-OFF")
+    await db_session.commit()
+    created = await client.post(
+        "/api/stations",
+        headers=auth_headers(admin_user),
+        json={"code": "ST-INACT", "name": "Con ricetta spenta"},
+    )
+    sid = created.json()["id"]
+    await client.post(
+        f"/api/stations/{sid}/recipes",
+        headers=auth_headers(admin_user),
+        json={"recipe_id": recipe.id},
+    )
+
+    recipe.active = False
+    await db_session.commit()
+
+    resp = await client.get("/api/stations", headers=auth_headers(admin_user))
+    station = next(s for s in resp.json() if s["id"] == sid)
+    assert station["recipes"] == []
+
+
+# ---------------------------------------------------------------------------
+# Per-row station reset (point 7)
+# ---------------------------------------------------------------------------
+
+
+async def test_reset_station_removes_all_assignments(
+    client: AsyncClient, admin_user, db_session,
+):
+    first = await create_test_recipe(db_session, user_id=admin_user.id, code="REC-R1")
+    second = await create_test_recipe(db_session, user_id=admin_user.id, code="REC-R2")
+    await db_session.commit()
+    created = await client.post(
+        "/api/stations",
+        headers=auth_headers(admin_user),
+        json={"code": "ST-RESET", "name": "Da azzerare"},
+    )
+    sid = created.json()["id"]
+    for recipe in (first, second):
+        await client.post(
+            f"/api/stations/{sid}/recipes",
+            headers=auth_headers(admin_user),
+            json={"recipe_id": recipe.id},
+        )
+
+    resp = await client.delete(
+        f"/api/stations/{sid}/recipes", headers=auth_headers(admin_user),
+    )
+    assert resp.status_code == 200, resp.text
+    assert resp.json() == {"station_id": sid, "removed": 2}
+
+    left = await client.get(
+        f"/api/stations/{sid}/recipes", headers=auth_headers(admin_user),
+    )
+    assert left.json() == []
+
+
+async def test_reset_station_keeps_the_station(
+    client: AsyncClient, admin_user, db_session,
+):
+    """Reset clears assignments only - the station stays and can be reassigned."""
+    recipe = await create_test_recipe(db_session, user_id=admin_user.id, code="REC-KEEP")
+    await db_session.commit()
+    created = await client.post(
+        "/api/stations",
+        headers=auth_headers(admin_user),
+        json={"code": "ST-KEEP", "name": "Resta"},
+    )
+    sid = created.json()["id"]
+    await client.post(
+        f"/api/stations/{sid}/recipes",
+        headers=auth_headers(admin_user),
+        json={"recipe_id": recipe.id},
+    )
+    await client.delete(f"/api/stations/{sid}/recipes", headers=auth_headers(admin_user))
+
+    still_there = await client.get(
+        f"/api/stations/{sid}", headers=auth_headers(admin_user),
+    )
+    assert still_there.status_code == 200
+
+    reassigned = await client.post(
+        f"/api/stations/{sid}/recipes",
+        headers=auth_headers(admin_user),
+        json={"recipe_id": recipe.id},
+    )
+    assert reassigned.status_code == 201
+
+
+async def test_reset_empty_station_is_idempotent(client: AsyncClient, admin_user):
+    created = await client.post(
+        "/api/stations",
+        headers=auth_headers(admin_user),
+        json={"code": "ST-IDEM", "name": "Gia vuota"},
+    )
+    sid = created.json()["id"]
+    resp = await client.delete(
+        f"/api/stations/{sid}/recipes", headers=auth_headers(admin_user),
+    )
+    assert resp.status_code == 200
+    assert resp.json()["removed"] == 0
+
+
+async def test_reset_station_non_admin_is_403(
+    client: AsyncClient, admin_user, maker_user,
+):
+    created = await client.post(
+        "/api/stations",
+        headers=auth_headers(admin_user),
+        json={"code": "ST-RBAC", "name": "Protetta"},
+    )
+    sid = created.json()["id"]
+    resp = await client.delete(
+        f"/api/stations/{sid}/recipes", headers=auth_headers(maker_user),
+    )
+    assert resp.status_code == 403
+
+
+async def test_reset_unknown_station_is_404(client: AsyncClient, admin_user):
+    resp = await client.delete(
+        "/api/stations/999999/recipes", headers=auth_headers(admin_user),
+    )
+    assert resp.status_code == 404