update

backend/transfer.py

@@ -0,0 +1,135 @@
+"""Ein Thema als JSON exportieren/importieren (make server-push/-pull TOPIC=…).
+
+Ein Thema lebt in ~15 verzahnten Tabellen mit Integer-PKs plus Dateien.
+Export schreibt alle Zeilen (Snapshot-Pfade relativ); Import LÖSCHT das Thema
+auf der Zielseite und fügt mit neuen IDs ein — alle Verweise werden über
+alte→neue Maps nachgezogen. Die Dateien (storage/korpus/, topics/) trägt das
+Makefile per rsync NACH dem Import (topic_loeschen räumt den Korpus-Ordner)."""
+
+import json
+import sys
+from pathlib import Path
+
+import db
+import pipeline
+from config import PROJECT_ROOT
+
+
+def export(topic: str) -> dict:
+    if not db.one("SELECT name FROM topics WHERE name=?", (topic,)):
+        sys.exit(f"unbekanntes Topic: {topic}")
+    q = db.query
+    d = {
+        "topic": topic,
+        "topics": q("SELECT * FROM topics WHERE name=?", (topic,)),
+        "quellen": q("SELECT * FROM quellen WHERE topic=?", (topic,)),
+        "soll": q("SELECT * FROM soll WHERE topic=?", (topic,)),
+        "lernziele": q("SELECT * FROM lernziele WHERE topic=?", (topic,)),
+        "kapitel": q("SELECT * FROM kapitel WHERE topic=?", (topic,)),
+        "bausteine": q("SELECT * FROM bausteine WHERE topic=?", (topic,)),
+        "atome": q("SELECT * FROM atome WHERE topic=?", (topic,)),
+        "anker": q("SELECT k.* FROM anker k JOIN atome a ON a.id=k.atom_id"
+                   " WHERE a.topic=?", (topic,)),
+        "kanten": q("SELECT * FROM kanten WHERE topic=?", (topic,)),
+        "artefakte": q("SELECT ar.* FROM artefakte ar JOIN atome a ON a.id=ar.atom_id"
+                       " WHERE a.topic=?", (topic,)),
+        "leitner": q("SELECT l.* FROM leitner l JOIN artefakte ar ON ar.id=l.artefakt_id"
+                     " JOIN atome a ON a.id=ar.atom_id WHERE a.topic=?", (topic,)),
+        "sections": q("SELECT s.* FROM sections s JOIN bausteine b ON b.id=s.baustein_id"
+                      " WHERE b.topic=?", (topic,)),
+        "runs": q("SELECT * FROM runs WHERE topic=? ORDER BY id", (topic,)),
+        "befunde": q("SELECT b.* FROM befunde b JOIN runs r ON r.id=b.run_id"
+                     " WHERE r.topic=?", (topic,)),
+        "events": q("SELECT e.* FROM events e JOIN runs r ON r.id=e.run_id"
+                    " WHERE r.topic=? ORDER BY e.id", (topic,)),
+    }
+    for zeile in d["quellen"]:  # absolute Pfade überleben den Rechnerwechsel nicht
+        if zeile.get("snapshot"):
+            try:
+                zeile["snapshot"] = str(Path(zeile["snapshot"]).relative_to(PROJECT_ROOT))
+            except ValueError:
+                pass
+    return d
+
+
+def _einfuegen(tabelle: str, zeilen: list[dict], **ersetzungen) -> dict:
+    """Zeilen ohne id einfügen; Verweisfelder via ersetzungen={feld: map} remappen.
+    → Map alte id → neue id."""
+    id_map: dict = {}
+    for z in zeilen:
+        z = dict(z)
+        alt = z.pop("id", None)
+        for feld, m in ersetzungen.items():
+            if z.get(feld) is not None:
+                z[feld] = m.get(z[feld])
+        id_map[alt] = db.insert(tabelle, **z)
+    return id_map
+
+
+def importieren(d: dict) -> None:
+    topic = d["topic"]
+    if db.one("SELECT name FROM topics WHERE name=?", (topic,)):
+        pipeline.topic_loeschen(topic)  # Zielseite wird überschrieben
+
+    t = dict(d["topics"][0])
+    resets_alt = db.uj(t.get("resets") or "{}", {})
+    t["resets"] = db.j({})  # wird nach dem Event-Import übersetzt
+    db.insert("topics", **t)
+
+    q_map = _einfuegen("quellen", [
+        {**z, "snapshot": str(PROJECT_ROOT / z["snapshot"])
+         if z.get("snapshot") and not Path(z["snapshot"]).is_absolute() else z.get("snapshot")}
+        for z in d["quellen"]])
+
+    soll_zeilen = []
+    for z in d["soll"]:
+        z = dict(z)
+        belege = db.uj(z.get("belege") or "[]")
+        for b in belege:
+            if b.get("quelle") in q_map:
+                b["quelle"] = q_map[b["quelle"]]
+        z["belege"] = db.j(belege)
+        soll_zeilen.append(z)
+    s_map = _einfuegen("soll", soll_zeilen)
+
+    z_map = _einfuegen("lernziele", d["lernziele"], soll_id=s_map)
+    k_map = _einfuegen("kapitel", d["kapitel"])
+    b_map = _einfuegen("bausteine", d["bausteine"], ziel_id=z_map, kapitel_id=k_map)
+    # merged_into zeigt auf atome selbst → zweiphasig
+    a_map = _einfuegen("atome", [{**z, "merged_into": None} for z in d["atome"]],
+                       soll_id=s_map, ziel_id=z_map, baustein_id=b_map)
+    for z in d["atome"]:
+        if z.get("merged_into") is not None:
+            db.update("atome", "id", a_map[z["id"]],
+                      merged_into=a_map.get(z["merged_into"]))
+    _einfuegen("anker", d["anker"], atom_id=a_map, quelle_id=q_map)
+    _einfuegen("kanten", d["kanten"], von_atom=a_map, zu_atom=a_map)
+    ar_map = _einfuegen("artefakte", d["artefakte"], atom_id=a_map)
+    for z in d["leitner"]:  # PK ist artefakt_id — kein eigenes id-Feld
+        z = dict(z)
+        z["artefakt_id"] = ar_map.get(z["artefakt_id"])
+        db.insert("leitner", **z)
+    for z in d["sections"]:  # PK ist baustein_id
+        z = dict(z)
+        z["baustein_id"] = b_map.get(z["baustein_id"])
+        db.insert("sections", **z)
+    r_map = _einfuegen("runs", d["runs"])
+    _einfuegen("befunde", d["befunde"], run_id=r_map)
+    e_map = _einfuegen("events", d["events"], run_id=r_map)
+
+    resets_neu = {}
+    for ebene, grenze in resets_alt.items():  # Marker sind Event-ids → übersetzen
+        neue = [neu for alt, neu in e_map.items() if alt is not None and alt <= grenze]
+        resets_neu[ebene] = max(neue, default=0)
+    db.update("topics", "name", topic, resets=db.j(resets_neu))
+    print(f"importiert: {topic} — {len(d['atome'])} Atome, {len(d['sections'])} Sections,"
+          f" {len(d['events'])} Events", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) >= 3 and sys.argv[1] == "export":
+        print(json.dumps(export(sys.argv[2]), ensure_ascii=False))
+    elif len(sys.argv) >= 2 and sys.argv[1] == "import":
+        importieren(json.load(sys.stdin))
+    else:
+        sys.exit("Nutzung: transfer.py export <topic> | transfer.py import < datei.json")