all

backend/api/admin_api.py

@@ -110,6 +110,19 @@ async def admin_actions(request: Request):
     })
 
 
+@router.get("/admin/settings", response_class=HTMLResponse)
+async def admin_settings(request: Request):
+    redirect = _require_auth(request)
+    if redirect:
+        return redirect
+    cfg = request.app.state.config
+    return _templates.TemplateResponse("admin/settings.html", {
+        "request": request,
+        "config": cfg,
+        "button": cfg.button,
+    })
+
+
 @router.get("/admin/print", response_class=HTMLResponse)
 async def admin_print(request: Request):
     redirect = _require_auth(request)

backend/api/admin_gallery_api.py

@@ -1,98 +1,15 @@
 """API galerie admin — impression et suppression de photos."""
 
 import logging
+from pathlib import Path
 from fastapi import APIRouter, Request, Query
-from fastapi.responses import JSONResponse, RedirectResponse
+from fastapi.responses import JSONResponse
 
 logger = logging.getLogger(__name__)
 router = APIRouter()
 
 
-@router.get("/admin/api/gallery/photos")
-async def admin_get_photos(
-    request: Request,
-    page: int = Query(default=1, ge=1),
-    limit: int = Query(default=24, ge=1, le=100),
-):
-    """Liste des photos pour la galerie admin."""
-    if not request.session.get("authenticated"):
-        return JSONResponse({"error": "Non authentifié"}, status_code=401)
-
-    pb = request.app.state.photobooth_service
-    all_photos = await pb.get_media_collection(limit=500)
-    photos = [p for p in all_photos if _is_image(p)]
-
-    total = len(photos)
-    start = (page - 1) * limit
-    page_photos = photos[start:start + limit]
-
-    for p in page_photos:
-        pid = _get_id(p)
-        p["full_url"] = pb.media_url(pid)
-        p["thumb_url"] = pb.thumbnail_url(pid)
-
-    return {"photos": page_photos, "total": total, "page": page,
-            "pages": max(1, (total + limit - 1) // limit)}
-
-
-@router.post("/admin/api/gallery/print/{photo_id}")
-async def admin_print_photo(
-    request: Request,
-    photo_id: str,
-    copies: int = Query(default=1, ge=1, le=3),
-):
-    """Impression directe depuis la galerie admin."""
-    if not request.session.get("authenticated"):
-        return JSONResponse({"error": "Non authentifié"}, status_code=401)
-
-    pb = request.app.state.photobooth_service
-    printer_svc = request.app.state.printer_service
-    led = request.app.state.led_service
-    ws = request.app.state.ws_manager
-
-    # Reconstruit le chemin du fichier depuis l'ID
-    from pathlib import Path
-    import re
-    cfg = request.app.state.config
-
-    # photobooth-app identifiant → chemin fichier
-    media_dir = cfg.photobooth.media_dir
-    # Cherche le fichier correspondant
-    filename = _find_file(media_dir, photo_id)
-    if not filename:
-        return JSONResponse({"error": f"Fichier introuvable pour {photo_id}"}, status_code=404)
-
-    thumb_url = pb.thumbnail_url(photo_id)
-    entry = await printer_svc.add_request(str(filename), thumb_url, copies)
-
-    if cfg.print.mode == "direct":
-        led.play("printing")
-        result = await printer_svc.execute_print(entry["id"], copies)
-        await ws.broadcast({"type": "print_result", "result": result})
-        if result["success"]:
-            led.play("finished")
-        else:
-            led.play("error")
-        return result
-
-    await ws.broadcast({"type": "print_request", "entry": entry})
-    return {"ok": True, "entry": entry, "mode": cfg.print.mode}
-
-
-@router.delete("/admin/api/gallery/{photo_id}")
-async def admin_delete_photo(request: Request, photo_id: str):
-    """Supprime une photo via l'API photobooth-app."""
-    if not request.session.get("authenticated"):
-        return JSONResponse({"error": "Non authentifié"}, status_code=401)
-
-    pb = request.app.state.photobooth_service
-    ws = request.app.state.ws_manager
-
-    ok = await pb.delete_media(photo_id)
-    if ok:
-        await ws.broadcast({"type": "photo_deleted", "photo_id": photo_id})
-    return {"ok": ok, "photo_id": photo_id}
-
+# ── Helpers ───────────────────────────────────────────────────────────────────
 
 def _is_image(item: dict) -> bool:
     t = item.get("type", item.get("mediaitem_type", "image"))
@@ -103,20 +20,179 @@ def _get_id(item: dict) -> str:
     return str(item.get("id", item.get("filename", item.get("uid", ""))))
 
 
-def _find_file(media_dir: str, photo_id: str):
+def _find_file(media_dir: str, photo_id: str) -> Path | None:
     """Cherche un fichier image correspondant à l'identifiant dans le répertoire media."""
-    from pathlib import Path
     base = Path(media_dir)
     if not base.exists():
         return None
-
-    # L'ID peut être le stem du filename
     for ext in (".jpg", ".jpeg", ".png"):
         f = base / f"{photo_id}{ext}"
         if f.exists():
             return f
-        # Cherche dans les sous-dossiers
         matches = list(base.rglob(f"{photo_id}{ext}"))
         if matches:
             return matches[0]
     return None
+
+
+def _require_auth(request: Request):
+    return request.session.get("authenticated") is True
+
+
+# ── Photos ────────────────────────────────────────────────────────────────────
+
+@router.get("/admin/api/gallery/photos")
+async def admin_get_photos(
+    request: Request,
+    page: int = Query(default=1, ge=1),
+    limit: int = Query(default=24, ge=1, le=100),
+):
+    """Liste des photos pour la galerie admin, annotées avec leurs demandes d'impression."""
+    if not _require_auth(request):
+        return JSONResponse({"error": "Non authentifié"}, status_code=401)
+
+    pb = request.app.state.photobooth_service
+    printer_svc = request.app.state.printer_service
+
+    # Récupère toutes les photos
+    all_photos = await pb.get_media_collection(limit=500)
+    photos = [p for p in all_photos if _is_image(p)]
+
+    total = len(photos)
+    start = (page - 1) * limit
+    page_photos = photos[start:start + limit]
+
+    # Construit les URLs
+    for p in page_photos:
+        pid = _get_id(p)
+        p["photo_id"] = pid
+        p["full_url"] = pb.media_url(pid)
+        p["thumb_url"] = pb.thumbnail_url(pid)
+
+    # Croise avec la file d'impression en attente (une seule requête SQLite)
+    try:
+        pending_map = await printer_svc.get_pending_by_photo_id()
+        for p in page_photos:
+            pid = p.get("photo_id", "")
+            requests = pending_map.get(pid, [])
+            p["print_requests"] = requests
+            p["print_pending"] = len([r for r in requests if r["status"] == "pending"])
+            p["print_printing"] = len([r for r in requests if r["status"] == "printing"])
+    except Exception as e:
+        logger.warning("Impossible de croiser avec print_queue: %s", e)
+        for p in page_photos:
+            p["print_requests"] = []
+            p["print_pending"] = 0
+            p["print_printing"] = 0
+
+    return {
+        "photos": page_photos,
+        "total": total,
+        "page": page,
+        "pages": max(1, (total + limit - 1) // limit),
+    }
+
+
+# ── Demandes d'impression ─────────────────────────────────────────────────────
+
+@router.post("/admin/api/gallery/print/{photo_id}")
+async def admin_print_photo(
+    request: Request,
+    photo_id: str,
+    copies: int = Query(default=1, ge=1, le=3),
+    immediate: bool = Query(default=False, description="True = imprimer maintenant sans passer par la file"),
+):
+    """Ajoute une demande d'impression (ou imprime immédiatement si immediate=true).
+
+    En mode 'validation', la demande est mise en file — l'admin valide via /admin/print.
+    En mode 'direct' ou si immediate=true, l'impression est lancée tout de suite.
+    """
+    if not _require_auth(request):
+        return JSONResponse({"error": "Non authentifié"}, status_code=401)
+
+    pb = request.app.state.photobooth_service
+    printer_svc = request.app.state.printer_service
+    led = request.app.state.led_service
+    ws = request.app.state.ws_manager
+    cfg = request.app.state.config
+
+    filename = _find_file(cfg.photobooth.media_dir, photo_id)
+    if not filename:
+        return JSONResponse({"error": f"Fichier introuvable pour {photo_id}"}, status_code=404)
+
+    thumb_url = pb.thumbnail_url(photo_id)
+    entry = await printer_svc.add_request(str(filename), thumb_url, copies)
+
+    should_print_now = (cfg.print.mode == "direct") or immediate
+
+    if should_print_now:
+        led.play("printing")
+        result = await printer_svc.execute_print(entry["id"], copies)
+        await ws.broadcast({"type": "print_result", "result": result, "photo_id": photo_id})
+        led.play("finished" if result["success"] else "error")
+        return {**result, "entry_id": entry["id"], "photo_id": photo_id}
+
+    # Mode validation : juste en file
+    await ws.broadcast({
+        "type": "print_request",
+        "entry": entry,
+        "photo_id": photo_id,
+    })
+    return {
+        "ok": True,
+        "queued": True,
+        "entry_id": entry["id"],
+        "photo_id": photo_id,
+        "mode": cfg.print.mode,
+    }
+
+
+@router.delete("/admin/api/gallery/print/{photo_id}")
+async def admin_cancel_print_requests(request: Request, photo_id: str):
+    """Annule toutes les demandes d'impression en attente pour une photo."""
+    if not _require_auth(request):
+        return JSONResponse({"error": "Non authentifié"}, status_code=401)
+
+    printer_svc = request.app.state.printer_service
+    ws = request.app.state.ws_manager
+
+    count = await printer_svc.cancel_by_photo_id(photo_id)
+    if count:
+        await ws.broadcast({"type": "print_cancelled_for_photo", "photo_id": photo_id, "count": count})
+    return {"ok": True, "photo_id": photo_id, "cancelled": count}
+
+
+@router.get("/admin/api/gallery/print-status")
+async def admin_print_status(request: Request):
+    """Retourne le dict {photo_id_stem: pending_count} pour toute la file.
+
+    Utilisé par la galerie pour mettre à jour les badges sans recharger les photos.
+    """
+    if not _require_auth(request):
+        return JSONResponse({"error": "Non authentifié"}, status_code=401)
+
+    printer_svc = request.app.state.printer_service
+    pending_map = await printer_svc.get_pending_by_photo_id()
+
+    # Format compact : {stem: count} pour minimiser la taille de la réponse
+    return {
+        stem: len(entries)
+        for stem, entries in pending_map.items()
+    }
+
+
+# ── Suppression ───────────────────────────────────────────────────────────────
+
+@router.delete("/admin/api/gallery/{photo_id}")
+async def admin_delete_photo(request: Request, photo_id: str):
+    """Supprime une photo via l'API photobooth-app."""
+    if not _require_auth(request):
+        return JSONResponse({"error": "Non authentifié"}, status_code=401)
+
+    pb = request.app.state.photobooth_service
+    ws = request.app.state.ws_manager
+
+    ok = await pb.delete_media(photo_id)
+    if ok:
+        await ws.broadcast({"type": "photo_deleted", "photo_id": photo_id})
+    return {"ok": ok, "photo_id": photo_id}

backend/api/event_api.py

@@ -0,0 +1,99 @@
+"""API de gestion des événements et statistiques."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+
+from fastapi import APIRouter, Request
+from pydantic import BaseModel
+
+from backend.services.event_service import slugify
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+class EventUpdate(BaseModel):
+    name: str
+    new_event: bool = False  # True = archive l'ancien et crée un nouveau
+
+
+@router.get("/event")
+async def get_current_event(request: Request):
+    """Retourne l'événement en cours avec ses statistiques."""
+    cfg = request.app.state.config
+    event_svc = request.app.state.event_service
+
+    ev = cfg.event
+    stats = await event_svc.get_stats(ev.slug)
+
+    return {
+        "name": ev.name,
+        "slug": ev.slug,
+        "started_at": ev.started_at,
+        "started_at_iso": (
+            datetime.fromtimestamp(ev.started_at).isoformat()
+            if ev.started_at
+            else None
+        ),
+        "stats": stats,
+    }
+
+
+@router.put("/event")
+async def update_event(request: Request, payload: EventUpdate):
+    """Met à jour l'événement en cours.
+
+    Si new_event=True : archive le précédent et démarre un nouvel événement
+                        (les stats repartent de zéro).
+    Si new_event=False : renomme l'événement en cours (même slug ou nouveau slug,
+                         les stats existantes restent sous l'ancien slug).
+    """
+    cfg = request.app.state.config
+    config_svc = request.app.state.config_service
+    event_svc = request.app.state.event_service
+
+    new_slug = slugify(payload.name)
+    now = datetime.now().timestamp()
+
+    old_slug = cfg.event.slug
+
+    if payload.new_event and old_slug and old_slug != new_slug:
+        # Archive l'ancien événement
+        await event_svc.archive_event(old_slug)
+
+    # Crée ou met à jour la ligne dans la DB
+    await event_svc.ensure_event(new_slug, payload.name, now if payload.new_event else cfg.event.started_at or now)
+
+    # Persiste dans settings.yaml
+    started = now if payload.new_event or not cfg.event.started_at else cfg.event.started_at
+    config_svc.save_event_config(payload.name, new_slug, started)
+
+    stats = await event_svc.get_stats(new_slug)
+    return {
+        "ok": True,
+        "name": payload.name,
+        "slug": new_slug,
+        "started_at": started,
+        "new_event": payload.new_event,
+        "stats": stats,
+    }
+
+
+@router.get("/event/history")
+async def get_event_history(request: Request):
+    """Retourne tous les événements passés avec leurs statistiques."""
+    event_svc = request.app.state.event_service
+    history = await event_svc.get_history()
+
+    # Ajoute les dates ISO pour l'affichage
+    for ev in history:
+        if ev.get("started_at"):
+            ev["started_at_iso"] = datetime.fromtimestamp(ev["started_at"]).strftime("%d/%m/%Y %H:%M")
+        if ev.get("ended_at"):
+            ev["ended_at_iso"] = datetime.fromtimestamp(ev["ended_at"]).strftime("%d/%m/%Y %H:%M")
+        else:
+            ev["ended_at_iso"] = None
+
+    return {"events": history}

backend/api/gallery.py

@@ -1,12 +1,15 @@
-"""Galerie publique — accessible sans authentification."""
+"""Galerie publique -- accessible sans authentification."""
 
+import asyncio
 import logging
-
-from fastapi import APIRouter, Request, Query
-from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
-from fastapi.templating import Jinja2Templates
+from datetime import datetime
 from pathlib import Path
 
+import httpx
+from fastapi import APIRouter, Request, Query
+from fastapi.responses import HTMLResponse, RedirectResponse, Response
+from fastapi.templating import Jinja2Templates
+
 logger = logging.getLogger(__name__)
 router = APIRouter()
 
@@ -15,7 +18,6 @@ _templates = Jinja2Templates(directory=Path(__file__).parent.parent.parent / "fr
 
 @router.get("/", response_class=HTMLResponse)
 async def index(request: Request):
-    """Page d'accueil → redirige vers la galerie publique."""
     return RedirectResponse(url="/gallery")
 
 
@@ -23,7 +25,7 @@ async def index(request: Request):
 async def gallery_page(request: Request):
     cfg = request.app.state.config
     if not cfg.gallery.public_enabled:
-        return HTMLResponse("<h1>Galerie désactivée</h1>", status_code=403)
+        return HTMLResponse("<h1>Galerie desactivee</h1>", status_code=403)
     return _templates.TemplateResponse("public/gallery.html", {"request": request, "config": cfg})
 
 
@@ -33,13 +35,9 @@ async def api_gallery_photos(
     page: int = Query(default=1, ge=1),
     limit: int = Query(default=24, ge=1, le=100),
 ):
-    """Liste des photos depuis photobooth-app (paginée)."""
     pb = request.app.state.photobooth_service
-    cfg = request.app.state.config
 
     all_photos = await pb.get_media_collection(limit=500)
-
-    # Filtre sur les images uniquement
     photos = [p for p in all_photos if _is_image(p)]
 
     total = len(photos)
@@ -47,7 +45,6 @@ async def api_gallery_photos(
     end = start + limit
     page_photos = photos[start:end]
 
-    # Enrichit avec les URLs
     for p in page_photos:
         pid = _get_id(p)
         p["full_url"] = pb.media_url(pid)
@@ -64,9 +61,37 @@ async def api_gallery_photos(
 
 @router.get("/api/gallery/download/{photo_id}")
 async def download_photo(request: Request, photo_id: str):
-    """Redirige vers le fichier full-res sur photobooth-app."""
+    """Proxy la photo full-res avec un nom de fichier lie a l'evenement en cours."""
     pb = request.app.state.photobooth_service
-    return RedirectResponse(url=pb.media_url(photo_id))
+    cfg = request.app.state.config
+    event_svc = getattr(request.app.state, "event_service", None)
+
+    img_url = pb.media_url(photo_id)
+    slug = cfg.event.slug or "photomaton"
+    date_str = datetime.now().strftime("%Y-%m-%d")
+    filename = f"{slug}_By_LSDW_{date_str}.jpg"
+
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            r = await client.get(img_url)
+            r.raise_for_status()
+
+        if event_svc:
+            asyncio.create_task(event_svc.increment(slug, "downloads"))
+
+        content_type = r.headers.get("content-type", "image/jpeg")
+        return Response(
+            content=r.content,
+            media_type=content_type,
+            headers={
+                "Content-Disposition": f'attachment; filename="{filename}"',
+                "Content-Length": str(len(r.content)),
+                "Cache-Control": "no-cache",
+            },
+        )
+    except Exception as e:
+        logger.warning("Download proxy echoue (%s), fallback redirect: %s", photo_id, e)
+        return RedirectResponse(url=img_url)
 
 
 def _is_image(item: dict) -> bool:

backend/api/leds_api.py

@@ -49,3 +49,52 @@ async def leds_off(request: Request):
     led = request.app.state.led_service
     led.play("off")
     return {"ok": True}
+
+
+@router.get("/leds/effects")
+async def get_effects(request: Request):
+    """Retourne la configuration de tous les effets LED."""
+    cfg = request.app.state.config.leds
+    return {
+        name: {
+            "color": effect.get("color", [0, 0, 0]),
+            "flash_duration": effect.get("flash_duration", 0.1),
+            "flashes": effect.get("flashes", 2),
+            "speed": effect.get("speed", 0.05),
+            "duration": effect.get("duration", 2.0),
+        }
+        for name, effect in cfg.effects.items()
+    }
+
+
+@router.put("/leds/effect/{effect_name}")
+async def update_effect(
+    request: Request,
+    effect_name: str,
+    r: int = Query(default=None, ge=0, le=255),
+    g: int = Query(default=None, ge=0, le=255),
+    b: int = Query(default=None, ge=0, le=255),
+    flash_duration: float = Query(default=None, ge=0.05, le=2.0),
+    flashes: int = Query(default=None, ge=1, le=5),
+    save: bool = Query(default=True),
+):
+    """Met a jour la configuration d'un effet LED (couleur, timings).
+    
+    Exemple : PUT /api/leds/effect/capture?r=255&g=200&b=80&flash_duration=0.3&flashes=2
+    """
+    cfg = request.app.state.config.leds
+    config_svc = request.app.state.config_service
+
+    effect_raw = cfg.effects.setdefault(effect_name, {})
+
+    if r is not None and g is not None and b is not None:
+        effect_raw["color"] = [r, g, b]
+    if flash_duration is not None:
+        effect_raw["flash_duration"] = flash_duration
+    if flashes is not None:
+        effect_raw["flashes"] = flashes
+
+    if save:
+        config_svc.save_led_effect(effect_name, effect_raw)
+
+    return {"ok": True, "effect": effect_name, "config": effect_raw}

backend/api/print_api.py

@@ -1,5 +1,6 @@
 """API gestion de la file d'attente d'impression."""
 
+import asyncio
 import logging
 from pathlib import Path
 
@@ -33,6 +34,12 @@ async def print_request(
 
     await ws.broadcast({"type": "print_request", "entry": entry})
 
+    # Compteur statistiques événement
+    event_svc = getattr(request.app.state, "event_service", None)
+    if event_svc:
+        slug = request.app.state.config.event.slug
+        asyncio.create_task(event_svc.increment(slug, "print_requests"))
+
     # Feedback LED si impression directe
     if request.app.state.config.print.mode == "direct":
         led.play("printing")
@@ -71,6 +78,10 @@ async def execute_print(
 
     if result["success"]:
         led.play("finished")
+        event_svc = getattr(request.app.state, "event_service", None)
+        if event_svc:
+            slug = request.app.state.config.event.slug
+            asyncio.create_task(event_svc.increment(slug, "prints_done"))
     else:
         led.play("error")
 
@@ -112,3 +123,40 @@ async def set_print_mode(request: Request, mode: str = Query(...)):
     config_svc.save_print_mode(mode)
     request.app.state.config.print.mode = mode
     return {"ok": True, "mode": mode}
+
+
+# ── Gestion avancée des imprimantes CUPS ──────────────────────────────────────
+
+@router.post("/print/printers/{printer_name}/enable")
+async def printer_enable(request: Request, printer_name: str):
+    """Active une imprimante CUPS (cupsenable + cupsaccept)."""
+    ok = await request.app.state.printer_service.enable_printer(printer_name)
+    return {"ok": ok, "printer": printer_name, "action": "enable"}
+
+
+@router.post("/print/printers/{printer_name}/disable")
+async def printer_disable(request: Request, printer_name: str):
+    """Désactive une imprimante CUPS (cupsdisable)."""
+    ok = await request.app.state.printer_service.disable_printer(printer_name)
+    return {"ok": ok, "printer": printer_name, "action": "disable"}
+
+
+@router.post("/print/printers/{printer_name}/reject")
+async def printer_reject(request: Request, printer_name: str):
+    """Refuse les nouveaux jobs sans stopper l'impression en cours."""
+    ok = await request.app.state.printer_service.reject_jobs(printer_name)
+    return {"ok": ok, "printer": printer_name, "action": "reject"}
+
+
+@router.get("/print/printers/{printer_name}/jobs")
+async def printer_jobs(request: Request, printer_name: str):
+    """Liste les jobs CUPS en cours pour une imprimante."""
+    jobs = await request.app.state.printer_service.get_cups_jobs(printer_name)
+    return {"printer": printer_name, "jobs": jobs}
+
+
+@router.delete("/print/printers/jobs/{job_id}")
+async def cancel_one_job(request: Request, job_id: str):
+    """Annule un job CUPS précis par son ID."""
+    ok = await request.app.state.printer_service.cancel_cups_job(job_id)
+    return {"ok": ok, "job_id": job_id}

backend/api/system_api.py

@@ -1,8 +1,10 @@
 """API de surveillance des ressources système."""
 
 import logging
-from fastapi import APIRouter, Request
+from typing import Optional
+from fastapi import APIRouter, Request, Body
 from fastapi.responses import JSONResponse
+from pydantic import BaseModel
 
 logger = logging.getLogger(__name__)
 router = APIRouter()
@@ -50,3 +52,111 @@ async def control_relay(request: Request, state: str = "on"):
     else:
         btn.relay_off()
     return {"ok": True, "relay": state}
+
+
+@router.get("/system/ui/delete-button")
+async def get_delete_button(request: Request):
+    """Retourne l'état actuel du bouton Supprimer de photobooth-app."""
+    visible = request.app.state.config.photobooth.show_delete_button
+    return {"visible": visible}
+
+
+@router.post("/system/ui/delete-button")
+async def set_delete_button(request: Request, visible: bool):
+    """Active ou désactive le bouton Supprimer dans l'UI de review photobooth-app.
+
+    Écrit userdata/private.css en temps réel — effectif à la prochaine capture,
+    sans redémarrage.
+    """
+    pb = request.app.state.photobooth_service
+    config_svc = request.app.state.config_service
+
+    ok = await pb.set_delete_button_visible(visible)
+    if ok:
+        config_svc.save_show_delete_button(visible)
+
+    return {"ok": ok, "visible": visible}
+
+
+@router.post("/system/screen/refresh")
+async def screen_refresh(request: Request):
+    """Envoie F5 à l'écran HDMI connecté (Chromium kiosque Wayland/X11)."""
+    import subprocess, os, asyncio
+
+    # Cherche le display Wayland du user pi (UID 1000)
+    # Essaie wayland-0 puis wayland-1
+    xdg_runtime = "/run/user/1000"
+    cmd_wtype   = f"WAYLAND_DISPLAY=wayland-1 XDG_RUNTIME_DIR={xdg_runtime} wtype -k F5"
+    cmd_x11     = f"DISPLAY=:0 XAUTHORITY=/home/pi/.Xauthority xdotool key F5"
+
+    for cmd in [cmd_wtype, cmd_x11]:
+        try:
+            proc = await asyncio.create_subprocess_shell(
+                f"su -s /bin/bash pi -c '{cmd}'",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            _, stderr = await asyncio.wait_for(proc.communicate(), timeout=3)
+            if proc.returncode == 0:
+                logger.info("Screen refresh OK via: %s", cmd.split()[0])
+                return {"ok": True, "method": cmd.split()[0]}
+        except Exception as e:
+            logger.debug("Screen refresh cmd failed (%s): %s", cmd.split()[0], e)
+
+    return JSONResponse({"ok": False, "error": "Aucune méthode disponible (wtype/xdotool)"}, status_code=500)
+
+
+class ButtonConfigUpdate(BaseModel):
+    double_click_ms: Optional[int] = None
+    long_press_ms: Optional[int] = None
+    debounce_ms: Optional[int] = None
+    max_clicks: Optional[int] = None
+    print_enabled: Optional[bool] = None
+    save: bool = False  # True = persiste dans settings.yaml
+
+
+@router.get("/system/button/config")
+async def get_button_config(request: Request):
+    """Retourne la configuration actuelle du bouton (timings)."""
+    cfg = request.app.state.config.button
+    return {
+        "double_click_ms": cfg.double_click_ms,
+        "long_press_ms": cfg.long_press_ms,
+        "debounce_ms": cfg.debounce_ms,
+        "max_clicks": cfg.max_clicks,
+        "print_enabled": cfg.print_enabled,
+    }
+
+
+@router.put("/system/button/config")
+async def update_button_config(request: Request, payload: ButtonConfigUpdate):
+    """Met à jour les timings du bouton (à chaud + optionnellement sauvegardé)."""
+    btn = request.app.state.button_service
+    config_svc = request.app.state.config_service
+
+    update = {k: v for k, v in payload.model_dump(exclude={"save"}).items() if v is not None}
+
+    # Application immédiate (sans redémarrage)
+    btn.update_timings(
+        double_click_ms=payload.double_click_ms,
+        long_press_ms=payload.long_press_ms,
+        debounce_ms=payload.debounce_ms,
+        max_clicks=payload.max_clicks,
+    )
+
+    # Persistance optionnelle
+    if payload.save and update:
+        config_svc.save_button_config(update)
+
+    cfg = request.app.state.config.button
+    return {
+        "ok": True,
+        "saved": payload.save,
+        "current": {
+            "double_click_ms": cfg.double_click_ms,
+            "long_press_ms": cfg.long_press_ms,
+            "debounce_ms": cfg.debounce_ms,
+            "max_clicks": cfg.max_clicks,
+            "print_enabled": cfg.print_enabled,
+        }
+    }

backend/api/webhooks.py

@@ -1,16 +1,6 @@
-"""Webhooks reçus de photobooth-app via plugin_commander.
-
-photobooth-app envoie un GET sur /api/webhook/photobooth?event_key=XXX&mediaitem_type=image
-pour chaque événement de capture.
-
-Événements :
-  counting   → countdown en cours (LEDs remplissage vert)
-  capture    → flash photo (LEDs flash blanc)
-  captured   → photo prise (LEDs violet)
-  finished   → traitement terminé (LEDs bleu → retour idle + relay ON)
-  start/stop → démarrage/arrêt photobooth-app
-"""
+"""Webhooks recus de photobooth-app via plugin_commander."""
 
+import asyncio
 import logging
 
 from fastapi import APIRouter, Request, Query
@@ -18,7 +8,6 @@ from fastapi import APIRouter, Request, Query
 logger = logging.getLogger(__name__)
 router = APIRouter()
 
-# Durée par défaut du countdown (en secondes) — peut être overridé par action
 DEFAULT_COUNTDOWN = 5.0
 
 
@@ -33,30 +22,25 @@ async def photobooth_webhook(
     ws = request.app.state.ws_manager
 
     logger.info("Webhook photobooth: event=%s type=%s", event_key, mediaitem_type)
-
     await ws.broadcast({"type": "photobooth_event", "event": event_key, "media_type": mediaitem_type})
 
     match event_key:
         case "counting":
-            # Countdown en cours — remplissage LED vert
-            # On cherche la durée du countdown dans la config de l'action courante
-            countdown_duration = _get_countdown_duration(request)
-            led.play("countdown", countdown_duration=countdown_duration)
+            led.play("countdown", countdown_duration=DEFAULT_COUNTDOWN)
 
         case "capture":
-            # Flash photo
             led.play("capture")
 
         case "captured":
-            # Photo prise, traitement en cours
             led.play("captured")
 
         case "finished":
-            # Traitement terminé
             led.play("finished")
-            # Réactive le relay après l'animation "finished" (durée ~2s gérée par le service LED)
-            import asyncio
             asyncio.create_task(_delayed_relay_on(btn, 2.5))
+            event_svc = getattr(request.app.state, "event_service", None)
+            if event_svc:
+                slug = request.app.state.config.event.slug
+                asyncio.create_task(event_svc.increment(slug, "photos_taken"))
 
         case "start":
             led.play("idle")
@@ -65,28 +49,12 @@ async def photobooth_webhook(
             led.play("off")
 
         case _:
-            logger.debug("Événement inconnu: %s", event_key)
+            logger.debug("Evenement inconnu: %s", event_key)
 
     return {"ok": True, "event": event_key}
 
 
 async def _delayed_relay_on(btn, delay: float):
-    import asyncio
     await asyncio.sleep(delay)
     if btn:
         btn.relay_on()
-
-
-def _get_countdown_duration(request: Request) -> float:
-    """
-    Essaie de récupérer la durée du countdown depuis la config photobooth-app
-    en lisant le dernier index d'action déclenché par le bouton.
-    Retourne la valeur par défaut si indisponible.
-    """
-    try:
-        btn = request.app.state.button_service
-        # On pourrait stocker le dernier index dans le button_service
-        # Pour l'instant on retourne 5s par défaut
-        return DEFAULT_COUNTDOWN
-    except Exception:
-        return DEFAULT_COUNTDOWN