Gruppen: Obergruppen + Mindestbestaende nur noch je Lagerort (Backend)

Zwei zusammenhaengende Umbauten, weil sie dieselben Stellen betreffen.

Obergruppen: Gruppen bilden jetzt einen gerichteten azyklischen Graphen statt
einer flachen Liste. Eine Gruppe darf unter MEHREREN Obergruppen haengen -
"Grillwurst" unter "Wurst" UND unter "Grillgut"; mit einem einzelnen parent_id
waere genau das nicht abbildbar. Bestand und Mindestbestand einer Gruppe zaehlen
den gesamten Untergraphen, wobei eine ueber zwei Wege erreichbare Untergruppe
nur einmal zaehlt (services/gruppen.py arbeitet durchgaengig mit Mengen).
Product.group_id bleibt unveraendert - ein Artikel haengt weiter an genau einer
Gruppe.

Mindestbestaende: der separate Gesamt-Mindestbestand entfaellt. Er wird zur
Zeile mit location_id NULL ("Ueberall") und ist damit die Wurzel ueber allen
Lagerorten - dieselbe Verrechnung wie bei verschachtelten Orten greift jetzt
auch zwischen Ueberall und Kueche, wodurch derselbe Artikel nicht mehr doppelt
in der Einkaufsliste steht. Alle Werte liegen einheitlich in Basiseinheiten
statt in drei verschiedenen Einheiten nebeneinander; das Umrechnen beim
Umschalten der Erfassungseinheit entfaellt dadurch ersatzlos.

_netted_topups nimmt die Hierarchie jetzt als Parameter und faltet damit
Lagerort-Baum und Gruppen-Graph. Verrechnet wird zwischen zwei Gruppen nur,
wenn die zaehlenden Artikel der Untergruppe eine Teilmenge der Obergruppe sind -
zaehlt die Obergruppe in Kilogramm und die Untergruppe in Stueck, kommt ein Kauf
dort oben nicht an.

Die vierfach kopierte Bestandssumme wandert in Sammelabfragen
(summe_bestand_base), sonst vervielfacht der transitive Teilgraph die Abfragen.

Einmalige Datenwanderung beim Start (Merker in den Einstellungen), 18 neue
Tests - darunter Doppelzaehlung ueber zwei Wege, Ringschutz und die bewusst
offene Grenze bei zwei Obergruppen mit gemeinsamer Untergruppe.

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

backend/app/services/conversion.py

@@ -13,6 +13,7 @@ from sqlalchemy import func
 from sqlalchemy.orm import Session
 
 from ..models import BaseUnit, Group, Product, Unit, UnitKind
