Etiketten-Vorlagen: gespeicherte Exporte mit frei waehlbaren Spalten

Der Etikettenexport konnte genau eine Sache, und zwar unveraenderlich: sechs
feste Spalten ueber Einzelstuecke. Was fehlte, war genau das, was ein Etikett
brauchbar macht - die eigenen Felder. Eine Kabellaenge oder die Kapazitaet einer
Powerbank steht laengst am Artikel, kam aber in keiner CSV vor. Und jede
Zusammenstellung war beim naechsten Mal wieder weg: Kategorien im React-State,
Trennzeichen im localStorage, Spalten hartkodiert.

Jetzt gibt es benannte Vorlagen mit eigener Spaltenwahl und Reihenfolge, fuer
Einzelstuecke, Artikel und Lagerorte. Eine Tabelle nach dem Vorbild von
DashboardLayout: benannt, Nutzlast als JSON-Text. Ohne user_id - eine Vorlage
gehoert allen, nicht einem Konto.

Spaltenschluessel fuer eigene Felder ist die ID, nicht der key: FieldDefinition.key
ist nur JE KATEGORIE eindeutig, zwei Kategorien duerfen beide "kapazitaet" fuehren.

Die CSV entsteht jetzt im Server statt im Browser. Mit waehlbaren Spalten,
eigenen Feldern und drei Bezugsarten gehoert das an eine Stelle - und zwar
dorthin, wo es sich pruefen laesst. Formel-Injektionsschutz, BOM und CRLF sind
aus der Browser-Fassung mitgenommen. Der Grund, aus dem der QR-Inhalt bisher im
Browser entstand ("nur die Oberflaeche kennt die oeffentliche Adresse"), gilt
allein fuer Lagerorte; dafuer reicht sie ihre Herkunft als Parameter durch.

Die beiden alten Abschnitte weichen den Vorlagen. Beim ersten Start entstehen
zwei mitgelieferte, die genau die bisherigen Spalten fuehren - wer nichts
einstellt, bekommt dasselbe Ergebnis wie vorher.

Dazu laesst sich eine P-touch-Datei hinterlegen. Geprueft wird ueber Endung und
ZIP-Inhalt (label.xml), nicht ueber den Content-Type: Fuer .lbx meldet der
Browser meist application/octet-stream. Eine .lbx merkt sich den Pfad zu ihrer
Datenquelle - auf einem fremden Rechner muss die CSV in P-touch einmal neu
verknuepft werden. Das laesst sich von hier aus nicht loesen; die Datei
dabeizuhaben erspart trotzdem das Suchen.

Sicherung auf Version 4: Vorlagen kommen mit, Kategorien als Pfad und eigene
Felder als Label, weil IDs zwischen zwei Instanzen nicht dieselben sind. Die
.lbx als Base64 - das erste Binaerformat in dieser Sicherung, vertretbar bei
wenigen Kilobyte und einer Vorlage, die ohne ihre Datei nur eine halbe waere.

23 neue Tests (343 gesamt), dazu im Browser durchgespielt: Kabel-Kategorie mit
eigenem Feld, Spalte hinzugefuegt, CSV mit "Länge (m)" und dem Wert, .lbx
hoch- und wieder heruntergeladen (Pruefsumme identisch), PNG und Nicht-ZIP
sauber abgelehnt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

backend/app/routers/transfer.py

@@ -6,6 +6,7 @@ werden ergänzt – es wird nie etwas gelöscht oder überschrieben.
 
 from __future__ import annotations
 
+import base64
 import csv
 import io
 import json
@@ -22,11 +23,13 @@ from ..services.dates import MONTH, clean_precision, normalize_best_before
 from ..services import gruppen as gruppen_graph
 from ..services.group_codes import sync as sync_group_code
 from ..services.min_stock import lies_ueberall, schreibe_ueberall
