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>

backend/tests/test_konsolidierung.py

@@ -0,0 +1,182 @@
+"""Zusammenfassen gleichartiger Chargen – und die Ausnahme für angebrochene.
+
+Diese Logik war bisher ungetestet, obwohl vier Stellen sie aufrufen
+(`check_in`, `bulk_lot_location`, `split_lot`, `update_lot`). Mit dem Anbrechen
+wird sie gefährlich: Ohne die Ausnahme würde eine offene Packung beim nächsten
+Einlagern am selben Ort still mit einer ungeöffneten verschmolzen und ihr
+kürzeres Verbrauchsdatum verlieren.
+"""
+
+from datetime import date, timedelta
+
+import pytest
+
+from app.models import BaseUnit, Location, Lot, Movement, MovementType, Product, Role, User
+from app.routers.stock import bulk_lot_location, open_lot
+from app.schemas import BulkLotLocation, LotOpen
+from app.services.stock import (
+    check_in,
+    consolidate_duplicate_lots,
+    consolidate_lot_group,
+    current_stock,
+)
+
+
+@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 keller(db):
+    ort = Location(name="Keller")
+    db.add(ort)
+    db.commit()
+    db.refresh(ort)
+    return ort
+
+
+@pytest.fixture()
+def milch(db):
+    product = Product(
+        name="Vollmilch", base_unit=BaseUnit.milliliter, package_size=1000,
+        source="manual",
+    )
+    db.add(product)
+    db.commit()
+    db.refresh(product)
+    return product
+
+
+def _lot(db, product, menge, best_before=None, ort=None):
+    lot = Lot(
+        product_id=product.id, quantity=menge, best_before=best_before,
+        location_id=ort.id if ort else None,
+    )
+    db.add(lot)
+    db.commit()
+    db.refresh(lot)
+    return lot
+
+
+# --------------------------------------------------------------------------
+# Das bisherige Verhalten muss bleiben
+# --------------------------------------------------------------------------
+def test_gleiche_chargen_werden_zusammengefasst(db, milch, keller):
+    mhd = date.today() + timedelta(days=10)
+    _lot(db, milch, 1000, mhd, keller)
+    _lot(db, milch, 2000, mhd, keller)
+
+    survivor = consolidate_lot_group(db, milch.id, mhd, "day", keller.id)
+    db.commit()
+
+    assert survivor.quantity == 3000
+    assert db.query(Lot).count() == 1
+
+
+def test_verschiedenes_mhd_bleibt_getrennt(db, milch, keller):
+    _lot(db, milch, 1000, date.today() + timedelta(days=5), keller)
+    _lot(db, milch, 1000, date.today() + timedelta(days=9), keller)
+
+    consolidate_duplicate_lots(db)
+
+    assert db.query(Lot).count() == 2
+
+
+def test_bewegungen_haengen_an_der_verbleibenden_charge(db, milch, keller, user):
+    mhd = date.today() + timedelta(days=10)
+    alt = _lot(db, milch, 1000, mhd, keller)
+    neu = _lot(db, milch, 1000, mhd, keller)
+    db.add(Movement(product_id=milch.id, lot_id=neu.id, type=MovementType.in_,
+                    quantity=1000, unit_used="ml"))
+    db.commit()
+
+    survivor = consolidate_lot_group(db, milch.id, mhd, "day", keller.id)
+    db.commit()
+
+    assert survivor.id == alt.id
+    assert db.query(Movement).one().lot_id == alt.id
+
+
+def test_einlagern_fasst_mit_der_bestehenden_charge_zusammen(db, milch, keller):
+    mhd = date.today() + timedelta(days=10)
+    check_in(db, milch, 1, "package", mhd, keller.id, None)
+    check_in(db, milch, 1, "package", mhd, keller.id, None)
+    db.commit()
+
+    assert db.query(Lot).count() == 1
+    assert current_stock(db, milch.id) == 2000
+
+
+# --------------------------------------------------------------------------
+# Die Ausnahme: Angebrochenes bleibt für sich
+# --------------------------------------------------------------------------
+def test_angebrochene_charge_wird_nicht_eingesammelt(db, milch, keller, user):
+    mhd = date.today() + timedelta(days=20)
+    lot = _lot(db, milch, 2000, mhd, keller)
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+    verbrauchsdatum = offen.consume_by
+
+    consolidate_lot_group(db, milch.id, mhd, "day", keller.id)
+    db.commit()
+
+    assert db.query(Lot).count() == 2
+    frisch = db.get(Lot, offen.id)
+    assert frisch is not None
+    assert frisch.consume_by == verbrauchsdatum
+
+
+def test_einlagern_laesst_die_offene_packung_in_ruhe(db, milch, keller, user):
+    """Der gefährlichste Pfad: nachkaufen, während eine Packung offen ist."""
+    mhd = date.today() + timedelta(days=20)
+    lot = _lot(db, milch, 2000, mhd, keller)
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    check_in(db, milch, 1, "package", mhd, keller.id, None)
+    db.commit()
+
+    frisch = db.get(Lot, offen.id)
+    assert frisch.quantity == 1000
+    assert frisch.opened_on is not None
+    # Die zugekaufte Packung verschmilzt mit der verbliebenen ungeöffneten.
+    zu = db.query(Lot).filter(Lot.opened_on.is_(None)).all()
+    assert len(zu) == 1
+    assert zu[0].quantity == 2000
+    assert current_stock(db, milch.id) == 3000
+
+
+def test_umlagern_mehrerer_chargen_laesst_offenes_getrennt(db, milch, keller, user):
+    mhd = date.today() + timedelta(days=20)
+    lot = _lot(db, milch, 3000, mhd, None)
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+    zweite = _lot(db, milch, 1000, mhd, None)
+
+    bulk_lot_location(
+        BulkLotLocation(lot_ids=[offen.id, zweite.id, lot.id], location_id=keller.id),
+        db=db, _=user,
+    )
+
+    offene = db.query(Lot).filter(Lot.opened_on.isnot(None)).all()
+    assert len(offene) == 1
+    assert offene[0].quantity == 1000
+    assert offene[0].location_id == keller.id
+    assert current_stock(db, milch.id) == 4000
+
+
+def test_start_aufraeumer_ruehrt_offenes_nicht_an(db, milch, keller, user):
+    mhd = date.today() + timedelta(days=20)
+    lot = _lot(db, milch, 2000, mhd, keller)
+    open_lot(lot.id, LotOpen(), db=db, _=user)
+    # Zwei ungeöffnete Dubletten dazu, die zusammengefasst werden sollen.
+    _lot(db, milch, 500, mhd, keller)
+
+    entfernt = consolidate_duplicate_lots(db)
+
+    assert entfernt == 1
+    assert db.query(Lot).filter(Lot.opened_on.isnot(None)).count() == 1
+    assert db.query(Lot).filter(Lot.opened_on.is_(None)).count() == 1
+    assert current_stock(db, milch.id) == 2500