feat: Schlagwörter je Kategorie + auf-/zuklappbares Kategorie-Dropdown
- Manuelle Schlagwörter je Kategorie (Popup mit Chips, Doppelklick zum Bearbeiten) - Treffer über Empfänger ODER Verwendungszweck; längstes Schlagwort gewinnt; Kind-Filter (Ausgabe/Einnahme); wirken nur bei künftigen Importen - Lernende Korrektur-Erkennung: ab 5 Anwendungen und >= 1/3 Korrekturen erscheint eine Prüf-Meldung in den Einstellungen (Behalten/Entfernen) - Neue CategorySelect-Komponente (Baum + Suche, per Portal) ersetzt die nativen optgroup-Selects in Buchungen und Import-Prüfansicht - Migration 0006 (source/applied_count/overridden_count/confirmed, match_field any) - Endpunkte, i18n DE/EN, Tests (test_keywords: 7 neu, gesamt 27 grün) Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Guido
Claude Opus 4.8
+18
-1
@@ -94,6 +94,12 @@ class AmountMode(str, enum.Enum):
|
||||
class MatchField(str, enum.Enum):
|
||||
payee = "payee"
|
||||
purpose = "purpose"
|
||||
any = "any" # trifft, wenn das Muster im Empfänger ODER im Zweck vorkommt
|
||||
|
||||
|
||||
class RuleSource(str, enum.Enum):
|
||||
learned = "learned" # automatisch aus bestätigten Zuordnungen gelernt
|
||||
manual = "manual" # vom Nutzer als Schlagwort angelegt
|
||||
|
||||
|
||||
class ImportStatus(str, enum.Enum):
|
||||
@@ -466,7 +472,13 @@ class ImportBatch(Base):
|
||||
|
||||
|
||||
class CategorizationRule(Base):
|
||||
"""Lernende Regel: Empfänger/Zweck enthält Muster -> Kategorie (oder Transfer)."""
|
||||
"""Regel: Empfänger/Zweck enthält Muster -> Kategorie.
|
||||
|
||||
Zwei Quellen (``source``): ``learned`` wird beim Import automatisch aus
|
||||
bestätigten Zuordnungen gelernt; ``manual`` legt der Nutzer als Schlagwort je
|
||||
Kategorie an. ``applied_count``/``overridden_count`` zählen, wie oft die Regel
|
||||
zutraf und wie oft ihr Vorschlag wegkorrigiert wurde – daraus wird ein
|
||||
manuelles Schlagwort ggf. als „stimmt vielleicht nicht" markiert."""
|
||||
|
||||
__tablename__ = "categorization_rules"
|
||||
|
||||
@@ -479,8 +491,13 @@ class CategorizationRule(Base):
|
||||
category_id: Mapped[int | None] = mapped_column(
|
||||
ForeignKey("categories.id", ondelete="CASCADE"), nullable=True
|
||||
)
|
||||
source: Mapped[RuleSource] = mapped_column(_enum(RuleSource), nullable=False, default=RuleSource.learned)
|
||||
priority: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
|
||||
hits: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
|
||||
applied_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
|
||||
overridden_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
|
||||
# „Behalten, nicht mehr fragen" – unterdrückt das Flaggen trotz Korrekturen.
|
||||
confirmed: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_now)
|
||||
|
||||
__table_args__ = (
|
||||
|
||||
@@ -3,12 +3,12 @@
|
||||
Eine Kategorie erbt ihre Art (Einnahme/Ausgabe) von ihrer Gruppe.
|
||||
"""
|
||||
|
||||
from fastapi import APIRouter, Depends, status
|
||||
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 Category, CategoryGroup, User
|
||||
from ..models import CategorizationRule, Category, CategoryGroup, MatchField, RuleSource, User
|
||||
from ..schemas import (
|
||||
CategoryCreate,
|
||||
CategoryGroupCreate,
|
||||
@@ -16,10 +16,20 @@ from ..schemas import (
|
||||
CategoryGroupUpdate,
|
||||
CategoryOut,
|
||||
CategoryUpdate,
|
||||
FlaggedKeywordOut,
|
||||
KeywordCreate,
|
||||
KeywordOut,
|
||||
KeywordUpdate,
|
||||
)
|
||||
from ..services.csv_import import normalize_text
|
||||
|
||||
router = APIRouter(prefix="/categories", tags=["categories"])
|
||||
|
||||
# Ab wann ein manuelles Schlagwort als „stimmt vielleicht nicht" markiert wird:
|
||||
# mindestens so viele Anwendungen UND mindestens dieser Anteil wegkorrigiert.
|
||||
FLAG_MIN_APPLIED = 5
|
||||
FLAG_RATIO_DEN = 3 # >= 1/3 (jede dritte)
|
||||
|
||||
|
||||
def group_out(g: CategoryGroup) -> CategoryGroupOut:
|
||||
cats = sorted(g.categories, key=lambda c: (c.position, c.name.lower()))
|
||||
@@ -152,3 +162,152 @@ def delete_category(
|
||||
cat = get_owned(db, Category, category_id, user)
|
||||
db.delete(cat)
|
||||
db.commit()
|
||||
|
||||
|
||||
# --- Schlagwörter je Kategorie (manuelle Regeln, Feld = Empfänger ODER Zweck) ---
|
||||
|
||||
|
||||
def _keyword_out(rule: CategorizationRule) -> KeywordOut:
|
||||
return KeywordOut(id=rule.id, category_id=rule.category_id, word=rule.pattern)
|
||||
|
||||
|
||||
def _owned_manual_rule(db: Session, rule_id: int, user: User) -> CategorizationRule:
|
||||
rule = db.get(CategorizationRule, rule_id)
|
||||
if rule is None or rule.owner_id != user.id or rule.source != RuleSource.manual:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Nicht gefunden")
|
||||
return rule
|
||||
|
||||
|
||||
@router.get("/keywords/flagged", response_model=list[FlaggedKeywordOut])
|
||||
def list_flagged_keywords(db: Session = Depends(get_db), user: User = Depends(get_current_user)):
|
||||
"""Manuelle Schlagwörter, die auffällig oft wegkorrigiert werden."""
|
||||
rules = (
|
||||
db.query(CategorizationRule)
|
||||
.filter(
|
||||
CategorizationRule.owner_id == user.id,
|
||||
CategorizationRule.source == RuleSource.manual,
|
||||
CategorizationRule.confirmed.is_(False),
|
||||
CategorizationRule.applied_count >= FLAG_MIN_APPLIED,
|
||||
CategorizationRule.overridden_count * FLAG_RATIO_DEN >= CategorizationRule.applied_count,
|
||||
)
|
||||
.order_by(CategorizationRule.overridden_count.desc())
|
||||
.all()
|
||||
)
|
||||
names = {c.id: c.name for c in db.query(Category).filter(Category.owner_id == user.id)}
|
||||
return [
|
||||
FlaggedKeywordOut(
|
||||
id=r.id, category_id=r.category_id, category_name=names.get(r.category_id, "?"),
|
||||
word=r.pattern, applied_count=r.applied_count, overridden_count=r.overridden_count,
|
||||
)
|
||||
for r in rules
|
||||
]
|
||||
|
||||
|
||||
@router.post("/keywords/{rule_id}/confirm", status_code=status.HTTP_204_NO_CONTENT)
|
||||
def confirm_keyword(rule_id: int, db: Session = Depends(get_db), user: User = Depends(get_current_user)):
|
||||
"""„Behalten" – nicht mehr nachfragen, obwohl korrigiert wird."""
|
||||
rule = _owned_manual_rule(db, rule_id, user)
|
||||
rule.confirmed = True
|
||||
db.commit()
|
||||
|
||||
|
||||
@router.patch("/keywords/{rule_id}", response_model=KeywordOut)
|
||||
def update_keyword(
|
||||
rule_id: int,
|
||||
payload: KeywordUpdate,
|
||||
db: Session = Depends(get_db),
|
||||
user: User = Depends(get_current_user),
|
||||
):
|
||||
"""Wort eines Schlagworts ändern (Inline-Bearbeitung im Popup). Da sich das
|
||||
Muster ändert, werden die Korrektur-Zähler zurückgesetzt."""
|
||||
rule = _owned_manual_rule(db, rule_id, user)
|
||||
pattern = normalize_text(payload.word)[:255]
|
||||
if not pattern:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Leeres Schlagwort")
|
||||
if pattern != rule.pattern:
|
||||
clash = (
|
||||
db.query(CategorizationRule)
|
||||
.filter(
|
||||
CategorizationRule.owner_id == user.id,
|
||||
CategorizationRule.match_field == MatchField.any,
|
||||
CategorizationRule.pattern == pattern,
|
||||
CategorizationRule.id != rule.id,
|
||||
)
|
||||
.first()
|
||||
)
|
||||
if clash is not None:
|
||||
other = db.get(Category, clash.category_id)
|
||||
other_name = other.name if other else "?"
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_409_CONFLICT,
|
||||
detail=f"Schlagwort ist bereits der Kategorie „{other_name}“ zugeordnet.",
|
||||
)
|
||||
rule.pattern = pattern
|
||||
rule.applied_count = 0
|
||||
rule.overridden_count = 0
|
||||
rule.confirmed = False
|
||||
db.commit()
|
||||
db.refresh(rule)
|
||||
return _keyword_out(rule)
|
||||
|
||||
|
||||
@router.delete("/keywords/{rule_id}", status_code=status.HTTP_204_NO_CONTENT)
|
||||
def delete_keyword(rule_id: int, db: Session = Depends(get_db), user: User = Depends(get_current_user)):
|
||||
rule = _owned_manual_rule(db, rule_id, user)
|
||||
db.delete(rule)
|
||||
db.commit()
|
||||
|
||||
|
||||
@router.get("/{category_id}/keywords", response_model=list[KeywordOut])
|
||||
def list_keywords(category_id: int, db: Session = Depends(get_db), user: User = Depends(get_current_user)):
|
||||
cat = get_owned(db, Category, category_id, user)
|
||||
rules = (
|
||||
db.query(CategorizationRule)
|
||||
.filter(
|
||||
CategorizationRule.owner_id == user.id,
|
||||
CategorizationRule.source == RuleSource.manual,
|
||||
CategorizationRule.category_id == cat.id,
|
||||
)
|
||||
.order_by(CategorizationRule.pattern)
|
||||
.all()
|
||||
)
|
||||
return [_keyword_out(r) for r in rules]
|
||||
|
||||
|
||||
@router.post("/{category_id}/keywords", response_model=KeywordOut, status_code=status.HTTP_201_CREATED)
|
||||
def add_keyword(
|
||||
category_id: int,
|
||||
payload: KeywordCreate,
|
||||
db: Session = Depends(get_db),
|
||||
user: User = Depends(get_current_user),
|
||||
):
|
||||
cat = get_owned(db, Category, category_id, user)
|
||||
pattern = normalize_text(payload.word)[:255]
|
||||
if not pattern:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Leeres Schlagwort")
|
||||
existing = (
|
||||
db.query(CategorizationRule)
|
||||
.filter(
|
||||
CategorizationRule.owner_id == user.id,
|
||||
CategorizationRule.match_field == MatchField.any,
|
||||
CategorizationRule.pattern == pattern,
|
||||
)
|
||||
.first()
|
||||
)
|
||||
if existing is not None:
|
||||
if existing.category_id == cat.id:
|
||||
return _keyword_out(existing) # schon vorhanden – unverändert zurück
|
||||
other = db.get(Category, existing.category_id)
|
||||
other_name = other.name if other else "?"
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_409_CONFLICT,
|
||||
detail=f"Schlagwort ist bereits der Kategorie „{other_name}“ zugeordnet.",
|
||||
)
|
||||
rule = CategorizationRule(
|
||||
owner_id=user.id, match_field=MatchField.any, pattern=pattern,
|
||||
category_id=cat.id, source=RuleSource.manual, priority=10,
|
||||
)
|
||||
db.add(rule)
|
||||
db.commit()
|
||||
db.refresh(rule)
|
||||
return _keyword_out(rule)
|
||||
|
||||
@@ -345,3 +345,29 @@ class ImportCommitIn(BaseModel):
|
||||
template_id: int | None = None
|
||||
filename: str = ""
|
||||
rows: list[dict] = Field(default_factory=list)
|
||||
|
||||
|
||||
# --- Schlagwörter (manuelle Kategorisierungs-Regeln) -----------------------
|
||||
|
||||
|
||||
class KeywordCreate(BaseModel):
|
||||
word: str = Field(min_length=1, max_length=255)
|
||||
|
||||
|
||||
class KeywordUpdate(BaseModel):
|
||||
word: str = Field(min_length=1, max_length=255)
|
||||
|
||||
|
||||
class KeywordOut(BaseModel):
|
||||
id: int
|
||||
category_id: int
|
||||
word: str
|
||||
|
||||
|
||||
class FlaggedKeywordOut(BaseModel):
|
||||
id: int
|
||||
category_id: int
|
||||
category_name: str
|
||||
word: str
|
||||
applied_count: int
|
||||
overridden_count: int
|
||||
|
||||
@@ -18,10 +18,12 @@ from ..models import (
|
||||
BudgetTreatment,
|
||||
CategorizationRule,
|
||||
Category,
|
||||
CategoryKind,
|
||||
ImportBatch,
|
||||
ImportStatus,
|
||||
ImportTemplate,
|
||||
MatchField,
|
||||
RuleSource,
|
||||
SAVINGS_ACCOUNT_TYPES,
|
||||
Transaction,
|
||||
TxnType,
|
||||
@@ -143,14 +145,43 @@ def import_hash(account_id: int, d: date | None, amount_cents: int | None, payee
|
||||
# --- Vorschau --------------------------------------------------------------
|
||||
|
||||
|
||||
def _apply_rules(rules: list[CategorizationRule], payee: str, purpose: str) -> int | None:
|
||||
def _rule_sort_key(rule: CategorizationRule) -> tuple:
|
||||
"""Reihenfolge der Regelanwendung: längstes Schlagwort zuerst, dann manuelle
|
||||
vor gelernten, dann höhere Priorität/mehr Treffer."""
|
||||
return (
|
||||
len(rule.pattern or ""),
|
||||
1 if rule.source == RuleSource.manual else 0,
|
||||
rule.priority,
|
||||
rule.hits,
|
||||
)
|
||||
|
||||
|
||||
def _apply_rules(
|
||||
rules: list[CategorizationRule],
|
||||
payee: str,
|
||||
purpose: str,
|
||||
allowed_kind: CategoryKind | None,
|
||||
cat_kind: dict[int, CategoryKind],
|
||||
) -> tuple[int | None, int | None]:
|
||||
"""Erste passende Regel -> (category_id, rule_id). Nur Kategorien, deren Art
|
||||
(Einnahme/Ausgabe) zur Buchung passt, damit ein Ausgabe-Schlagwort keine
|
||||
Einnahme falsch einordnet."""
|
||||
p = normalize_text(payee)
|
||||
z = normalize_text(purpose)
|
||||
for rule in rules: # bereits nach Priorität sortiert
|
||||
hay = p if rule.match_field == MatchField.payee else z
|
||||
if rule.pattern and rule.pattern in hay and rule.category_id:
|
||||
return rule.category_id
|
||||
return None
|
||||
for rule in rules: # bereits sortiert (längstes/manuell zuerst)
|
||||
if not rule.pattern or not rule.category_id:
|
||||
continue
|
||||
if allowed_kind is not None and cat_kind.get(rule.category_id) != allowed_kind:
|
||||
continue
|
||||
if rule.match_field == MatchField.payee:
|
||||
hit = rule.pattern in p
|
||||
elif rule.match_field == MatchField.purpose:
|
||||
hit = rule.pattern in z
|
||||
else: # any: Empfänger ODER Zweck
|
||||
hit = rule.pattern in p or rule.pattern in z
|
||||
if hit:
|
||||
return rule.category_id, rule.id
|
||||
return None, None
|
||||
|
||||
|
||||
def parse_file_to_candidates(data: bytes, template: ImportTemplate) -> list[dict]:
|
||||
@@ -200,12 +231,12 @@ def detect_rows(db: Session, user: User, account: Account, candidates: list[dict
|
||||
):
|
||||
idents[value_norm] = acc_id
|
||||
|
||||
rules = (
|
||||
db.query(CategorizationRule)
|
||||
.filter(CategorizationRule.owner_id == user.id)
|
||||
.order_by(CategorizationRule.priority.desc(), CategorizationRule.hits.desc())
|
||||
.all()
|
||||
)
|
||||
rules = db.query(CategorizationRule).filter(CategorizationRule.owner_id == user.id).all()
|
||||
rules.sort(key=_rule_sort_key, reverse=True) # längstes/manuell zuerst
|
||||
cat_kind: dict[int, CategoryKind] = {
|
||||
cid: kind
|
||||
for cid, kind in db.query(Category.id, Category.type).filter(Category.owner_id == user.id)
|
||||
}
|
||||
existing = {
|
||||
h[0]
|
||||
for h in db.query(Transaction.import_hash).filter(
|
||||
@@ -226,6 +257,7 @@ def detect_rows(db: Session, user: User, account: Account, candidates: list[dict
|
||||
valid = d is not None and amount is not None and amount != 0
|
||||
ttype = "expense" if (amount or 0) < 0 else "income"
|
||||
category_id: int | None = None
|
||||
matched_rule_id: int | None = None
|
||||
to_account_id: int | None = None
|
||||
|
||||
other = idents.get(iban) if iban else None
|
||||
@@ -233,7 +265,10 @@ def detect_rows(db: Session, user: User, account: Account, candidates: list[dict
|
||||
ttype = "transfer"
|
||||
to_account_id = other
|
||||
else:
|
||||
category_id = _apply_rules(rules, payee or "", purpose or "")
|
||||
kind = CategoryKind.expense if ttype == "expense" else CategoryKind.income
|
||||
category_id, matched_rule_id = _apply_rules(
|
||||
rules, payee or "", purpose or "", kind, cat_kind
|
||||
)
|
||||
|
||||
h = import_hash(account.id, d, amount, payee)
|
||||
is_dup = h in existing or h in seen
|
||||
@@ -249,6 +284,7 @@ def detect_rows(db: Session, user: User, account: Account, candidates: list[dict
|
||||
"valid": valid,
|
||||
"type": ttype,
|
||||
"category_id": category_id,
|
||||
"matched_rule_id": matched_rule_id,
|
||||
"to_account_id": to_account_id,
|
||||
"import_hash": h,
|
||||
"is_duplicate": is_dup,
|
||||
@@ -347,13 +383,34 @@ def _learn_rule(db: Session, user: User, row: dict) -> None:
|
||||
if existing is None:
|
||||
db.add(CategorizationRule(
|
||||
owner_id=user.id, match_field=MatchField.payee, pattern=pattern,
|
||||
category_id=cat, priority=1, hits=1,
|
||||
category_id=cat, source=RuleSource.learned, priority=1, hits=1,
|
||||
))
|
||||
# Sichtbar machen (Session ist autoflush=False), damit dasselbe Muster ein
|
||||
# zweites Mal im selben Import die vorhandene Regel findet statt zu doppeln.
|
||||
db.flush()
|
||||
else:
|
||||
existing.category_id = cat
|
||||
existing.hits += 1
|
||||
|
||||
|
||||
def _track_and_learn(db: Session, user: User, row: dict) -> None:
|
||||
"""Zählt für die zutreffende Regel Anwendung/Korrektur (Basis fürs Flaggen von
|
||||
Schlagwörtern) und lernt anschließend Empfänger -> Kategorie weiter."""
|
||||
rid = row.get("matched_rule_id")
|
||||
final_cat = row.get("category_id")
|
||||
matched_manual_kept = False
|
||||
if rid:
|
||||
rule = db.get(CategorizationRule, rid)
|
||||
if rule is not None and rule.owner_id == user.id:
|
||||
rule.applied_count = (rule.applied_count or 0) + 1
|
||||
if final_cat != rule.category_id:
|
||||
rule.overridden_count = (rule.overridden_count or 0) + 1
|
||||
elif rule.source == RuleSource.manual:
|
||||
matched_manual_kept = True # Schlagwort greift schon – nicht doppelt lernen
|
||||
if not matched_manual_kept:
|
||||
_learn_rule(db, user, row)
|
||||
|
||||
|
||||
def commit_import(db: Session, user: User, account: Account, template_id: int | None, filename: str, rows: list[dict]) -> ImportBatch:
|
||||
accounts = {a.id: a for a in db.query(Account).filter(Account.owner_id == user.id)}
|
||||
batch = ImportBatch(
|
||||
@@ -372,7 +429,7 @@ def commit_import(db: Session, user: User, account: Account, template_id: int |
|
||||
if txn is None:
|
||||
continue
|
||||
db.add(txn)
|
||||
_learn_rule(db, user, row)
|
||||
_track_and_learn(db, user, row)
|
||||
imported += 1
|
||||
|
||||
batch.imported_count = imported
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
"""Schlagwörter/Regeln erweitern: Quelle + Korrektur-Zähler + „behalten".
|
||||
|
||||
Manuelle Schlagwörter je Kategorie und die lernende Korrektur-Erkennung nutzen
|
||||
dieselbe Tabelle ``categorization_rules`` wie die automatisch gelernten Regeln.
|
||||
|
||||
Revision ID: 0006
|
||||
Revises: 0005
|
||||
Create Date: 2026-08-19
|
||||
"""
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
|
||||
revision = "0006"
|
||||
down_revision = "0005"
|
||||
branch_labels = None
|
||||
depends_on = None
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
with op.batch_alter_table("categorization_rules") as batch:
|
||||
batch.add_column(sa.Column("source", sa.String(length=32), nullable=False, server_default="learned"))
|
||||
batch.add_column(sa.Column("applied_count", sa.Integer(), nullable=False, server_default=sa.text("0")))
|
||||
batch.add_column(sa.Column("overridden_count", sa.Integer(), nullable=False, server_default=sa.text("0")))
|
||||
batch.add_column(sa.Column("confirmed", sa.Boolean(), nullable=False, server_default=sa.text("0")))
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
with op.batch_alter_table("categorization_rules") as batch:
|
||||
batch.drop_column("confirmed")
|
||||
batch.drop_column("overridden_count")
|
||||
batch.drop_column("applied_count")
|
||||
batch.drop_column("source")
|
||||
@@ -0,0 +1,162 @@
|
||||
"""Schlagwörter je Kategorie: Anlegen/Konflikt, Treffer (Empfänger ODER Zweck),
|
||||
längstes gewinnt, Kind-Filter, Korrektur-Erkennung/Flagging, keine Rückwirkung."""
|
||||
|
||||
import io
|
||||
import json
|
||||
|
||||
|
||||
def _account(admin, **kw):
|
||||
body = {"name": "Giro", "type": "girokonto", "currency": "EUR", "opening_balance_cents": 0}
|
||||
body.update(kw)
|
||||
r = admin.post("/api/accounts", json=body)
|
||||
assert r.status_code == 201, r.text
|
||||
return r.json()
|
||||
|
||||
|
||||
def _expense_cats(admin, n=2):
|
||||
out = []
|
||||
for g in admin.get("/api/categories").json():
|
||||
if g["kind"] == "expense":
|
||||
out += g["categories"]
|
||||
assert len(out) >= n, "zu wenige Ausgabe-Kategorien im Seed"
|
||||
return out[:n]
|
||||
|
||||
|
||||
def _income_cat(admin):
|
||||
for g in admin.get("/api/categories").json():
|
||||
if g["kind"] == "income" and g["categories"]:
|
||||
return g["categories"][0]
|
||||
raise AssertionError("keine Einnahme-Kategorie im Seed")
|
||||
|
||||
|
||||
def _preview_csv(admin, account_id, csv, colmap):
|
||||
r = admin.post(
|
||||
"/api/imports/preview",
|
||||
files={"file": ("k.csv", io.BytesIO(csv.encode("utf-8")), "text/csv")},
|
||||
data={
|
||||
"account_id": str(account_id), "delimiter": ";", "decimal_sep": ",",
|
||||
"date_format": "%d.%m.%Y", "encoding": "utf-8", "has_header": "true",
|
||||
"skip_rows": "0", "amount_mode": "signed", "column_map": colmap,
|
||||
},
|
||||
)
|
||||
assert r.status_code == 200, r.text
|
||||
return r.json()["rows"]
|
||||
|
||||
|
||||
COLMAP = json.dumps({"date": 0, "amount": 1, "payee": 2, "purpose": 3})
|
||||
|
||||
|
||||
def test_keyword_crud_and_conflict(admin):
|
||||
a, b = _expense_cats(admin, 2)
|
||||
r = admin.post(f"/api/categories/{a['id']}/keywords", json={"word": " REWE "})
|
||||
assert r.status_code == 201, r.text
|
||||
assert r.json()["word"] == "rewe" # getrimmt + kleingeschrieben
|
||||
kid = r.json()["id"]
|
||||
|
||||
assert [k["word"] for k in admin.get(f"/api/categories/{a['id']}/keywords").json()] == ["rewe"]
|
||||
|
||||
# Gleiches Wort, gleiche Kategorie -> idempotent, keine Dublette.
|
||||
assert admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "rewe"}).status_code == 201
|
||||
assert len(admin.get(f"/api/categories/{a['id']}/keywords").json()) == 1
|
||||
|
||||
# Gleiches Wort, andere Kategorie -> Konflikt.
|
||||
assert admin.post(f"/api/categories/{b['id']}/keywords", json={"word": "rewe"}).status_code == 409
|
||||
|
||||
assert admin.delete(f"/api/categories/keywords/{kid}").status_code == 204
|
||||
assert admin.get(f"/api/categories/{a['id']}/keywords").json() == []
|
||||
|
||||
|
||||
def test_matching_payee_purpose_and_kind_filter(admin):
|
||||
giro = _account(admin, name="Giro KW")
|
||||
a, _ = _expense_cats(admin, 2)
|
||||
admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "netflix"})
|
||||
|
||||
csv = (
|
||||
"Datum;Betrag;Empfaenger;Zweck\n"
|
||||
"01.03.2026;-9,99;NETFLIX;Abo\n" # Empfänger-Treffer
|
||||
"02.03.2026;-9,99;Kartenzahlung;NETFLIX Monatsabo\n" # Zweck-Treffer (any)
|
||||
"03.03.2026;9,99;NETFLIX;Erstattung\n" # Einnahme -> darf NICHT greifen
|
||||
)
|
||||
rows = _preview_csv(admin, giro["id"], csv, COLMAP)
|
||||
assert rows[0]["category_id"] == a["id"]
|
||||
assert rows[0]["matched_rule_id"] is not None
|
||||
assert rows[1]["category_id"] == a["id"] # über den Zweck getroffen
|
||||
assert rows[2]["category_id"] is None # Ausgabe-Schlagwort, Einnahme -> gefiltert
|
||||
|
||||
|
||||
def test_longest_keyword_wins(admin):
|
||||
giro = _account(admin, name="Giro LW")
|
||||
a, b = _expense_cats(admin, 2)
|
||||
admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "rewe"})
|
||||
admin.post(f"/api/categories/{b['id']}/keywords", json={"word": "rewe getraenke"})
|
||||
|
||||
csv = "Datum;Betrag;Empfaenger;Zweck\n01.03.2026;-20,00;REWE Getraenke Markt;Wasser\n"
|
||||
rows = _preview_csv(admin, giro["id"], csv, COLMAP)
|
||||
assert rows[0]["category_id"] == b["id"] # spezifischeres (längeres) Schlagwort gewinnt
|
||||
|
||||
|
||||
def test_correction_flagging_confirm(admin):
|
||||
giro = _account(admin, name="Giro Flag")
|
||||
a, b = _expense_cats(admin, 2)
|
||||
kw = admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "spotify"}).json()
|
||||
|
||||
lines = "".join(f"0{i}.03.2026;-9,99;SPOTIFY;Abo\n" for i in range(1, 7)) # 6 Zeilen
|
||||
rows = _preview_csv(admin, giro["id"], "Datum;Betrag;Empfaenger;Zweck\n" + lines, COLMAP)
|
||||
assert len(rows) == 6 and all(r["category_id"] == a["id"] for r in rows)
|
||||
|
||||
for r in rows[:2]: # zwei wegkorrigieren
|
||||
r["category_id"] = b["id"]
|
||||
res = admin.post("/api/imports/commit", json={"account_id": giro["id"], "filename": "s.csv", "rows": rows})
|
||||
assert res.status_code == 200, res.text
|
||||
|
||||
flagged = admin.get("/api/categories/keywords/flagged").json()
|
||||
hit = next((f for f in flagged if f["id"] == kw["id"]), None)
|
||||
assert hit is not None, flagged
|
||||
assert hit["applied_count"] == 6 and hit["overridden_count"] == 2
|
||||
|
||||
# „Behalten" unterdrückt die Meldung künftig.
|
||||
assert admin.post(f"/api/categories/keywords/{kw['id']}/confirm").status_code == 204
|
||||
assert kw["id"] not in [f["id"] for f in admin.get("/api/categories/keywords/flagged").json()]
|
||||
|
||||
|
||||
def test_keyword_update_and_conflict(admin):
|
||||
a, b = _expense_cats(admin, 2)
|
||||
kw = admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "lidil"}).json()
|
||||
|
||||
r = admin.patch(f"/api/categories/keywords/{kw['id']}", json={"word": " LIDL "})
|
||||
assert r.status_code == 200, r.text
|
||||
assert r.json()["word"] == "lidl" # getrimmt + kleingeschrieben
|
||||
words = admin.get(f"/api/categories/{a['id']}/keywords").json()
|
||||
assert next(k for k in words if k["id"] == kw["id"])["word"] == "lidl"
|
||||
assert "lidil" not in [k["word"] for k in words] # altes Wort ist weg
|
||||
|
||||
# Umbenennen auf ein Wort, das schon einer anderen Kategorie gehört -> Konflikt.
|
||||
admin.post(f"/api/categories/{b['id']}/keywords", json={"word": "coop"})
|
||||
assert admin.patch(f"/api/categories/keywords/{kw['id']}", json={"word": "coop"}).status_code == 409
|
||||
|
||||
|
||||
def test_below_threshold_not_flagged(admin):
|
||||
giro = _account(admin, name="Giro NoFlag")
|
||||
a, b = _expense_cats(admin, 2)
|
||||
kw = admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "denner"}).json()
|
||||
|
||||
lines = "".join(f"0{i}.03.2026;-4,00;DENNER;Einkauf\n" for i in range(1, 7)) # 6 Zeilen
|
||||
rows = _preview_csv(admin, giro["id"], "Datum;Betrag;Empfaenger;Zweck\n" + lines, COLMAP)
|
||||
rows[0]["category_id"] = b["id"] # nur 1 von 6 korrigiert (< 1/3)
|
||||
admin.post("/api/imports/commit", json={"account_id": giro["id"], "filename": "d.csv", "rows": rows})
|
||||
|
||||
assert kw["id"] not in [f["id"] for f in admin.get("/api/categories/keywords/flagged").json()]
|
||||
|
||||
|
||||
def test_no_retroactive_apply(admin):
|
||||
giro = _account(admin, name="Giro Retro")
|
||||
a, _ = _expense_cats(admin, 2)
|
||||
rows = _preview_csv(admin, giro["id"], "Datum;Betrag;Empfaenger;Zweck\n01.03.2026;-5,00;ALDI;Einkauf\n", COLMAP)
|
||||
assert rows[0]["category_id"] is None
|
||||
admin.post("/api/imports/commit", json={"account_id": giro["id"], "filename": "aldi.csv", "rows": rows})
|
||||
|
||||
admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "aldi"}) # erst danach angelegt
|
||||
|
||||
txns = admin.get("/api/transactions").json()
|
||||
aldi = [t for t in txns if (t.get("payee") or "").upper() == "ALDI"]
|
||||
assert aldi and aldi[0]["category_id"] is None # bestehende Buchung bleibt unkategorisiert
|
||||
@@ -35,3 +35,11 @@ Zeilen-Parser (Datum + Betrag), speist dieselbe Prüfansicht. Best-Effort.
|
||||
## Querschnitt – Backup/Export ✅
|
||||
DB-Backup-Download (Admin) + Export je Entität (CSV/JSON); dokumentierte
|
||||
LXC-Sicherung (docs/BACKUP.md).
|
||||
|
||||
## Querschnitt – Schlagwörter & Kategorie-Auswahl ✅
|
||||
Manuelle Schlagwörter je Kategorie (Popup, Doppelklick zum Bearbeiten); Treffer
|
||||
über Empfänger ODER Verwendungszweck, längstes Schlagwort gewinnt, nur bei
|
||||
künftigen Importen. Korrektur-Erkennung: ab 5 Anwendungen und ≥ 1/3 Korrekturen
|
||||
Prüf-Meldung in den Einstellungen (Behalten/Entfernen). Auf-/zuklappbares
|
||||
Kategorie-Dropdown mit Suche (ersetzt das native optgroup-Select) in Buchungen
|
||||
und Import-Prüfansicht.
|
||||
|
||||
@@ -141,6 +141,14 @@ export const api = {
|
||||
updateCategory: (id, body) => request(`/categories/${id}`, { method: "PATCH", body }),
|
||||
deleteCategory: (id) => request(`/categories/${id}`, { method: "DELETE" }),
|
||||
|
||||
// Schlagwörter je Kategorie (manuelle Auto-Zuordnung) + Prüfmeldungen
|
||||
listKeywords: (categoryId) => request(`/categories/${categoryId}/keywords`),
|
||||
addKeyword: (categoryId, word) => request(`/categories/${categoryId}/keywords`, { method: "POST", body: { word } }),
|
||||
updateKeyword: (ruleId, word) => request(`/categories/keywords/${ruleId}`, { method: "PATCH", body: { word } }),
|
||||
deleteKeyword: (ruleId) => request(`/categories/keywords/${ruleId}`, { method: "DELETE" }),
|
||||
flaggedKeywords: () => request("/categories/keywords/flagged"),
|
||||
confirmKeyword: (ruleId) => request(`/categories/keywords/${ruleId}/confirm`, { method: "POST" }),
|
||||
|
||||
// Transaktionen
|
||||
listTransactions: (params = {}) => {
|
||||
const qs = new URLSearchParams();
|
||||
|
||||
@@ -0,0 +1,198 @@
|
||||
import { useEffect, useMemo, useRef, useState } from "react";
|
||||
import { createPortal } from "react-dom";
|
||||
import { useTranslation } from "react-i18next";
|
||||
import Icon from "./Icon";
|
||||
import IconChip from "./IconChip";
|
||||
|
||||
// Auf-/zuklappbares Kategorie-Dropdown (Gruppe -> Kategorien als Baum) mit
|
||||
// Suchfeld. Ersetzt das native <select> mit optgroup, das die oberste Gruppe
|
||||
// abgesetzt wirken ließ. Das Panel wird per Portal mit fester Position gerendert,
|
||||
// damit es in scrollbaren Tabellen (Import-Prüfansicht) nicht abgeschnitten wird.
|
||||
export default function CategorySelect({
|
||||
groups = [],
|
||||
value,
|
||||
onChange,
|
||||
allowNone = false,
|
||||
noneLabel = "—",
|
||||
placeholder = "—",
|
||||
minWidth = 0,
|
||||
disabled = false,
|
||||
}) {
|
||||
const { t } = useTranslation();
|
||||
const selectedId = value === "" || value == null ? null : Number(value);
|
||||
|
||||
const [open, setOpen] = useState(false);
|
||||
const [q, setQ] = useState("");
|
||||
const [collapsed, setCollapsed] = useState(() => new Set());
|
||||
const [pos, setPos] = useState(null);
|
||||
|
||||
const btnRef = useRef(null);
|
||||
const panelRef = useRef(null);
|
||||
const searchRef = useRef(null);
|
||||
|
||||
const byId = useMemo(() => {
|
||||
const m = {};
|
||||
for (const g of groups) for (const c of g.categories) m[c.id] = c;
|
||||
return m;
|
||||
}, [groups]);
|
||||
const sel = selectedId != null ? byId[selectedId] : null;
|
||||
|
||||
function computePos() {
|
||||
const el = btnRef.current;
|
||||
if (!el) return;
|
||||
const r = el.getBoundingClientRect();
|
||||
const width = Math.max(r.width, 260);
|
||||
const spaceBelow = window.innerHeight - r.bottom;
|
||||
const spaceAbove = r.top;
|
||||
const desired = 340;
|
||||
let top;
|
||||
let maxHeight;
|
||||
if (spaceBelow >= 220 || spaceBelow >= spaceAbove) {
|
||||
maxHeight = Math.min(desired, spaceBelow - 10);
|
||||
top = r.bottom + 4;
|
||||
} else {
|
||||
maxHeight = Math.min(desired, spaceAbove - 10);
|
||||
top = r.top - 4 - maxHeight;
|
||||
}
|
||||
let left = r.left;
|
||||
if (left + width > window.innerWidth - 8) left = window.innerWidth - 8 - width;
|
||||
if (left < 8) left = 8;
|
||||
setPos({ left, top, width, maxHeight });
|
||||
}
|
||||
|
||||
function openPanel() {
|
||||
if (disabled) return;
|
||||
computePos();
|
||||
setQ("");
|
||||
setOpen(true);
|
||||
}
|
||||
|
||||
useEffect(() => {
|
||||
if (!open) return undefined;
|
||||
searchRef.current?.focus();
|
||||
const onDown = (e) => {
|
||||
if (panelRef.current?.contains(e.target) || btnRef.current?.contains(e.target)) return;
|
||||
setOpen(false);
|
||||
};
|
||||
const onKey = (e) => e.key === "Escape" && setOpen(false);
|
||||
const onScrollResize = () => setOpen(false);
|
||||
document.addEventListener("mousedown", onDown);
|
||||
document.addEventListener("keydown", onKey);
|
||||
// capture=true: fängt auch das Scrollen innerhalb der Tabelle ab.
|
||||
window.addEventListener("scroll", onScrollResize, true);
|
||||
window.addEventListener("resize", onScrollResize);
|
||||
return () => {
|
||||
document.removeEventListener("mousedown", onDown);
|
||||
document.removeEventListener("keydown", onKey);
|
||||
window.removeEventListener("scroll", onScrollResize, true);
|
||||
window.removeEventListener("resize", onScrollResize);
|
||||
};
|
||||
}, [open]);
|
||||
|
||||
function choose(id) {
|
||||
onChange(id);
|
||||
setOpen(false);
|
||||
}
|
||||
function toggleGroup(id) {
|
||||
setCollapsed((prev) => {
|
||||
const next = new Set(prev);
|
||||
next.has(id) ? next.delete(id) : next.add(id);
|
||||
return next;
|
||||
});
|
||||
}
|
||||
|
||||
const ql = q.trim().toLowerCase();
|
||||
|
||||
return (
|
||||
<div className="catsel" style={{ minWidth }}>
|
||||
<button
|
||||
type="button"
|
||||
ref={btnRef}
|
||||
className={`catsel-btn${open ? " open" : ""}`}
|
||||
onClick={() => (open ? setOpen(false) : openPanel())}
|
||||
disabled={disabled}
|
||||
>
|
||||
{sel ? (
|
||||
<span className="catsel-value">
|
||||
<IconChip name={sel.icon} color={sel.color} size={22} />
|
||||
<span className="ellipsis">{sel.name}</span>
|
||||
</span>
|
||||
) : (
|
||||
<span className="catsel-value muted ellipsis">{placeholder}</span>
|
||||
)}
|
||||
<Icon name="chevron-down" size={15} className="catsel-caret" />
|
||||
</button>
|
||||
|
||||
{open &&
|
||||
pos &&
|
||||
createPortal(
|
||||
<div
|
||||
ref={panelRef}
|
||||
className="catsel-panel"
|
||||
style={{ left: pos.left, top: pos.top, width: pos.width, maxHeight: pos.maxHeight }}
|
||||
>
|
||||
<div className="catsel-search">
|
||||
<Icon name="search" size={14} />
|
||||
<input
|
||||
ref={searchRef}
|
||||
value={q}
|
||||
onChange={(e) => setQ(e.target.value)}
|
||||
placeholder={t("categories.searchPlaceholder")}
|
||||
/>
|
||||
</div>
|
||||
<div className="catsel-list">
|
||||
{allowNone && (
|
||||
<button
|
||||
type="button"
|
||||
className={`catsel-opt${selectedId == null ? " selected" : ""}`}
|
||||
onClick={() => choose(null)}
|
||||
>
|
||||
<span className="muted ellipsis">{noneLabel}</span>
|
||||
{selectedId == null && <Icon name="check" size={15} className="catsel-check" />}
|
||||
</button>
|
||||
)}
|
||||
{groups.map((g) => {
|
||||
const cats = ql
|
||||
? g.categories.filter((c) => c.name.toLowerCase().includes(ql))
|
||||
: g.categories;
|
||||
if (ql && cats.length === 0) return null;
|
||||
const isCollapsed = !ql && collapsed.has(g.id);
|
||||
return (
|
||||
<div className="catsel-group" key={g.id}>
|
||||
<button
|
||||
type="button"
|
||||
className="catsel-group-head"
|
||||
onClick={() => toggleGroup(g.id)}
|
||||
>
|
||||
<Icon
|
||||
name="chevron-down"
|
||||
size={14}
|
||||
className={`catsel-gchev${isCollapsed ? " collapsed" : ""}`}
|
||||
/>
|
||||
<IconChip name={g.icon} color={g.color} size={18} />
|
||||
<span className="ellipsis">{g.name}</span>
|
||||
</button>
|
||||
{!isCollapsed &&
|
||||
cats.map((c) => (
|
||||
<button
|
||||
type="button"
|
||||
key={c.id}
|
||||
className={`catsel-opt${selectedId === c.id ? " selected" : ""}`}
|
||||
onClick={() => choose(c.id)}
|
||||
>
|
||||
<IconChip name={c.icon} color={c.color} size={20} />
|
||||
<span className="ellipsis">{c.name}</span>
|
||||
{selectedId === c.id && <Icon name="check" size={15} className="catsel-check" />}
|
||||
</button>
|
||||
))}
|
||||
</div>
|
||||
);
|
||||
})}
|
||||
{groups.length === 0 && <div className="catsel-empty muted small">{t("categories.emptyGroup")}</div>}
|
||||
</div>
|
||||
</div>,
|
||||
document.body
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -71,6 +71,14 @@ const PATHS = {
|
||||
</>
|
||||
),
|
||||
"chevron-right": <path d="m9 18 6-6-6-6" />,
|
||||
"chevron-down": <path d="m6 9 6 6 6-6" />,
|
||||
tags: (
|
||||
<>
|
||||
<path d="M9 5H2v7l6.29 6.29c.94.94 2.48.94 3.42 0l3.58-3.58c.94-.94.94-2.48 0-3.42L9 5Z" />
|
||||
<path d="M6 9.01V9" />
|
||||
<path d="m15 5 6.3 6.3a2.4 2.4 0 0 1 0 3.4L17 19" />
|
||||
</>
|
||||
),
|
||||
"refresh-ccw": (
|
||||
<>
|
||||
<path d="M21 12a9 9 0 0 0-9-9 9.75 9.75 0 0 0-6.74 2.74L3 8" />
|
||||
|
||||
@@ -571,3 +571,219 @@ tr.row-dup {
|
||||
border-radius: var(--radius-sm);
|
||||
margin-top: var(--sp-2);
|
||||
}
|
||||
|
||||
/* ---------- Kategorie-Auswahl (auf-/zuklappbarer Baum, Ersatz für <select>) ---------- */
|
||||
.catsel {
|
||||
width: 100%;
|
||||
}
|
||||
.catsel-btn {
|
||||
width: 100%;
|
||||
margin-top: 5px;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: var(--sp-2);
|
||||
padding: 7px 10px;
|
||||
border: 1px solid var(--border-strong);
|
||||
border-radius: var(--radius-sm);
|
||||
background: var(--surface);
|
||||
color: var(--text);
|
||||
font: inherit;
|
||||
text-align: left;
|
||||
cursor: pointer;
|
||||
transition: border-color .12s, box-shadow .12s;
|
||||
}
|
||||
.catsel-btn:hover:not(:disabled) {
|
||||
border-color: var(--accent);
|
||||
}
|
||||
.catsel-btn:disabled {
|
||||
opacity: 0.6;
|
||||
cursor: default;
|
||||
}
|
||||
.catsel-btn.open {
|
||||
border-color: var(--accent);
|
||||
box-shadow: 0 0 0 3px var(--accent-soft);
|
||||
}
|
||||
.catsel-value {
|
||||
flex: 1 1 auto;
|
||||
min-width: 0;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: var(--sp-2);
|
||||
}
|
||||
.catsel-caret {
|
||||
flex: 0 0 auto;
|
||||
color: var(--muted);
|
||||
}
|
||||
|
||||
.catsel-panel {
|
||||
position: fixed;
|
||||
z-index: 1000;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
background: var(--surface);
|
||||
border: 1px solid var(--border-strong);
|
||||
border-radius: var(--radius);
|
||||
box-shadow: 0 8px 24px rgba(0, 0, 0, 0.18);
|
||||
overflow: hidden;
|
||||
}
|
||||
.catsel-search {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: var(--sp-2);
|
||||
padding: 8px 10px;
|
||||
border-bottom: 1px solid var(--border);
|
||||
color: var(--muted);
|
||||
flex: 0 0 auto;
|
||||
}
|
||||
.catsel-search input {
|
||||
width: 100%;
|
||||
border: none;
|
||||
background: none;
|
||||
outline: none;
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
color: var(--text);
|
||||
font: inherit;
|
||||
}
|
||||
.catsel-list {
|
||||
overflow-y: auto;
|
||||
padding: 5px;
|
||||
}
|
||||
.catsel-group + .catsel-group {
|
||||
margin-top: 2px;
|
||||
}
|
||||
.catsel-group-head {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 6px;
|
||||
width: 100%;
|
||||
padding: 6px;
|
||||
border: none;
|
||||
background: none;
|
||||
cursor: pointer;
|
||||
color: var(--muted);
|
||||
font-weight: 650;
|
||||
font-size: 0.72rem;
|
||||
text-transform: uppercase;
|
||||
letter-spacing: 0.03em;
|
||||
}
|
||||
.catsel-group-head:hover {
|
||||
color: var(--text);
|
||||
}
|
||||
.catsel-gchev {
|
||||
flex: 0 0 auto;
|
||||
transition: transform .12s ease;
|
||||
}
|
||||
.catsel-gchev.collapsed {
|
||||
transform: rotate(-90deg);
|
||||
}
|
||||
.catsel-opt {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: var(--sp-2);
|
||||
width: 100%;
|
||||
padding: 6px 8px 6px 22px;
|
||||
border: none;
|
||||
border-radius: var(--radius-sm);
|
||||
background: none;
|
||||
color: var(--text);
|
||||
font: inherit;
|
||||
text-align: left;
|
||||
cursor: pointer;
|
||||
}
|
||||
.catsel-opt:hover {
|
||||
background: var(--surface-2);
|
||||
}
|
||||
.catsel-opt.selected {
|
||||
background: var(--accent-soft);
|
||||
color: var(--accent);
|
||||
font-weight: 600;
|
||||
}
|
||||
.catsel-check {
|
||||
margin-left: auto;
|
||||
flex: 0 0 auto;
|
||||
color: var(--accent);
|
||||
}
|
||||
.catsel-empty {
|
||||
padding: 10px;
|
||||
}
|
||||
|
||||
/* ---------- Schlagwörter (Kategorie-Popup + Prüfmeldungen) ---------- */
|
||||
.kw-add {
|
||||
display: flex;
|
||||
gap: var(--sp-2);
|
||||
margin-bottom: var(--sp-3);
|
||||
}
|
||||
.kw-add input {
|
||||
flex: 1 1 auto;
|
||||
min-width: 0;
|
||||
margin-top: 0;
|
||||
}
|
||||
.kw-chips {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: var(--sp-2);
|
||||
}
|
||||
.kw-chip {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: 6px;
|
||||
padding: 4px 6px 4px 11px;
|
||||
border-radius: 20px;
|
||||
background: var(--surface-2);
|
||||
border: 1px solid var(--border);
|
||||
font-size: 0.85rem;
|
||||
}
|
||||
.kw-chip button {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
width: 18px;
|
||||
height: 18px;
|
||||
padding: 0;
|
||||
margin: 0;
|
||||
border: none;
|
||||
border-radius: 50%;
|
||||
background: none;
|
||||
color: var(--muted);
|
||||
cursor: pointer;
|
||||
}
|
||||
.kw-chip button:hover {
|
||||
background: var(--danger);
|
||||
color: #fff;
|
||||
}
|
||||
.kw-chip.editing {
|
||||
padding: 2px 6px;
|
||||
border-color: var(--accent);
|
||||
box-shadow: 0 0 0 2px var(--accent-soft);
|
||||
}
|
||||
.kw-chip.editing input {
|
||||
width: 12ch;
|
||||
min-width: 70px;
|
||||
margin: 0;
|
||||
padding: 2px 2px;
|
||||
border: none;
|
||||
background: none;
|
||||
outline: none;
|
||||
font: inherit;
|
||||
font-size: 0.85rem;
|
||||
color: var(--text);
|
||||
}
|
||||
|
||||
.kw-flag {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: var(--sp-3);
|
||||
padding: var(--sp-3) 0;
|
||||
border-bottom: 1px solid var(--border);
|
||||
}
|
||||
.kw-flag:last-child {
|
||||
border-bottom: none;
|
||||
}
|
||||
.kw-flag-main {
|
||||
flex: 1;
|
||||
min-width: 0;
|
||||
}
|
||||
.kw-flag-word {
|
||||
font-weight: 600;
|
||||
}
|
||||
|
||||
+14
-2
@@ -79,7 +79,12 @@
|
||||
"exportTxnJson": "Buchungen (JSON)",
|
||||
"exportAll": "Alle Daten (JSON)",
|
||||
"dbBackup": "Komplettes DB-Backup herunterladen",
|
||||
"dbBackupHint": "Vollständige Datenbank aller Nutzer (nur Admin) – zum Wiederherstellen sichern."
|
||||
"dbBackupHint": "Vollständige Datenbank aller Nutzer (nur Admin) – zum Wiederherstellen sichern.",
|
||||
"keywordReview": "Schlagwörter prüfen",
|
||||
"keywordReviewHint": "Diese Schlagwörter werden auffällig oft wieder wegkorrigiert – stimmen sie vielleicht nicht mehr?",
|
||||
"keywordCorrected": "{{overridden}} von {{applied}} Buchungen korrigiert",
|
||||
"keep": "Behalten",
|
||||
"remove": "Entfernen"
|
||||
},
|
||||
"dashboard": {
|
||||
"title": "Übersicht",
|
||||
@@ -153,7 +158,14 @@
|
||||
"expense": "Ausgabe",
|
||||
"emptyGroup": "Keine Kategorien in dieser Gruppe.",
|
||||
"deleteConfirm": "Diese Kategorie löschen?",
|
||||
"deleteGroupConfirm": "Diese Gruppe samt aller Kategorien löschen?"
|
||||
"deleteGroupConfirm": "Diese Gruppe samt aller Kategorien löschen?",
|
||||
"keywordsBtn": "Schlagwörter",
|
||||
"keywordsTitle": "Schlagwörter – {{name}}",
|
||||
"keywordsHint": "Buchungen, die eines dieser Wörter im Empfänger oder Verwendungszweck enthalten, werden bei künftigen Importen automatisch dieser Kategorie zugeordnet.",
|
||||
"keywordAdd": "Wort eingeben und Enter",
|
||||
"keywordEmpty": "Noch keine Schlagwörter.",
|
||||
"keywordEditHint": "Doppelklick auf ein Schlagwort, um es zu bearbeiten.",
|
||||
"searchPlaceholder": "Kategorie suchen …"
|
||||
},
|
||||
"transactions": {
|
||||
"title": "Buchungen",
|
||||
|
||||
+14
-2
@@ -79,7 +79,12 @@
|
||||
"exportTxnJson": "Transactions (JSON)",
|
||||
"exportAll": "All data (JSON)",
|
||||
"dbBackup": "Download full DB backup",
|
||||
"dbBackupHint": "Complete database of all users (admin only) — keep it for restore."
|
||||
"dbBackupHint": "Complete database of all users (admin only) — keep it for restore.",
|
||||
"keywordReview": "Review keywords",
|
||||
"keywordReviewHint": "These keywords keep getting corrected away — maybe they no longer fit?",
|
||||
"keywordCorrected": "{{overridden}} of {{applied}} transactions corrected",
|
||||
"keep": "Keep",
|
||||
"remove": "Remove"
|
||||
},
|
||||
"dashboard": {
|
||||
"title": "Overview",
|
||||
@@ -153,7 +158,14 @@
|
||||
"expense": "Expense",
|
||||
"emptyGroup": "No categories in this group.",
|
||||
"deleteConfirm": "Delete this category?",
|
||||
"deleteGroupConfirm": "Delete this group and all its categories?"
|
||||
"deleteGroupConfirm": "Delete this group and all its categories?",
|
||||
"keywordsBtn": "Keywords",
|
||||
"keywordsTitle": "Keywords – {{name}}",
|
||||
"keywordsHint": "Transactions whose payee or description contains one of these words are automatically assigned to this category on future imports.",
|
||||
"keywordAdd": "Type a word and press Enter",
|
||||
"keywordEmpty": "No keywords yet.",
|
||||
"keywordEditHint": "Double-click a keyword to edit it.",
|
||||
"searchPlaceholder": "Search category …"
|
||||
},
|
||||
"transactions": {
|
||||
"title": "Transactions",
|
||||
|
||||
@@ -8,12 +8,141 @@ import IconChip from "../components/IconChip";
|
||||
import Modal from "../components/Modal";
|
||||
import IconPicker, { CATEGORY_ICONS } from "../components/IconPicker";
|
||||
|
||||
// Popup zum Pflegen der Schlagwörter einer Kategorie. Wörter werden beim Import
|
||||
// gegen Empfänger/Verwendungszweck geprüft und ordnen Buchungen automatisch zu.
|
||||
function KeywordModal({ category, onClose }) {
|
||||
const { t } = useTranslation();
|
||||
const toast = useToast();
|
||||
const [words, setWords] = useState([]);
|
||||
const [input, setInput] = useState("");
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [editId, setEditId] = useState(null);
|
||||
const [editVal, setEditVal] = useState("");
|
||||
|
||||
async function laden() {
|
||||
try { setWords(await api.listKeywords(category.id)); }
|
||||
catch (err) { toast(err.message, "error"); }
|
||||
}
|
||||
useEffect(() => { laden(); }, [category.id]);
|
||||
|
||||
async function hinzufuegen() {
|
||||
const w = input.trim();
|
||||
if (!w) return;
|
||||
setBusy(true);
|
||||
try {
|
||||
await api.addKeyword(category.id, w);
|
||||
setInput("");
|
||||
await laden();
|
||||
} catch (err) {
|
||||
toast(err.message, "error");
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
async function entfernen(id) {
|
||||
try {
|
||||
await api.deleteKeyword(id);
|
||||
setWords((ws) => ws.filter((x) => x.id !== id));
|
||||
} catch (err) {
|
||||
toast(err.message, "error");
|
||||
}
|
||||
}
|
||||
|
||||
function starteBearbeiten(w) {
|
||||
setEditId(w.id);
|
||||
setEditVal(w.word);
|
||||
}
|
||||
function abbrechenBearbeiten() {
|
||||
setEditId(null);
|
||||
setEditVal("");
|
||||
}
|
||||
async function speichernBearbeiten(id) {
|
||||
const val = editVal.trim();
|
||||
const orig = words.find((x) => x.id === id);
|
||||
if (!val || (orig && val === orig.word)) { abbrechenBearbeiten(); return; }
|
||||
try {
|
||||
await api.updateKeyword(id, val);
|
||||
abbrechenBearbeiten();
|
||||
await laden();
|
||||
} catch (err) {
|
||||
toast(err.message, "error");
|
||||
abbrechenBearbeiten();
|
||||
await laden();
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<Modal
|
||||
title={t("categories.keywordsTitle", { name: category.name })}
|
||||
onClose={onClose}
|
||||
footer={<button className="btn primary" onClick={onClose}>{t("common.close")}</button>}
|
||||
>
|
||||
<p className="muted small" style={{ marginTop: 0 }}>{t("categories.keywordsHint")}</p>
|
||||
<div className="kw-add">
|
||||
{/* eslint-disable-next-line jsx-a11y/no-autofocus */}
|
||||
<input
|
||||
autoFocus
|
||||
value={input}
|
||||
placeholder={t("categories.keywordAdd")}
|
||||
onChange={(e) => setInput(e.target.value)}
|
||||
onKeyDown={(e) => { if (e.key === "Enter") { e.preventDefault(); hinzufuegen(); } }}
|
||||
/>
|
||||
<button className="btn" onClick={hinzufuegen} disabled={busy || !input.trim()}>
|
||||
<Icon name="plus" size={15} />
|
||||
</button>
|
||||
</div>
|
||||
{words.length === 0 ? (
|
||||
<div className="muted small">{t("categories.keywordEmpty")}</div>
|
||||
) : (
|
||||
<>
|
||||
<div className="kw-chips">
|
||||
{words.map((w) =>
|
||||
editId === w.id ? (
|
||||
<span className="kw-chip editing" key={w.id}>
|
||||
{/* eslint-disable-next-line jsx-a11y/no-autofocus */}
|
||||
<input
|
||||
autoFocus
|
||||
value={editVal}
|
||||
onFocus={(e) => e.target.select()}
|
||||
onChange={(e) => setEditVal(e.target.value)}
|
||||
onKeyDown={(e) => {
|
||||
if (e.key === "Enter") { e.preventDefault(); speichernBearbeiten(w.id); }
|
||||
else if (e.key === "Escape") { e.preventDefault(); abbrechenBearbeiten(); }
|
||||
}}
|
||||
onBlur={() => speichernBearbeiten(w.id)}
|
||||
/>
|
||||
</span>
|
||||
) : (
|
||||
<span
|
||||
className="kw-chip"
|
||||
key={w.id}
|
||||
title={t("categories.keywordEditHint")}
|
||||
onDoubleClick={() => starteBearbeiten(w)}
|
||||
>
|
||||
{w.word}
|
||||
<button type="button" title={t("common.delete")} onClick={() => entfernen(w.id)}>
|
||||
<Icon name="close" size={13} />
|
||||
</button>
|
||||
</span>
|
||||
)
|
||||
)}
|
||||
</div>
|
||||
<p className="muted small" style={{ marginTop: "var(--sp-2)", marginBottom: 0 }}>
|
||||
{t("categories.keywordEditHint")}
|
||||
</p>
|
||||
</>
|
||||
)}
|
||||
</Modal>
|
||||
);
|
||||
}
|
||||
|
||||
export default function Categories() {
|
||||
const { t } = useTranslation();
|
||||
const confirm = useConfirm();
|
||||
const toast = useToast();
|
||||
const [groups, setGroups] = useState([]);
|
||||
const [modal, setModal] = useState(null); // {type:'group'|'category', editing, groupId, form}
|
||||
const [keywordCat, setKeywordCat] = useState(null); // Kategorie fürs Schlagwort-Popup
|
||||
|
||||
async function laden() {
|
||||
try {
|
||||
@@ -103,6 +232,9 @@ export default function Categories() {
|
||||
<div className="cat-row" key={c.id}>
|
||||
<IconChip name={c.icon} color={c.color} size={28} />
|
||||
<span className="grow">{c.name}</span>
|
||||
<button className="btn sm ghost" title={t("categories.keywordsBtn")} onClick={() => setKeywordCat(c)}>
|
||||
<Icon name="tags" size={14} />
|
||||
</button>
|
||||
<button className="btn sm ghost" title={t("common.edit")} onClick={() => openCategory(g.id, c)}>
|
||||
<Icon name="edit" size={14} />
|
||||
</button>
|
||||
@@ -164,6 +296,8 @@ export default function Categories() {
|
||||
</form>
|
||||
</Modal>
|
||||
)}
|
||||
|
||||
{keywordCat && <KeywordModal category={keywordCat} onClose={() => setKeywordCat(null)} />}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -5,6 +5,7 @@ import { useSettings } from "../settings";
|
||||
import { useConfirm } from "../confirm";
|
||||
import { useToast } from "../toast";
|
||||
import Icon from "../components/Icon";
|
||||
import CategorySelect from "../components/CategorySelect";
|
||||
import { formatMoney } from "../format";
|
||||
|
||||
const DATE_FORMATS = [
|
||||
@@ -421,14 +422,15 @@ export default function Import() {
|
||||
{accounts.filter((a) => a.id !== Number(accountId)).map((a) => <option key={a.id} value={a.id}>{a.name}</option>)}
|
||||
</select>
|
||||
) : (
|
||||
<select value={r.category_id || ""} onChange={(e) => updateRow(idx, { category_id: e.target.value ? Number(e.target.value) : null })} style={{ minWidth: 150 }}>
|
||||
<option value="">{t("transactions.uncategorized")}</option>
|
||||
{(r.type === "income" ? incomeGroups : expenseGroups).map((g) => (
|
||||
<optgroup key={g.id} label={g.name}>
|
||||
{g.categories.map((c) => <option key={c.id} value={c.id}>{c.name}</option>)}
|
||||
</optgroup>
|
||||
))}
|
||||
</select>
|
||||
<CategorySelect
|
||||
groups={r.type === "income" ? incomeGroups : expenseGroups}
|
||||
value={r.category_id || ""}
|
||||
onChange={(id) => updateRow(idx, { category_id: id != null ? Number(id) : null })}
|
||||
allowNone
|
||||
noneLabel={t("transactions.uncategorized")}
|
||||
placeholder={t("transactions.uncategorized")}
|
||||
minWidth={180}
|
||||
/>
|
||||
)}
|
||||
</td>
|
||||
</tr>
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import { useEffect, useState } from "react";
|
||||
import { useTranslation } from "react-i18next";
|
||||
import { useSettings } from "../settings";
|
||||
import { useAuth } from "../auth";
|
||||
@@ -10,6 +11,22 @@ export default function Settings() {
|
||||
const s = useSettings();
|
||||
const { isAdmin } = useAuth();
|
||||
const toast = useToast();
|
||||
const [flagged, setFlagged] = useState([]);
|
||||
|
||||
async function ladenFlagged() {
|
||||
try { setFlagged(await api.flaggedKeywords()); }
|
||||
catch { /* still ignorieren – nicht kritisch für die Einstellungen */ }
|
||||
}
|
||||
useEffect(() => { ladenFlagged(); }, []);
|
||||
|
||||
async function keywordBehalten(id) {
|
||||
try { await api.confirmKeyword(id); setFlagged((f) => f.filter((x) => x.id !== id)); }
|
||||
catch (err) { toast(err.message, "error"); }
|
||||
}
|
||||
async function keywordEntfernen(id) {
|
||||
try { await api.deleteKeyword(id); setFlagged((f) => f.filter((x) => x.id !== id)); }
|
||||
catch (err) { toast(err.message, "error"); }
|
||||
}
|
||||
|
||||
async function set(key, value) {
|
||||
try {
|
||||
@@ -32,6 +49,30 @@ export default function Settings() {
|
||||
<div>
|
||||
<h1>{t("settings.title")}</h1>
|
||||
|
||||
{flagged.length > 0 && (
|
||||
<div className="card" style={{ maxWidth: 520, marginBottom: "var(--sp-4)", borderColor: "var(--danger)" }}>
|
||||
<h2 style={{ display: "flex", alignItems: "center", gap: "var(--sp-2)", marginTop: 0 }}>
|
||||
<Icon name="alert" size={18} /> {t("settings.keywordReview")}
|
||||
</h2>
|
||||
<p className="muted small">{t("settings.keywordReviewHint")}</p>
|
||||
{flagged.map((f) => (
|
||||
<div className="kw-flag" key={f.id}>
|
||||
<div className="kw-flag-main">
|
||||
<div className="ellipsis">
|
||||
<span className="kw-flag-word">{f.word}</span>
|
||||
<Icon name="chevron-right" size={12} /> {f.category_name}
|
||||
</div>
|
||||
<div className="muted small">
|
||||
{t("settings.keywordCorrected", { overridden: f.overridden_count, applied: f.applied_count })}
|
||||
</div>
|
||||
</div>
|
||||
<button className="btn sm" onClick={() => keywordBehalten(f.id)}>{t("settings.keep")}</button>
|
||||
<button className="btn sm danger" onClick={() => keywordEntfernen(f.id)}>{t("settings.remove")}</button>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
|
||||
<div className="card" style={{ maxWidth: 520 }}>
|
||||
<label>
|
||||
<span>{t("settings.baseCurrency")}</span>
|
||||
|
||||
@@ -8,6 +8,7 @@ import Icon from "../components/Icon";
|
||||
import IconChip from "../components/IconChip";
|
||||
import Money from "../components/Money";
|
||||
import Modal from "../components/Modal";
|
||||
import CategorySelect from "../components/CategorySelect";
|
||||
import { centsToInput, parseAmountToCents, todayIso } from "../format";
|
||||
|
||||
const TYPES = ["expense", "income", "transfer"];
|
||||
@@ -321,14 +322,14 @@ export default function Transactions() {
|
||||
) : (
|
||||
<label>
|
||||
<span>{t("transactions.category")}</span>
|
||||
<select value={form.category_id} onChange={(e) => setForm({ ...form, category_id: e.target.value })}>
|
||||
<option value="">{t("transactions.uncategorized")}</option>
|
||||
{catOptions.map((g) => (
|
||||
<optgroup key={g.id} label={g.name}>
|
||||
{g.categories.map((c) => <option key={c.id} value={c.id}>{c.name}</option>)}
|
||||
</optgroup>
|
||||
))}
|
||||
</select>
|
||||
<CategorySelect
|
||||
groups={catOptions}
|
||||
value={form.category_id}
|
||||
onChange={(id) => setForm({ ...form, category_id: id != null ? String(id) : "" })}
|
||||
allowNone
|
||||
noneLabel={t("transactions.uncategorized")}
|
||||
placeholder={t("transactions.uncategorized")}
|
||||
/>
|
||||
</label>
|
||||
)}
|
||||
|
||||
@@ -357,13 +358,12 @@ export default function Transactions() {
|
||||
{form.budget_as_expense && (
|
||||
<label>
|
||||
<span>{t("transactions.budgetCategory")}</span>
|
||||
<select value={form.budget_category_id} onChange={(e) => setForm({ ...form, budget_category_id: e.target.value })}>
|
||||
{expenseGroups.map((g) => (
|
||||
<optgroup key={g.id} label={g.name}>
|
||||
{g.categories.map((c) => <option key={c.id} value={c.id}>{c.name}</option>)}
|
||||
</optgroup>
|
||||
))}
|
||||
</select>
|
||||
<CategorySelect
|
||||
groups={expenseGroups}
|
||||
value={form.budget_category_id}
|
||||
onChange={(id) => setForm({ ...form, budget_category_id: id != null ? String(id) : "" })}
|
||||
placeholder={t("transactions.budgetCategory")}
|
||||
/>
|
||||
</label>
|
||||
)}
|
||||
</div>
|
||||
|
||||
Reference in New Issue
Block a user