feat(erindringer): kladde-upload ved stop, afskrift og næste spørgsmål i baggrunden, dagbog pr. dag, afspil spørgsmål + svar; tabeller ruller selv på mobil

Optagelsen sendes op som kladde, når man stopper, så STT kører mens man lytter;
'Send svaret' bekræfter. Næste spørgsmål (Claude + TTS) forberedes i baggrunden
efter hvert svar og hentes på 0 s. Dagbogens samtale er datoen (vælg dag).
'Spørgsmål og svar' afspiller oplæsningen og svaret efter hinanden; /erindringer/alle
viser alt dag for dag. Baggrundsjobs holdes med stærke referencer og logger fejl.
portal.css: én standardregel, så tabeller på smalle skærme ruller i sig selv og
lange ord brydes, i stedet for at siden får vandret scroll.

Claude-Session: https://claude.ai/code/session_01JmhJG6JnhXfzNiKv8f2vHu

main.py

@@ -8,6 +8,7 @@ from fastapi.templating import Jinja2Templates
 from starlette.middleware.sessions import SessionMiddleware
 
 import asyncio
+import logging
 import re
 import time
 import urllib.parse
@@ -639,7 +640,7 @@ def _erindringer_person(request: Request, noegle: str = "") -> dict:
     raise HTTPException(403, "Kun for familien")
 
 
-def _erindringer_side(request: Request, p: dict, rod: str, noegle: str, saved: str, valgt: str):
+def _erindringer_side(request: Request, p: dict, rod: str, noegle: str, saved: str, valgt: str, alle: bool = False):
     user = current_user(request)
     pr = []
     for slug in p.get("projekter") or []:
