feat: Buchungen lassen sich mit eigenen, farbigen Tags versehen und danach filtern

Die Kategorie beantwortet "wofuer war das Geld" und gilt genau einmal. Alles,
was quer dazu liegt – "Urlaub Island", "absetzbar", "zurueckfordern" –, hatte
bisher keinen Platz, weil eine Buchung davon mehrere auf einmal sein kann.

Tags werden auf einer eigenen Seite angelegt, jeder mit seiner Farbe. Gesetzt
werden sie an der Buchung: direkt in der Liste oder beim Bearbeiten. Die
Spalte laesst sich filtern, auch nach mehreren Tags gleichzeitig.

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

backend/app/main.py

@@ -45,6 +45,7 @@ from .routers import (
     rates,
     settings as settings_router,
     subscriptions,
+    tags,
     transactions,
     users,
 )
@@ -214,6 +215,7 @@ api.include_router(settings_router.router)
 api.include_router(policy.router)
 api.include_router(accounts.router)
 api.include_router(categories.router)
+api.include_router(tags.router)
 api.include_router(transactions.router)
 api.include_router(budgets.router)
 api.include_router(dashboard.router)

backend/app/models.py

@@ -1281,3 +1281,61 @@ class BankAccountLink(Base):
         except ValueError:
             return {}
         return daten if isinstance(daten, dict) else {}