+from ..services.etiketten import FELD_PRAEFIX, konfiguration_lesen
 from ..models import (
     BaseUnit,
     Category,
     CategoryTracking,
     DatePrecision,
+    EtikettenVorlage,
     FieldDefinition,
     Group,
     GroupLocationMinStock,
@@ -166,10 +169,11 @@ def export_backup_json(
     loc_name = {loc.id: loc.name for loc in locations}
 
     data = {
+        # v4: Etiketten-Vorlagen samt hinterlegter P-touch-Datei.
         # v3: Gruppen mit Obergruppen und Gebinde, Mindestbestaende je Ort
-        # (Ort null = „Ueberall") in Basiseinheiten. v2-Sicherungen bleiben
+        # (Ort null = „Ueberall") in Basiseinheiten. Aeltere Sicherungen bleiben
         # lesbar – ihnen fehlen diese Listen einfach.
-        "version": 3,
+        "version": 4,
         "exported_at": datetime.now(timezone.utc).isoformat(),
         "exported_at_local": datetime.now().isoformat(timespec="seconds"),
         "units": [
@@ -262,6 +266,8 @@ def export_backup_json(
             }
         )
 
+    data["etiketten_vorlagen"] = _vorlagen_exportieren(db)
+
     return Response(
         content=json.dumps(data, ensure_ascii=False, indent=2),
         media_type="application/json; charset=utf-8",
@@ -435,6 +441,106 @@ def _get_or_create_location(db: Session, name: str | None) -> Location | None:
     return loc
 
 
+def _vorlagen_exportieren(db: Session) -> list[dict]:
+    """Etiketten-Vorlagen fuer die Sicherung.
+
+    Kategorien als PFAD und eigene Felder als LABEL – IDs sind zwischen zwei
+    Instanzen nicht dieselben, genau wie bei Gruppen und Artikeln.
+
+    Die hinterlegte .lbx kommt als Base64 mit. Das ist das erste Binaerformat in
+    dieser Sicherung; vertretbar, weil eine .lbx wenige Kilobyte gross ist und
+    eine Vorlage ohne ihre Datei nur eine halbe Vorlage waere.
+    """
+    zeilen: list[dict] = []
+    for v in db.query(EtikettenVorlage).order_by(EtikettenVorlage.position).all():
+        konf = konfiguration_lesen(v)
+        spalten: list[str] = []
+        for schluessel in konf["spalten"]:
+            if schluessel.startswith(FELD_PRAEFIX):
+                rest = schluessel[len(FELD_PRAEFIX):]
+                fd = db.get(FieldDefinition, int(rest)) if rest.isdigit() else None
+                # Kategoriepfad mit dazu: Zwei Kategorien duerfen dasselbe Label
+                # fuehren, erst beides zusammen ist eindeutig.
+                spalten.append(
+                    f"{FELD_PRAEFIX}{_category_path(db, db.get(Category, fd.category_id))}"
+                    f"::{fd.label}" if fd else schluessel
+                )
+            else:
+                spalten.append(schluessel)
+        zeilen.append({
+            "name": v.name,
+            "art": v.art,
+            "position": v.position,
+            "spalten": spalten,
+            "kategorien": [
+                _category_path(db, db.get(Category, kid)) for kid in konf["kategorie_ids"]
+            ],
+            "trennzeichen": konf["trennzeichen"],
+            "datei_name": v.datei_name,
+            "datei_base64": base64.b64encode(v.datei).decode() if v.datei else None,
+        })
+    return zeilen
+
+
+def _vorlagen_importieren(db: Session, zeilen: list, errors: list[str]) -> int:
+    """Vorlagen additiv einspielen – Bestehendes bleibt unberuehrt."""
+    angelegt = 0
+    pfad_zu_id: dict[str, int] = {}
+    for cat in db.query(Category).all():
+        pfad_zu_id[_category_path(db, cat)] = cat.id
+
+    for entry in zeilen:
+        try:
+            name = (entry.get("name") or "").strip()
+            if not name or db.query(EtikettenVorlage).filter(
+                EtikettenVorlage.name == name
+            ).first():
+                continue
+
+            spalten: list[str] = []
+            for roh in entry.get("spalten", []):
+                if not str(roh).startswith(FELD_PRAEFIX):
+                    spalten.append(str(roh))
+                    continue
+                rest = str(roh)[len(FELD_PRAEFIX):]
+                pfad, _, label = rest.rpartition("::")
+                kat_id = pfad_zu_id.get(pfad)
+                fd = (
+                    db.query(FieldDefinition)
+                    .filter(
+                        FieldDefinition.category_id == kat_id,
+                        FieldDefinition.label == label,
+                    ).first()
+                    if kat_id else None
+                )
+                # Gibt es das Feld hier nicht, faellt die Spalte weg statt die
+                # ganze Vorlage scheitern zu lassen.
+                if fd is not None:
+                    spalten.append(f"{FELD_PRAEFIX}{fd.id}")
+
+            kategorie_ids = [
+                pfad_zu_id[p] for p in entry.get("kategorien", []) if p in pfad_zu_id
+            ]
+            roh_datei = entry.get("datei_base64")
+            db.add(EtikettenVorlage(
+                name=name,
+                art=entry.get("art") or "items",
+                position=int(entry.get("position") or 0),
+                konfiguration=json.dumps({
+                    "spalten": spalten,
+                    "kategorie_ids": kategorie_ids,
+                    "trennzeichen": entry.get("trennzeichen") or ",",
+                }, ensure_ascii=False),
+                datei_name=entry.get("datei_name"),
+                datei=base64.b64decode(roh_datei) if roh_datei else None,
+            ))
+            angelegt += 1
+        except Exception as exc:
+            errors.append(f"Etiketten-Vorlage {entry.get('name')!r}: {exc}")
+    db.commit()
+    return angelegt
+
+
 def _category_path(db: Session, category: Category | None) -> str:
     """Unterkategorien als "Süßwaren & Snacks > Schokolade" in EINE Spalte.
 
@@ -901,9 +1007,14 @@ def _import_json(db: Session, content: bytes, user: User, mode: str) -> dict:
         except Exception as exc:
             errors.append(f"Produkt {entry.get('name')!r}: {exc}")
 
+    vorlagen_created = _vorlagen_importieren(
+        db, data.get("etiketten_vorlagen", []), errors
+    )
+
     return {
         "format": "json",
         "mode": mode,
+        "etiketten_vorlagen_created": vorlagen_created,
         "units_created": units_created,
         "products_created": len(created_products),
         "products_cleared": len(cleared),