@@ -647,12 +648,15 @@ def _erindringer_side(request: Request, p: dict, rod: str, noegle: str, saved: s
         if x:
             pr.append({**x, "antal": len(erindringer.klip_for(p["pid"], slug))})
     titler = {x["slug"]: x["titel"] for x in pr}
-    seneste = list(reversed(erindringer.klip_for(p["pid"])))[:20]
+    alle_klip = list(reversed(erindringer.klip_for(p["pid"])))
+    seneste = alle_klip if alle else alle_klip[:20]
     for k in seneste:
         k["projekt_titel"] = titler.get(k.get("projekt"), k.get("projekt"))
+        k["dag"] = (k.get("tid") or "")[:10]
     return templates.TemplateResponse(request, "erindringer.html", {
         "request": request, "user": user, "is_admin": is_admin(user), "navn": p.get("navn") or "",
         "noegle": noegle, "rod": rod, "api": "/erindringer/api", "projekter": pr, "klip_seneste": seneste,
+        "alle": alle, "antal_alle": len(alle_klip), "idag": time.strftime("%Y-%m-%d"),
         "saved": saved, "valgt": valgt if valgt in titler else ""})
 
 
@@ -662,6 +666,20 @@ async def erindringer_side(request: Request, saved: str = "", valgt: str = ""):
     return _erindringer_side(request, p, "/erindringer", "", saved, valgt)
 
 
+@app.get("/erindringer/alle", response_class=HTMLResponse)
+async def erindringer_alle(request: Request):
+    p = _erindringer_person(request)
+    return _erindringer_side(request, p, "/erindringer", "", "", "", alle=True)
+
+
+@app.get("/erindringer/g/{key}/alle/", response_class=HTMLResponse)
+async def erindringer_gaest_alle(request: Request, key: str):
+    p = _erindringer_person(request, key)
+    r = _erindringer_side(request, p, f"/erindringer/g/{key}", key, "", "", alle=True)
+    r.headers["X-Robots-Tag"] = "noindex, nofollow, noarchive"
+    return r
+
+
 @app.get("/erindringer/g/{key}/", response_class=HTMLResponse)
 async def erindringer_gaest(request: Request, key: str, saved: str = "", valgt: str = ""):
     p = _erindringer_person(request, key)
@@ -725,15 +743,59 @@ async def erindringer_naeste(request: Request):
         return _fejl(403, "Det emne er ikke åbent for dig.")
     pr = erindringer.projekt(slug)
     samtale = str(data.get("samtale") or "")
-    if not re.match(r"^[0-9]{8}-[a-f0-9]{6}$", samtale):
+    if slug == "dagbog":
+        samtale = erindringer.dagbog_samtale(str(data.get("dato") or ""))
+    elif not erindringer.SAMTALE.match(samtale):
         samtale = erindringer.ny_samtale()
     sprunget = [str(x)[:400] for x in (data.get("sprunget") or []) if isinstance(x, str)][:50]
+    q = await _naeste_med_lyd(p, pr, samtale, sprunget)
+    return {"samtale": samtale, "spoergsmaal": q["spoergsmaal"], "talt": q["talt"], "afslut": q["afslut"],
+            "kilde": q["kilde"], "lyd_url": f"/erindringer/tts/{q['lyd_sha']}.mp3" if q.get("lyd_sha") else None,
+            "lyd_sha": q.get("lyd_sha") or "", "nr": len(erindringer.klip_for(p["pid"], slug, samtale)) + 1}
+
+
+async def _naeste_med_lyd(p: dict, pr: dict, samtale: str, sprunget: list[str]) -> dict:
+    """Næste spørgsmål med oplæsning: tag det forudberegnede, hvis det bygger på det seneste svar;
+    ellers vent (kort) på at det seneste svar er skrevet af, og regn det ud nu."""
+    seneste = erindringer.klip_for(p["pid"], pr["slug"], samtale)
+    basis = seneste[-1]["id"] if seneste else ""
+    if not sprunget:
+        v = erindringer.hent_forberedt(p["pid"], samtale, basis)
+        if v and v.get("q"):
+            return {**v["q"], "lyd_sha": v.get("lyd_sha") or ""}
+    if seneste and seneste[-1].get("status") == "transskriberes":
+        for _ in range(25):                      # op til ca. 25 s: teksten er på vej fra STT
+            await asyncio.sleep(1)
+            k = erindringer.klip(p["pid"], basis)
+            if not k or k.get("status") != "transskriberes":
+                break
     q = await erindringer.naeste_spoergsmaal(p, pr, samtale, sprunget)
     lyd = await asyncio.to_thread(erindringer.tts_sti, q["talt"])
-    return {"samtale": samtale, "spoergsmaal": q["spoergsmaal"], "talt": q["talt"], "afslut": q["afslut"],
-            "kilde": q["kilde"], "lyd_url": f"/erindringer/tts/{lyd.stem}.mp3" if lyd else None,
-            "lyd_sha": lyd.stem if lyd else "", "tilbage": len([s for s in (pr.get("start") or []) if s not in sprunget]),
-            "nr": len(erindringer.klip_for(p["pid"], slug, samtale)) + 1}
+    return {**q, "lyd_sha": lyd.stem if lyd else ""}
+
+
+_baggrund: set = set()   # stærke referencer: en create_task uden reference kan blive samlet op af GC midtvejs
+
+
+def _i_baggrunden(coro) -> None:
+    t = asyncio.create_task(coro)
+    _baggrund.add(t)
+    t.add_done_callback(_baggrund.discard)
+
+
+async def _efter_svar(p: dict, pr: dict, samtale: str, kid: str) -> None:
+    """Baggrundsarbejde efter et svar: transskribér, og forbered næste spørgsmål (tekst + lyd),
+    så det ligger klar, når personen trykker 'Næste spørgsmål'."""
+    try:
+        await asyncio.to_thread(erindringer.transskriber_klip, p["pid"], kid)
+        k = erindringer.klip(p["pid"], kid)
+        if not k or k.get("kladde"):
+            return                               # ikke sendt endnu (eller slettet): intet at forberede
+        q = await erindringer.naeste_spoergsmaal(p, pr, samtale, [])
+        lyd = await asyncio.to_thread(erindringer.tts_sti, q["talt"])
+        erindringer.gem_forberedt(p["pid"], samtale, kid, q, lyd.stem if lyd else "")
+    except Exception:                            # baggrund: må aldrig vælte appen; næste kald regner selv
+        logging.getLogger("portal.erindringer").exception("baggrundsjob efter svar %s fejlede", kid)
 
 
 @app.post("/erindringer/api/svar")
@@ -744,8 +806,8 @@ async def erindringer_svar(request: Request):
     if not erindringer.maa(p, slug):
         return _fejl(403, "Det emne er ikke åbent for dig.")
     samtale = str(form.get("samtale") or "")
-    if not re.match(r"^[0-9]{8}-[a-f0-9]{6}$", samtale):
-        samtale = erindringer.ny_samtale()
+    if not erindringer.SAMTALE.match(samtale):
+        samtale = erindringer.dagbog_samtale() if slug == "dagbog" else erindringer.ny_samtale()
     lyd = form.get("lyd")
     data, filnavn = None, ""
     if lyd is not None and hasattr(lyd, "read"):
@@ -754,13 +816,59 @@ async def erindringer_svar(request: Request):
         if not data:
             data = None
     tekst = str(form.get("tekst") or "")
+    kladde = str(form.get("kladde") or "") == "1"
     try:
         meta = await asyncio.to_thread(erindringer.gem_svar, p["pid"], slug, samtale, str(form.get("spoergsmaal") or ""),
                                        data, filnavn, tekst or None, str(form.get("spoergsmaal_talt") or ""),
-                                       str(form.get("lyd_sha") or ""), str(form.get("kilde") or ""))
+                                       str(form.get("lyd_sha") or ""), str(form.get("kilde") or ""), kladde)
     except ValueError as e:
         return _fejl(400, str(e))