+
+
+class Tag(Base):
+    """Ein frei vergebenes Etikett fuer Buchungen, mit eigener Farbe.
+
+    Neben der Kategorie, nicht statt ihr: Die Kategorie beantwortet „wofuer war
+    das Geld", ein Tag alles andere, was sich quer dazu legt – „Urlaub Island",
+    „steuerlich absetzbar", „zurueckfordern". Deshalb mehrere je Buchung und
+    keine Pflicht, genau eines zu waehlen.
+
+    Die Farbe traegt der Tag selbst, wie bei Kategorie und Gruppe: In einer
+    langen Liste erkennt man sie am Fleck, bevor man den Text liest.
+    """
+
+    __tablename__ = "tags"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    owner_id: Mapped[int] = mapped_column(
+        ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+    name: Mapped[str] = mapped_column(String(60), nullable=False)
+    color: Mapped[str] = mapped_column(String(9), nullable=False, default="#6b7480")
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_now)
+
+    __table_args__ = (
+        UniqueConstraint("owner_id", "name", name="uq_tag_owner_name"),
+    )
+
+
+class TransactionTag(Base):
+    """Welcher Tag haengt an welcher Buchung.
+
+    Eine eigene Tabelle und kein ``secondary``-Verweis, wie ueberall hier
+    (``TransferLink``, ``LinkIgnored``): Sie traegt ihre eigene ``owner_id`` und
+    ist damit vom Backup und von der Mandanten-Pruefung erfasst wie jede andere.
+
+    CASCADE auf beiden Seiten. Verschwindet die Buchung oder der Tag, ist die
+    Zuordnung gegenstandslos – es verschwindet immer nur das Etikett, nie eine
+    Buchung.
+    """
+
+    __tablename__ = "transaction_tags"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    owner_id: Mapped[int] = mapped_column(
+        ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+    transaction_id: Mapped[int] = mapped_column(
+        ForeignKey("transactions.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+    tag_id: Mapped[int] = mapped_column(
+        ForeignKey("tags.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_now)
+
+    __table_args__ = (
+        UniqueConstraint("transaction_id", "tag_id", name="uq_txn_tag"),
+    )

backend/app/routers/tags.py

@@ -0,0 +1,83 @@
+"""Tags: frei vergebene Etiketten fuer Buchungen. Alles owner-gescoped.
+
+Neben der Kategorie, nicht statt ihr. Die Kategorie sagt, wofuer das Geld war;
+ein Tag alles, was quer dazu liegt – und davon duerfen mehrere an einer Buchung
+haengen.
+
+Die Zuordnung selbst wird hier NICHT gesetzt, sondern an der Buchung
+(``PATCH /transactions/{id}`` mit ``tag_ids``). Sonst gaebe es zwei Wege, eine
+Buchung zu aendern, und zwei Stellen, an denen man es vergessen kann.
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from ..deps import get_current_user, get_owned
+from ..models import Tag, User
+from ..schemas import TagCreate, TagOut, TagUpdate
+
+router = APIRouter(prefix="/tags", tags=["tags"])
+
+
+def _name_frei(db: Session, user: User, name: str, ausser_id: int | None = None) -> None:
+    """Denselben Namen zweimal gaebe es in der Liste nicht zu unterscheiden."""
+    q = db.query(Tag.id).filter(Tag.owner_id == user.id, Tag.name == name)
+    if ausser_id is not None:
+        q = q.filter(Tag.id != ausser_id)
+    if q.first() is not None:
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT,
+                            detail=f"Den Tag „{name}“ gibt es schon.")
+
+
+@router.get("", response_model=list[TagOut])
+def list_tags(db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    # Alphabetisch: In einer Auswahlliste sucht man nach dem Namen, nicht
+    # danach, wann der Tag entstanden ist.
+    return (
+        db.query(Tag).filter(Tag.owner_id == user.id).order_by(Tag.name).all()
+    )
+
+
+@router.post("", response_model=TagOut, status_code=status.HTTP_201_CREATED)
+def create_tag(payload: TagCreate, db: Session = Depends(get_db),
+               user: User = Depends(get_current_user)):
+    name = payload.name.strip()
+    if not name:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
+                            detail="Leerer Name")
+    _name_frei(db, user, name)
+    tag = Tag(owner_id=user.id, name=name, color=payload.color)
+    db.add(tag)
+    db.commit()
+    db.refresh(tag)
+    return TagOut.model_validate(tag)
+
+
+@router.patch("/{tag_id}", response_model=TagOut)
+def update_tag(tag_id: int, payload: TagUpdate, db: Session = Depends(get_db),
+               user: User = Depends(get_current_user)):
+    tag = get_owned(db, Tag, tag_id, user)
+    daten = payload.model_dump(exclude_unset=True)
+    if "name" in daten and daten["name"] is not None:
+        name = daten["name"].strip()
+        if not name:
+            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
+                                detail="Leerer Name")
+        _name_frei(db, user, name, ausser_id=tag.id)
+        tag.name = name
+    if daten.get("color") is not None:
+        tag.color = daten["color"]
+    db.commit()
+    db.refresh(tag)
+    return TagOut.model_validate(tag)
+
+
+@router.delete("/{tag_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_tag(tag_id: int, db: Session = Depends(get_db),
+               user: User = Depends(get_current_user)):
+    """Den Tag loeschen. Die Buchungen bleiben – es faellt nur das Etikett ab
+    (ON DELETE CASCADE auf ``transaction_tags``)."""
+    tag = get_owned(db, Tag, tag_id, user)
+    db.delete(tag)
+    db.commit()

backend/app/routers/transactions.py

@@ -19,7 +19,9 @@ from ..models import (
     Category,
     InboxItem,
     InboxStatus,
+    Tag,
     Transaction,
+    TransactionTag,
     TransferLink,
     TxnType,
     User,
@@ -82,7 +84,8 @@ def _pruefe_zeitraum(db: Session, user: User, label: str | None, tag: date) -> s
 
 
 def to_out(db: Session, txn: Transaction, base: str, ccy_by_account: dict[int, str],
-           herkunft: dict[int, str] | None = None, start_tag: int = 1) -> TransactionOut:
+           herkunft: dict[int, str] | None = None, start_tag: int = 1,
+           tags: dict[int, list[int]] | None = None) -> TransactionOut:
     acc_ccy = ccy_by_account.get(txn.account_id, "EUR")
     if base == "EUR":
         amount_base = txn.amount_eur_cents
@@ -113,9 +116,50 @@ def to_out(db: Session, txn: Transaction, base: str, ccy_by_account: dict[int, s
         payee=txn.payee,
         description=txn.description,
         notes=txn.notes,
+        tag_ids=(tags or {}).get(txn.id, []),
     )
 
 
+def _tags(db: Session, user: User, txns: list[Transaction]) -> dict[int, list[int]]:
+    """Die Tags je Buchung – als EINE Abfrage, nicht je Zeile.
+
+    Die Buchungsliste geht bis 5000 Zeilen; je Zeile zu fragen waere genau das
+    N+1, das die vier Nachbarn hier schon vermeiden.
+    """
+    ids = [t.id for t in txns]
+    if not ids:
+        return {}
+    nach: dict[int, list[int]] = {}
+    for txn_id, tag_id in db.query(
+        TransactionTag.transaction_id, TransactionTag.tag_id
+    ).filter(TransactionTag.owner_id == user.id,
+             TransactionTag.transaction_id.in_(ids)):
+        nach.setdefault(txn_id, []).append(tag_id)
+    return nach
+
+
+def _setze_tags(db: Session, user: User, txn: Transaction, tag_ids: list[int]) -> None:
+    """Die Tags einer Buchung auf genau diese Liste bringen.
+
+    Ersetzen statt ergaenzen: Die Oberflaeche schickt immer den vollen Stand,
+    sonst liesse sich ein Tag nie wieder abnehmen. Jede ID wird geprueft – ein
+    fremder Tag darf auch dann nicht haengenbleiben, wenn jemand die ID raet.
+    """
+    gewuenscht = {int(i) for i in tag_ids}
+    for tag_id in gewuenscht:
+        get_owned(db, Tag, tag_id, user)
+    vorhanden = {
+        z.tag_id: z for z in db.query(TransactionTag).filter(
+            TransactionTag.owner_id == user.id,
+            TransactionTag.transaction_id == txn.id)
+    }
+    for tag_id, zeile in vorhanden.items():
+        if tag_id not in gewuenscht:
+            db.delete(zeile)
+    for tag_id in gewuenscht - set(vorhanden):
+        db.add(TransactionTag(owner_id=user.id, transaction_id=txn.id, tag_id=tag_id))
+
+
 def _currency_map(db: Session, user: User) -> dict[int, str]:
     rows = db.query(Account.id, Account.currency).filter(Account.owner_id == user.id).all()
     return {row[0]: row[1] for row in rows}
@@ -184,7 +228,8 @@ def list_transactions(
     ccy = _currency_map(db, user)
     woher = _herkunft(db, user, rows)
     tag = budget.start_tag(db, user)
-    return [to_out(db, t, base, ccy, woher, tag) for t in rows]
+    etiketten = _tags(db, user, rows)
+    return [to_out(db, t, base, ccy, woher, tag, etiketten) for t in rows]
 
 
 @router.get("/dubletten")
@@ -332,10 +377,14 @@ def create_transaction(
     )
     buchung.setze_betraege(db, txn, from_acc, to_acc)
     db.add(txn)
+    if payload.tag_ids:
+        db.flush()                     # erst mit id laesst sich das Etikett haengen
+        _setze_tags(db, user, txn, payload.tag_ids)
     db.commit()
     db.refresh(txn)
     return to_out(db, txn, base_currency(db, user), _currency_map(db, user),
-                  _herkunft(db, user, [txn]), budget.start_tag(db, user))
+                  _herkunft(db, user, [txn]), budget.start_tag(db, user),
+                  _tags(db, user, [txn]))
 
 
 @router.get("/{txn_id}", response_model=TransactionOut)
@@ -344,7 +393,8 @@ def get_transaction(
 ):
     txn = get_owned(db, Transaction, txn_id, user)
     return to_out(db, txn, base_currency(db, user), _currency_map(db, user),
-                  _herkunft(db, user, [txn]), budget.start_tag(db, user))
+                  _herkunft(db, user, [txn]), budget.start_tag(db, user),
+                  _tags(db, user, [txn]))
 
 
 @router.patch("/{txn_id}", response_model=TransactionOut)
@@ -390,11 +440,16 @@ def update_transaction(
     else:
         txn.to_account_id = None
     buchung.setze_betraege(db, txn, from_acc, to_acc)
+    # Nach exclude_unset: mitgeschickt heisst ersetzen (auch mit leerer Liste),
+    # weggelassen heisst unberuehrt lassen.
+    if data.get("tag_ids") is not None:
+        _setze_tags(db, user, txn, data["tag_ids"])
 
     db.commit()
     db.refresh(txn)
     return to_out(db, txn, base_currency(db, user), _currency_map(db, user),
-                  _herkunft(db, user, [txn]), budget.start_tag(db, user))
+                  _herkunft(db, user, [txn]), budget.start_tag(db, user),
+                  _tags(db, user, [txn]))
 
 
 class TransactionTransferIn(BaseModel):
@@ -426,7 +481,8 @@ def make_transfer(txn_id: int, payload: TransactionTransferIn,
     db.commit()
     db.refresh(txn)
     return to_out(db, txn, base_currency(db, user), _currency_map(db, user),
-                  _herkunft(db, user, [txn]), budget.start_tag(db, user))
+                  _herkunft(db, user, [txn]), budget.start_tag(db, user),
+                  _tags(db, user, [txn]))
 
 
 @router.delete("/{txn_id}", status_code=status.HTTP_204_NO_CONTENT)

backend/app/schemas.py

@@ -346,6 +346,28 @@ class SubscriptionListOut(BaseModel):
     summary: SubscriptionSummary
 
 
+# --- Tags ------------------------------------------------------------------
+
+
+class TagOut(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    name: str
+    color: str
+
+
+class TagCreate(BaseModel):
+    name: str = Field(min_length=1, max_length=60)
+    # Ohne Angabe dasselbe Grau wie bei einer neuen Kategorie.
+    color: str = "#6b7480"
+
+
+class TagUpdate(BaseModel):
+    name: str | None = Field(default=None, min_length=1, max_length=60)
+    color: str | None = None
+
+
 # --- Kategorien ------------------------------------------------------------
 
 
@@ -433,6 +455,9 @@ class TransactionCreate(BaseModel):
     payee: str | None = Field(default=None, max_length=255)
     description: str | None = Field(default=None, max_length=255)
     notes: str | None = None
+    # Beim Anlegen gleich mitgeben, sonst muesste man die Buchung direkt
+    # danach noch einmal oeffnen, nur um sie zu etikettieren.
+    tag_ids: list[int] = []
 
 
 class TransactionUpdate(BaseModel):
@@ -452,6 +477,10 @@ class TransactionUpdate(BaseModel):
     payee: str | None = Field(default=None, max_length=255)
     description: str | None = Field(default=None, max_length=255)
     notes: str | None = None
+    # Die Tags dieser Buchung, vollstaendig. Mitgeschickt heisst ERSETZEN –
+    # eine leere Liste nimmt alle weg. Weggelassen laesst sie unberuehrt;
+    # darum haengt hier ``exclude_unset`` im Router dran.
+    tag_ids: list[int] | None = None
 
 
 class TransactionOut(BaseModel):
@@ -486,6 +515,11 @@ class TransactionOut(BaseModel):
     payee: str | None
     description: str | None
     notes: str | None
+    # Die Tags dieser Buchung. Anders als die Uebertrags-Verknuepfung stehen
+    # sie IM Schema und nicht in einem eigenen Endpunkt: Jede Zeile der
+    # Buchungsliste zeigt und filtert nach ihnen, ein zweiter Abruf wuerde im
+    # Browser doch nur wieder zusammengefuegt.
+    tag_ids: list[int] = []
 
 
 class RateStatus(BaseModel):