+from . import gruppen
 
 BASE_OF_KIND: dict[UnitKind, BaseUnit] = {
     UnitKind.count: BaseUnit.piece,
@@ -127,14 +128,21 @@ def group_min_context(group: Group) -> GroupMinContext:
     ein Gruppen-Gebinde definiert und aktiv ist – in ganzen Packungen. Die
     Packungsgroesse ist ein **Richtwert der Gruppe** (nicht die der einzelnen
     Produkte), weil deren Packungen unterschiedlich gross sein koennen.
+
+    ``matching`` umfasst die Artikel der Gruppe UND ihrer Untergruppen
+    (transitiv): „Wurst" zaehlt Wurst, Grillwurst, Salami und alles darunter.
+    Die Einheiten-Filterung der OBERgruppe gilt dabei fuer den ganzen
+    Teilgraphen – zaehlt „Wurst" in Kilogramm, bleiben stueckweise gefuehrte
+    Artikel einer Untergruppe aussen vor, genau wie ein direkt zugeordneter.
     """
+    alle = gruppen.produkte(group)  # inkl. Untergruppen, ohne Dubletten
     unit = group.min_stock_unit
     if unit is not None:
         base = BASE_OF_KIND[unit.kind]
-        matching = [p for p in group.products if p.base_unit == base]
+        matching = [p for p in alle if p.base_unit == base]
         base_unit: BaseUnit | None = base
     else:
-        matching = list(group.products)
+        matching = alle
         base_unit = None
     if group.min_stock_in_packages and group.package_size and group.package_size > 0:
         return GroupMinContext(

backend/app/services/gruppen.py

@@ -0,0 +1,71 @@
+"""Der Gruppen-Graph: Ober- und Untergruppen.
+
+Anders als Kategorien und Lagerorte bilden Gruppen KEINEN Baum: „Grillwurst"
+haengt unter „Wurst" UND unter „Grillgut" – mit einem einzelnen ``parent_id``
+waere genau das nicht abbildbar. Die Struktur ist deshalb ein gerichteter
+azyklischer Graph.
+
+Daraus folgt die eine Regel, an der hier alles haengt: Auswertungen laufen ueber
+MENGEN, nicht ueber Baum-Walks. Eine ueber zwei Wege erreichbare Untergruppe
+wuerde sonst doppelt zaehlen und den Bestand ihrer Obergruppe verfaelschen.
+
+Jede Funktion schuetzt sich zusaetzlich mit einem ``gesehen``-Set gegen Ringe.
+Ueber die API kann keiner entstehen (Pruefung in routers/groups.py), eine
+eingespielte Sicherung kann aber einen mitbringen – und ein Ring wuerde jede
+Auswertung endlos laufen lassen. Gleiche Vorsichtsmassnahme wie in
+routers/categories.py.
+"""
+
+from __future__ import annotations
+
+from ..models import Group, Product
+
+
+def teilgraph(group: Group) -> list[Group]:
+    """Die Gruppe samt ALLEN Untergruppen (transitiv), jede genau einmal."""
+    gesehen: set[int] = set()
+    ergebnis: list[Group] = []
+    offen = [group]
+    while offen:
+        aktuell = offen.pop()
+        if aktuell.id in gesehen:
+            continue  # ueber zwei Wege erreichbar ODER Ring in den Daten
+        gesehen.add(aktuell.id)
+        ergebnis.append(aktuell)
+        offen.extend(aktuell.children)
+    return ergebnis
+
+
+def nachfahren_ids(group: Group) -> set[int]:
+    """IDs aller Untergruppen (transitiv, ohne die Gruppe selbst)."""
+    return {g.id for g in teilgraph(group)} - {group.id}
+
+
+def vorfahren_ids(group: Group) -> set[int]:
+    """IDs aller Obergruppen (transitiv, ohne die Gruppe selbst)."""
+    gesehen: set[int] = set()
+    offen = list(group.parents)
+    while offen:
+        aktuell = offen.pop()
+        if aktuell.id in gesehen:
+            continue
+        gesehen.add(aktuell.id)
+        offen.extend(aktuell.parents)
+    return gesehen
+
+
+def produkte(group: Group) -> list[Product]:
+    """Alle Artikel der Gruppe UND ihrer Untergruppen – jeder genau einmal.
+
+    Ein Artikel haengt an genau einer Gruppe (``Product.group_id``), die
+    Entdopplung greift also schon auf Gruppenebene. Der Artikel-Check bleibt
+    trotzdem stehen: er kostet nichts und macht die Absicht sichtbar.
+    """
+    gesehen: set[int] = set()
+    ergebnis: list[Product] = []
+    for g in teilgraph(group):
+        for p in g.products:
+            if p.id not in gesehen:
+                gesehen.add(p.id)
+                ergebnis.append(p)
+    return ergebnis

backend/app/services/min_stock.py

@@ -0,0 +1,151 @@
+"""Mindestbestaende: „Ueberall" als Ort und die einmalige Datenwanderung.
+
+Mindestbestaende haengen ausschliesslich an Lagerorten. Der frueher separate
+Gesamt-Mindestbestand (``Product.min_stock`` / ``Group.min_stock``) ist jetzt
+eine Zeile mit ``location_id = NULL`` – „Ueberall": egal wo, Hauptsache die
+Menge ist im Haus. Damit ist Ueberall die Wurzel ueber allen Lagerorten und
+wird von derselben Verrechnung erfasst wie verschachtelte Orte.
+
+Alle Mengen stehen in BASISEINHEITEN. Vorher waren es drei verschiedene
+Einheiten nebeneinander (Gesamt in Basiseinheiten, je Ort in Artikeleinheiten,
+Gruppen in der Gruppen-Erfassungseinheit) – das machte jede Umrechnung zur
+Fehlerquelle und liess gespeicherte Werte ihre Bedeutung aendern, sobald sich
+eine Packungsgroesse aenderte.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from sqlalchemy.orm import Session
+
+from ..models import (
+    Group,
+    GroupLocationMinStock,
+    Product,
+    ProductLocationMinStock,
+    Setting,
+)
+from .conversion import article_unit, group_min_context
+
+#: Anzeigename des Ortes NULL – hier und in der Oberflaeche derselbe Begriff.
+UEBERALL_NAME = "Überall"
+
+#: Merker, dass die Datenwanderung gelaufen ist. Schritt 1 (Umrechnen der
+#: vorhandenen Werte) waere sonst nicht wiederholungsfest.
+MIGRATION_KEY = "min_stock_basis_v2"
+
+
+def lies_ueberall(eintraege: Iterable) -> float | None:
+    """Der „Ueberall"-Mindestbestand (Ort NULL) aus den Ort-Eintraegen.
+
+    Ersetzt die frueheren Spalten ``Product.min_stock``/``Group.min_stock``.
+    Ergebnis in Basiseinheiten; ``None`` = kein Ueberall-Bedarf hinterlegt.
+    """
+    for e in eintraege:
+        if e.location_id is None:
+            return e.min_stock
+    return None
+
+
+def schreibe_ueberall(db: Session, besitzer, wert: float | None) -> None:
+    """Den „Ueberall"-Mindestbestand setzen oder (bei None/0) entfernen.
+
+    ``besitzer`` ist ein ``Product`` oder eine ``Group`` – beide haben eine
+    ``location_min_stocks``-Beziehung mit derselben Form. Menge in
+    Basiseinheiten.
+    """
+    vorhanden = next(
+        (e for e in besitzer.location_min_stocks if e.location_id is None), None
+    )
+    if wert is None or wert <= 0:
+        if vorhanden is not None:
+            besitzer.location_min_stocks.remove(vorhanden)
+        return
+    if vorhanden is not None:
+        vorhanden.min_stock = wert
+        return
+    if isinstance(besitzer, Product):
+        neu = ProductLocationMinStock(
+            product_id=besitzer.id, location_id=None, min_stock=wert
+        )
+    else:
+        neu = GroupLocationMinStock(
+            group_id=besitzer.id, location_id=None, min_stock=wert
+        )
+    besitzer.location_min_stocks.append(neu)
+
+
+def migriere_mindestbestaende(db: Session) -> None:
+    """Einmalig: Gesamt-Werte zu „Ueberall" machen, alles in Basiseinheiten.
+
+    Laeuft beim Start (siehe main.py) und tut beim zweiten Mal nichts mehr.
+    """
+    if db.get(Setting, MIGRATION_KEY) is not None:
+        return
+
+    # 1. Bestehende Ort-Zeilen umrechnen: Artikel- bzw. Gruppeneinheit ->
+    #    Basiseinheiten. Der einzige Schritt, der bei doppelter Ausfuehrung
+    #    falsche Werte erzeugen wuerde – daher der Merker unten.
+    for eintrag in db.query(ProductLocationMinStock).all():
+        product = db.get(Product, eintrag.product_id)
+        if product is None:
+            continue
+        faktor, _ = article_unit(product)
+        eintrag.min_stock = eintrag.min_stock * (faktor or 1.0)
+
+    for eintrag in db.query(GroupLocationMinStock).all():
+        group = db.get(Group, eintrag.group_id)
+        if group is None:
+            continue
+        eintrag.min_stock = eintrag.min_stock * (group_min_context(group).divisor or 1.0)
+
+    # 2. Artikel-Gesamtwerte werden zur Ueberall-Zeile. ``Product.min_stock``
+    #    stand bereits in Basiseinheiten, also keine Umrechnung.
+    artikel = (
+        db.query(Product)
+        .filter(Product.min_stock.isnot(None), Product.min_stock > 0)
+        .all()
+    )
+    for product in artikel:
+        schon_da = (
+            db.query(ProductLocationMinStock)
+            .filter(
+                ProductLocationMinStock.product_id == product.id,
+                ProductLocationMinStock.location_id.is_(None),
+            )
+            .first()
+        )
+        if schon_da is None:
+            db.add(
+                ProductLocationMinStock(
+                    product_id=product.id, location_id=None, min_stock=product.min_stock
+                )
+            )
+        product.min_stock = None
+
+    # 3. Gruppen-Gesamtwerte genauso – die stehen in der Erfassungseinheit der
+    #    Gruppe und muessen deshalb ueber den Divisor.
+    gruppen = db.query(Group).filter(Group.min_stock.isnot(None), Group.min_stock > 0).all()
+    for group in gruppen:
+        divisor = group_min_context(group).divisor or 1.0
+        schon_da = (
+            db.query(GroupLocationMinStock)
+            .filter(
+                GroupLocationMinStock.group_id == group.id,
+                GroupLocationMinStock.location_id.is_(None),
+            )
+            .first()
+        )
+        if schon_da is None:
+            db.add(
+                GroupLocationMinStock(
+                    group_id=group.id,
+                    location_id=None,
+                    min_stock=group.min_stock * divisor,
+                )
+            )
+        group.min_stock = None
+
+    db.add(Setting(key=MIGRATION_KEY, value="done"))
+    db.commit()

backend/app/services/stock.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Sequence
 from datetime import date
 
 from sqlalchemy import asc, func
@@ -215,6 +216,65 @@ def current_stock(db: Session, product_id: int) -> float:
     return float(sum(q for (q,) in total))
 
 
+def summe_bestand_base(db: Session, produkte: Sequence[Product]) -> float:
+    """Gesamtbestand mehrerer Artikel (Basiseinheiten) in EINER Abfrage.
+
+    Ersetzt ``sum(current_stock(db, p.id) for p in …)``: das setzte je Artikel
+    zwei Abfragen ab. Seit eine Gruppe die Artikel ihres ganzen Untergruppen-
+    Graphen zaehlt, sind das schnell hunderte.
+    """
+    if not produkte:
+        return 0.0
+    # Gleiche Fallunterscheidung wie current_stock: Einzelstuecke zaehlen ihre
+    # Items, alle anderen summieren die Lot-Mengen.
+    einzel = [p.id for p in produkte if p.individual]
+    lots = [p.id for p in produkte if not p.individual]
+    total = 0.0
+    if lots:
+        total += float(
+            db.query(func.coalesce(func.sum(Lot.quantity), 0.0))
+            .filter(Lot.product_id.in_(lots))
+            .scalar()
+            or 0.0
+        )
+    if einzel:
+        total += float(
+            db.query(func.count(Item.id)).filter(Item.product_id.in_(einzel)).scalar() or 0
+        )
+    return total
+
+
+def summe_bestand_im_subtree_base(
+    db: Session, produkte: Sequence[Product], location_id: str
+) -> float:
+    """Wie ``summe_bestand_base``, aber nur an einem Lagerort inkl. Unterorten.
+
+    Chargen ohne Lagerort liegen in keinem Subtree und zaehlen hier bewusst
+    nicht mit – im Gesamtbestand („Ueberall") dagegen schon.
+    """
+    if not produkte:
+        return 0.0
+    ids = {location_id} | descendant_location_ids(db, location_id)
+    einzel = [p.id for p in produkte if p.individual]
+    lots = [p.id for p in produkte if not p.individual]
+    total = 0.0
+    if lots:
+        total += float(
+            db.query(func.coalesce(func.sum(Lot.quantity), 0.0))
+            .filter(Lot.product_id.in_(lots), Lot.location_id.in_(ids))
+            .scalar()
+            or 0.0
+        )
+    if einzel:
+        total += float(
+            db.query(func.count(Item.id))
+            .filter(Item.product_id.in_(einzel), Item.location_id.in_(ids))
+            .scalar()
+            or 0
+        )
+    return total
+
+
 def location_stock_base(db: Session, product: Product, location_id: str) -> float:
     """Bestand eines Produkts an EINEM Lagerort (in Basiseinheiten).