-    return {"id": meta["id"], "tekst": meta["tekst"], "varighed": meta["varighed"], "samtale": samtale}
+    _i_baggrunden(_efter_svar(p, erindringer.projekt(slug), samtale, meta["id"]))
+    return {"id": meta["id"], "tekst": meta["tekst"], "status": meta["status"], "varighed": meta["varighed"],
+            "samtale": samtale, "kladde": kladde}
+
+
+@app.post("/erindringer/api/status")
+async def erindringer_status(request: Request):
+    try:
+        data = await request.json()
+    except ValueError:
+        return _fejl(400, "Ugyldigt kald.")
+    p = _erindringer_person(request, str(data.get("noegle") or ""))
+    k = erindringer.klip(p["pid"], str(data.get("id") or ""))
+    if not k:
+        return _fejl(404, "Svaret findes ikke.")
+    return {"id": k["id"], "tekst": k.get("tekst", ""), "status": k.get("status", "klar"), "varighed": k.get("varighed", 0)}
+
+
+@app.post("/erindringer/api/bekraeft")
+async def erindringer_bekraeft(request: Request):
+    try:
+        data = await request.json()
+    except ValueError:
+        return _fejl(400, "Ugyldigt kald.")
+    p = _erindringer_person(request, str(data.get("noegle") or ""))
+    k = erindringer.bekraeft(p["pid"], str(data.get("id") or ""))
+    if not k:
+        return _fejl(404, "Svaret findes ikke.")
+    if k.get("status") != "transskriberes":
+        # Teksten er allerede klar: forbered næste spørgsmål nu (ellers gør baggrundsjobbet det)
+        pr = erindringer.projekt(k.get("projekt") or "")
+        if pr:
+            _i_baggrunden(_efter_svar(p, pr, k.get("samtale") or "", k["id"]))
+    return {"id": k["id"], "tekst": k.get("tekst", ""), "status": k.get("status", "klar"), "varighed": k.get("varighed", 0)}
+
+
+@app.post("/erindringer/api/slet")
+async def erindringer_slet(request: Request):
+    try:
+        data = await request.json()
+    except ValueError:
+        return _fejl(400, "Ugyldigt kald.")
+    p = _erindringer_person(request, str(data.get("noegle") or ""))
+    if not erindringer.slet_klip(p["pid"], str(data.get("id") or "")):
+        return _fejl(404, "Svaret findes ikke.")
+    return {"ok": True}
 
 
 @app.post("/erindringer/api/ret")