Angebrochene Packungen, Teilverbrauch und Hausmasse (Backend)

Eine Teilmenge auszulagern ging rechnerisch schon, aber es blieb keine Spur davon: Eine Charge mit 900 von urspruenglich 1000 ml war von einer frisch eingelagerten 900-ml-Charge nicht zu unterscheiden, und eine geoeffnete Milch galt weiter bis zum aufgedruckten MHD. Anbrechen spaltet jetzt eine Packung ab. Aus 4 x 1 l wird eine offene Charge mit 1 l und eine ungeoeffnete mit 3 l - sonst truegen die restlichen 3 l das kurze Verbrauchsdatum mit, obwohl sie noch zu sind. Der Gesamtbestand aendert sich dabei nicht, es ist eine Umbuchung wie das Aufteilen und schreibt wie dieses keine Bewegung. Verbrauchen geht in einem Schritt: Wer "100 ml verbraucht" eintraegt, bricht die Charge dabei an (abschaltbar ueber auto_open). Gerechnet wird vor dem Anbrechen - scheitert die Einheit, soll keine Packung grundlos offen stehen. MHD und "zu verbrauchen bis" stehen nebeneinander und bleiben beide sichtbar; gewarnt wird nach dem FRUEHEREN (Lot.faellig_am). Dafuer musste in /expiring die Vorbedingung "best_before IS NOT NULL" weg, sonst fehlte ausgerechnet die angebrochene Packung ohne aufgedrucktes MHD. ExpiringItem traegt beide Daten plus warn_date und warn_source, und best_before ist dort jetzt optional. Die Frist kommt aus drei Ebenen: Artikel schlaegt Kategorie, Kategorie schlaegt ueber ihre Oberkategorien hinweg den globalen Wert. Der Helfer dafuer (services/vererbung.py) liest die Kategoriekette von services/fields.py rueckwaerts - dort werden Felder ALLER Vorfahren gesammelt, hier gewinnt der naechste. Dieselbe Mechanik traegt die Hausmasse. Hausmasse sind der zweite Teil: "2 EL Mehl" liess sich bisher nicht buchen, weil eine globale Einheit "Essloeffel" bei Mehl und Zucker zwangslaeufig gleich schwer waere. Der Name ist deshalb global, die Menge haengt an Kategorie und Artikel. to_base loest sie nur mit hausmasse=True auf - beim Auslagern und Verbrauchen ja, beim Einlagern und bei Mindestbestaenden ausdruecklich nicht, denn ein Loeffel ist ein Schaetzwert. Verwaltete Einheiten werden zuerst geprueft, damit ein Mass namens "Liter" die echte Einheit nicht verdeckt. Zwei Stellen waeren sonst still kaputtgegangen: - Die Konsolidierung haette die offene Packung beim naechsten Einlagern am selben Ort einkassiert und ihr Verbrauchsdatum verschluckt. Angebrochene Chargen werden deshalb nie zusammengefasst - in consolidate_lot_group und im Start-Aufraeumer, beide bisher ohne jeden Test. Das Netz dafuer ist jetzt da (test_konsolidierung.py). - FEFO sortiert nach dem wirksamen Datum statt nur nach dem MHD. Eine offene Packung kommt damit meist von selbst zuerst, aber eine ungeoeffnete, die morgen ablaeuft, geht vor - Verderb schlaegt Bequemlichkeit. Erst bei gleichem Datum wird das Angebrochene vorgezogen. Dashboard bekommt "angebrochen" als fuenften Zustand, mit Vorrang abgelaufen > bald > angebrochen > in Ordnung: Was offen ist und morgen ablaeuft, gehoert in die Warnung, nicht in den ruhigeren Zustand. Oberflaechen in Web und App folgen in eigenen Commits. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-02 11:25:36 +02:00
parent 254737086e
commit fa5a2bc4fa
22 changed files with 2073 additions and 51 deletions
@@ -0,0 +1,276 @@
+"""Angebrochene Packungen: Abspalten, Verbrauchsdatum, Teilverbrauch, Frist-Vererbung."""
+
+from datetime import date, timedelta
+
+import pytest
+from fastapi import HTTPException
+
+from app.models import (
+    BaseUnit,
+    Category,
+    CategoryTracking,
+    Lot,
+    Movement,
+    MovementType,
+    Product,
+    Role,
+    Setting,
+    User,
+)
+from app.routers.stock import consume_lot, open_lot
+from app.schemas import LotConsume, LotOpen
+from app.services.stock import check_in, current_stock
+from app.services.vererbung import frist_herkunft, oeffnungsfrist
+
+
+@pytest.fixture()
+def user(db):
+    person = User(username="tester", password_hash="x", role=Role.admin)
+    db.add(person)
+    db.commit()
+    db.refresh(person)
+    return person
+
+
+@pytest.fixture()
+def milch(db):
+    """Milliliter-Artikel mit 1000 ml je Packung, in einer Lebensmittel-Kategorie."""
+    cat = Category(name="Molkereiprodukte", tracking=CategoryTracking.food.value)
+    db.add(cat)
+    db.flush()
+    product = Product(
+        name="Vollmilch", base_unit=BaseUnit.milliliter, package_size=1000,
+        category_id=cat.id, source="manual",
+    )
+    db.add(product)
+    db.commit()
+    db.refresh(product)
+    return product
+
+
+def _charge(db, product, menge_base, best_before=None):
+    lot = Lot(product_id=product.id, quantity=menge_base, best_before=best_before)
+    db.add(lot)
+    db.commit()
+    db.refresh(lot)
+    return lot
+
+
+# --------------------------------------------------------------------------
+# Anbrechen spaltet eine Packung ab
+# --------------------------------------------------------------------------
+def test_anbrechen_spaltet_eine_packung_ab(db, user, milch):
+    lot = _charge(db, milch, 4000)          # 4 x 1 l in einer Zeile
+
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    assert offen.quantity == 1000
+    assert offen.opened_on == date.today()
+    assert offen.opened_quantity == 1000
+    # Der Rest bleibt zu – sonst trüge er das kurze Verbrauchsdatum mit.
+    rest = db.query(Lot).filter(Lot.id != offen.id).one()
+    assert rest.quantity == 3000
+    assert rest.opened_on is None
+    assert rest.consume_by is None
+    # Der Gesamtbestand ändert sich beim Anbrechen nicht.
+    assert current_stock(db, milch.id) == 4000
+
+
+def test_anbrechen_einer_einzelnen_packung_spaltet_nichts(db, user, milch):
+    lot = _charge(db, milch, 1000)
+
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    assert offen.id == lot.id
+    assert db.query(Lot).count() == 1
+    assert offen.quantity == 1000
+
+
+def test_anbrechen_nimmt_hoechstens_die_ganze_charge(db, user, milch):
+    lot = _charge(db, milch, 400)            # weniger als eine Packung
+
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    assert offen.quantity == 400
+    assert db.query(Lot).count() == 1
+
+
+def test_anbrechen_mit_eigener_menge(db, user, milch):
+    lot = _charge(db, milch, 4000)
+
+    offen = open_lot(lot.id, LotOpen(quantity=500), db=db, _=user)
+
+    assert offen.quantity == 500
+    assert db.query(Lot).filter(Lot.id != offen.id).one().quantity == 3500
+
+
+def test_zweimal_anbrechen_aendert_nichts(db, user, milch):
+    lot = _charge(db, milch, 4000)
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    nochmal = open_lot(offen.id, LotOpen(), db=db, _=user)
+
+    assert nochmal.id == offen.id
+    assert nochmal.quantity == 1000
+    assert db.query(Lot).count() == 2
+
+
+def test_verbrauchsdatum_kommt_aus_der_frist(db, user, milch):
+    db.add(Setting(key="open_days", value="5"))
+    db.commit()
+    lot = _charge(db, milch, 1000)
+
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    assert offen.consume_by == date.today() + timedelta(days=5)
+
+
+def test_mhd_bleibt_neben_dem_verbrauchsdatum_stehen(db, user, milch):
+    mhd = date.today() + timedelta(days=20)
+    lot = _charge(db, milch, 1000, best_before=mhd)
+
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    assert offen.best_before == mhd            # unangetastet
+    assert offen.consume_by is not None
+    # Gewarnt wird nach dem früheren der beiden.
+    frisch = db.get(Lot, offen.id)
+    assert frisch.faellig_am == frisch.consume_by
+
+
+def test_frueheres_mhd_schlaegt_das_verbrauchsdatum(db, user, milch):
+    mhd = date.today() + timedelta(days=1)     # läuft vor der Öffnungsfrist ab
+    lot = _charge(db, milch, 1000, best_before=mhd)
+
+    open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    frisch = db.query(Lot).one()
+    assert frisch.faellig_am == mhd
+
+
+# --------------------------------------------------------------------------
+# Verbrauchen
+# --------------------------------------------------------------------------
+def test_verbrauchen_oeffnet_in_einem_schritt(db, user, milch):
+    lot = _charge(db, milch, 4000)
+
+    ergebnis = consume_lot(lot.id, LotConsume(quantity=100, unit="ml"), db=db, user=user)
+
+    assert ergebnis.opened is True
+    assert ergebnis.lot is not None
+    assert ergebnis.lot.quantity == 900       # 1000 geöffnet, 100 verbraucht
+    assert ergebnis.lot.opened_quantity == 1000
+    assert current_stock(db, milch.id) == 3900
+    # Der Verbrauch ist eine Bewegung, das Anbrechen allein nicht.
+    bewegungen = db.query(Movement).all()
+    assert len(bewegungen) == 1
+    assert bewegungen[0].type == MovementType.out
+    assert bewegungen[0].quantity == 100
+
+
+def test_verbrauchen_ohne_anbrechen_wenn_abgewaehlt(db, user, milch):
+    lot = _charge(db, milch, 4000)
+
+    ergebnis = consume_lot(
+        lot.id, LotConsume(quantity=100, unit="ml", auto_open=False), db=db, user=user
+    )
+
+    assert ergebnis.opened is False
+    assert db.query(Lot).count() == 1
+    assert db.query(Lot).one().opened_on is None
+    assert current_stock(db, milch.id) == 3900
+
+
+def test_weiterer_verbrauch_nutzt_die_offene_packung(db, user, milch):
+    lot = _charge(db, milch, 4000)
+    consume_lot(lot.id, LotConsume(quantity=100, unit="ml"), db=db, user=user)
+    offen = db.query(Lot).filter(Lot.opened_on.isnot(None)).one()
+
+    consume_lot(offen.id, LotConsume(quantity=200, unit="ml"), db=db, user=user)
+
+    assert db.get(Lot, offen.id).quantity == 700
+    assert db.query(Lot).count() == 2
+
+
+def test_leere_offene_packung_verschwindet(db, user, milch):
+    lot = _charge(db, milch, 1000)
+    open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    ergebnis = consume_lot(lot.id, LotConsume(quantity=1000, unit="ml"), db=db, user=user)
+
+    assert ergebnis.lot is None
+    assert db.query(Lot).count() == 0
+    assert current_stock(db, milch.id) == 0
+
+
+def test_mehr_verbrauchen_als_drin_ist_scheitert(db, user, milch):
+    lot = _charge(db, milch, 1000)
+
+    with pytest.raises(HTTPException) as fehler:
+        consume_lot(lot.id, LotConsume(quantity=2000, unit="ml"), db=db, user=user)
+    assert fehler.value.status_code == 409
+
+
+def test_unbekannte_einheit_bricht_nichts_an(db, user, milch):
+    """Erst rechnen, dann anbrechen – sonst stünde eine Packung grundlos offen."""
+    lot = _charge(db, milch, 4000)
+
+    with pytest.raises(HTTPException) as fehler:
+        consume_lot(lot.id, LotConsume(quantity=1, unit="furlong"), db=db, user=user)
+
+    assert fehler.value.status_code == 400
+    assert db.query(Lot).one().opened_on is None
+
+
+def test_verbrauchen_in_packungen(db, user, rice, milch):
+    """„1 Packung" muss weiter gehen – die Hausmaße dürfen das nicht verdrängen."""
+    lot = check_in(db, rice, 3, "package", None, None, None)
+    db.commit()
+
+    consume_lot(lot.id, LotConsume(quantity=1, unit="package"), db=db, user=user)
+
+    assert current_stock(db, rice.id) == 1000
+
+
+# --------------------------------------------------------------------------
+# Frist: Artikel > Kategorie > Oberkategorie > global
+# --------------------------------------------------------------------------
+def test_frist_vererbung_ueber_die_ebenen(db, milch):
+    # 1. Ohne alles gilt der Standard aus der Konfiguration.
+    assert oeffnungsfrist(db, milch) == 3
+    assert frist_herkunft(db, milch)[1] == "Einstellungen"
+
+    # 2. Globale Einstellung.
+    db.add(Setting(key="open_days", value="7"))
+    db.commit()
+    assert oeffnungsfrist(db, milch) == 7
+
+    # 3. Oberkategorie.
+    ober = db.get(Category, milch.category_id)
+    unter = Category(name="Frischmilch", parent_id=ober.id,
+                     tracking=CategoryTracking.food.value)
+    db.add(unter)
+    db.flush()
+    milch.category_id = unter.id
+    ober.open_days = 4
+    db.commit()
+    assert oeffnungsfrist(db, milch) == 4
+    assert frist_herkunft(db, milch)[1] == "Kategorie: Molkereiprodukte"
+
+    # 4. Die nähere Kategorie gewinnt.
+    unter.open_days = 2
+    db.commit()
+    assert oeffnungsfrist(db, milch) == 2
+    assert frist_herkunft(db, milch)[1] == "Kategorie: Frischmilch"
+
+    # 5. Der Artikel schlägt alles.
+    milch.open_days = 1
+    db.commit()
+    assert oeffnungsfrist(db, milch) == 1
+    assert frist_herkunft(db, milch)[1] == "Artikel"
+
+
+def test_kaputte_globale_einstellung_faellt_auf_den_standard(db, milch):
+    db.add(Setting(key="open_days", value="viele"))
+    db.commit()
+    assert oeffnungsfrist(db, milch) == 3