feat(meals): enforce three lower-calorie dinners with media

backend/app/api/admin.py

@@ -1,12 +1,32 @@
-from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Query, Response, status
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import Session
 from app.database import get_db
-from app.models import ScrapeLog, EmailLog, MealPlan, Recipe
+from app.models import (
+    FamilyProfile,
+    ScrapeLog,
+    EmailLog,
+    MealPlan,
+    Recipe,
+    RecipeImportStaging,
+    RecipeImportStatus,
+)
+from app.schemas.recipe_import import (
+    RecipeImportDetail,
+    RecipeImportListResponse,
+    RecipeImportRejectRequest,
+)
 from app.security import require_admin
 from app.services.scraper_service import ScraperService, enqueue_scrape
 from app.services.feedback_analyzer import FeedbackAnalyzer
-from app.services.recipe_discovery import RecipeDiscoveryService
-from app.services.recipe_ingestion import RecipeIngestionService
+from app.services.recipe_import_review import (
+    RecipeImportConflictError,
+    RecipeImportNotFoundError,
+    approve_recipe_import,
+    reject_recipe_import,
+)
+from app.services.wikibooks_import import WikibooksImportError, WikibooksImportService
+from app.config import settings
 from typing import List, Optional
 from datetime import datetime, timedelta
 from uuid import UUID
@@ -17,6 +37,99 @@ logger = logging.getLogger(__name__)
 router = APIRouter(dependencies=[Depends(require_admin)])
 
 
+def _import_list_item(row: RecipeImportStaging) -> dict:
+    normalized = row.normalized_recipe if isinstance(row.normalized_recipe, dict) else {}
+    return {
+        "id": row.id,
+        "source": row.source,
+        "external_id": row.external_id,
+        "source_url": row.source_url,
+        "source_revision": row.source_revision,
+        "name": normalized.get("name"),
+        "status": row.status.value,
+        "acquired_at": row.acquired_at,
+        "reviewed_at": row.reviewed_at,
+        "reviewed_by": row.reviewed_by,
+        "recipe_id": row.recipe_id,
+    }
+
+
+@router.get("/recipe-imports", response_model=RecipeImportListResponse)
+def list_recipe_imports(
+    import_status: RecipeImportStatus | None = Query(default=None, alias="status"),
+    source: str | None = Query(default=None, min_length=1, max_length=100),
+    limit: int = Query(default=50, ge=1, le=100),
+    offset: int = Query(default=0, ge=0),
+    db: Session = Depends(get_db),
+):
+    query = db.query(RecipeImportStaging)
+    if import_status is not None:
+        query = query.filter(RecipeImportStaging.status == import_status)
+    if source is not None:
+        query = query.filter(RecipeImportStaging.source == source)
+    total = query.count()
+    rows = (
+        query.order_by(RecipeImportStaging.acquired_at.desc(), RecipeImportStaging.id)
+        .offset(offset)
+        .limit(limit)
+        .all()
+    )
+    return {
+        "items": [_import_list_item(row) for row in rows],
+        "total": total,
+        "limit": limit,
+        "offset": offset,
+        "has_next": offset + len(rows) < total,
+    }
+
+
+@router.get("/recipe-imports/{import_id}", response_model=RecipeImportDetail)
+def get_recipe_import(import_id: UUID, db: Session = Depends(get_db)):
+    staged = db.get(RecipeImportStaging, import_id)
+    if staged is None:
+        raise HTTPException(status_code=404, detail="Recipe import not found")
+    return staged
+
+
+@router.post("/recipe-imports/{import_id}/approve", response_model=RecipeImportDetail)
+def approve_staged_recipe(
+    import_id: UUID,
+    response: Response,
+    db: Session = Depends(get_db),
+    reviewer: str = Depends(require_admin),
+):
+    try:
+        staged, created = approve_recipe_import(db, import_id, reviewer)
+    except RecipeImportNotFoundError as exc:
+        db.rollback()
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except RecipeImportConflictError as exc:
+        db.rollback()
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    except IntegrityError as exc:
+        db.rollback()
+        raise HTTPException(status_code=409, detail="Recipe publication conflicted") from exc
+    response.status_code = status.HTTP_201_CREATED if created else status.HTTP_200_OK
+    return staged
+
+
+@router.post("/recipe-imports/{import_id}/reject", response_model=RecipeImportDetail)
+def reject_staged_recipe(
+    import_id: UUID,
+    payload: RecipeImportRejectRequest,
+    db: Session = Depends(get_db),
+    reviewer: str = Depends(require_admin),
+):
+    try:
+        return reject_recipe_import(db, import_id, payload.reason, reviewer)
+    except RecipeImportNotFoundError as exc:
+        db.rollback()
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except RecipeImportConflictError as exc:
+        db.rollback()
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+
+
 @router.post("/scrape", status_code=202)
 def trigger_scrape(
     background_tasks: BackgroundTasks,
@@ -214,10 +327,9 @@ def trigger_images(
 def trigger_discovery(
     family_profile_id: UUID,
     force: bool = False,
+    limit: int = Query(default=5, ge=1, le=25),
     db: Session = Depends(get_db),
 ):
-    from uuid import UUID as UUIDType
-    
     profile = (
         db.query(FamilyProfile)
         .filter(FamilyProfile.id == family_profile_id)
@@ -232,25 +344,30 @@ def trigger_discovery(
     if not analysis.discovery_queries and not force:
         return {"status": "skipped", "reason": "No discovery queries and force=false"}
 
-    discovery = RecipeDiscoveryService()
-    if not analysis.discovery_queries and force:
-        queries = ["popular recipes"]
-    else:
-        queries = analysis.discovery_queries
-    
-    candidates = discovery.discover(queries)
-    if not candidates:
-        return {"status": "no_candidates"}
+    try:
+        staged = WikibooksImportService(
+            settings.WIKIBOOKS_USER_AGENT
+        ).stage_discovered_pages(
+            db,
+            limit=limit,
+            queries=analysis.discovery_queries or None,
+        )
+        db.commit()
+    except WikibooksImportError as exc:
+        db.rollback()
+        raise HTTPException(status_code=502, detail="Wikibooks staging failed") from exc
 
-    ingestion = RecipeIngestionService()
-    added = ingestion.ingest(
-        db, profile.id, candidates, analysis.to_dict()
+    pending = sum(row.status == RecipeImportStatus.PENDING for row in staged)
+    quarantined = sum(row.status == RecipeImportStatus.QUARANTINED for row in staged)
+    logger.info(
+        "Manual discovery: staged %d Wikibooks candidates for review", len(staged)
     )
-    logger.info("Manual discovery: added %d recipes for family %s", added, profile.id)
     return {
         "status": "success",
-        "candidates_found": len(candidates),
-        "recipes_added": added,
-        "discovery_queries": queries,
+        "candidates_staged": len(staged),
+        "pending": pending,
+        "quarantined": quarantined,
+        "recipes_added": 0,
+        "discovery_queries": analysis.discovery_queries,
         "confidence": analysis.confidence,
-    }
+    }