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>
This commit is contained in:
Scarriffle
co-authored by
Claude Opus 5
Claude Opus 5
parent
254737086e
commit
fa5a2bc4fa
@@ -98,8 +98,27 @@ def in_artikel_basis(product: Product, menge: float, quell_base: BaseUnit) -> fl
|
||||
return menge * anzahl / zweit
|
||||
|
||||
|
||||
def to_base(db: Session, product: Product, quantity: float, unit_token: str) -> float:
|
||||
"""Rechnet eine Menge (in unit_token) in die Basiseinheit des Produkts um."""
|
||||
def to_base(
|
||||
db: Session,
|
||||
product: Product,
|
||||
quantity: float,
|
||||
unit_token: str,
|
||||
*,
|
||||
hausmasse: bool = False,
|
||||
) -> float:
|
||||
"""Rechnet eine Menge (in unit_token) in die Basiseinheit des Produkts um.
|
||||
|
||||
Reihenfolge: Packung → verwaltete Einheit → Hausmaß → Zweiteinheit-Brücke.
|
||||
Die Einheitentabelle steht VOR den Hausmaßen, weil sie die harte Physik ist:
|
||||
Ein versehentlich angelegtes Hausmaß namens „Liter" würde sonst die echte
|
||||
Einheit dauerhaft verdecken.
|
||||
|
||||
``hausmasse=True`` lässt Hausmaße überhaupt zu („2 EL"). Vorgabe ist False,
|
||||
weil ein Esslöffel ein Schätzwert ist: Beim **Verbrauchen und Auslagern** ist
|
||||
das richtig, beim **Einlagern** und bei **Mindestbeständen** ausdrücklich
|
||||
nicht. Der Schalter hält das in der Signatur fest, statt es der Disziplin an
|
||||
jeder Aufrufstelle zu überlassen.
|
||||
"""
|
||||
if quantity <= 0:
|
||||
raise ConversionError("Menge muss größer als 0 sein")
|
||||
|
||||
@@ -113,6 +132,10 @@ def to_base(db: Session, product: Product, quantity: float, unit_token: str) ->
|
||||
|
||||
unit = find_unit(db, t)
|
||||
if unit is None:
|
||||
if hausmasse:
|
||||
gerechnet = _hausmass_to_base(db, product, quantity, t)
|
||||
if gerechnet is not None:
|
||||
return gerechnet
|
||||
raise ConversionError(f"Unbekannte Einheit: {unit_token}")
|
||||
if unit.kind != kind_of_product(product):
|
||||
# Artfremde Einheit: geht nur über die Zweiteinheit des Artikels.
|
||||
@@ -130,6 +153,50 @@ def to_base(db: Session, product: Product, quantity: float, unit_token: str) ->
|
||||
return quantity * unit.factor
|
||||
|
||||
|
||||
def _hausmass_to_base(
|
||||
db: Session, product: Product, quantity: float, token: str
|
||||
) -> float | None:
|
||||
"""Hausmaß-Token auflösen. ``None`` = kein Hausmaß dieses Namens.
|
||||
|
||||
Unterschied, der wichtig ist: Ein **unbekannter Name** gibt ``None`` zurück,
|
||||
damit danach die normale Einheitensuche greift. Ein **bekanntes Maß ohne
|
||||
Menge** für diesen Artikel ist dagegen ein Fehler mit klarer Ansage – genau
|
||||
die Meldung, aus der der Rezeptabgleich sein „Maß jetzt anlegen" macht.
|
||||
"""
|
||||
from .vererbung import mass_aufloesen, mass_in_basiseinheit
|
||||
|
||||
angabe = mass_aufloesen(db, product, token)
|
||||
if angabe is None:
|
||||
bekannt = _bekanntes_mass(db, token)
|
||||
if bekannt is not None:
|
||||
# Den richtigen Namen nennen, nicht das klein geschriebene Token –
|
||||
# die Meldung steht so in der Oberflaeche.
|
||||
raise ConversionError(
|
||||
f"Für diese Kategorie ist kein Maß '{bekannt.name}' hinterlegt."
|
||||
)
|
||||
return None
|
||||
ergebnis = mass_in_basiseinheit(db, product, token, quantity)
|
||||
if ergebnis is None:
|
||||
raise ConversionError(
|
||||
f"Das Maß '{angabe.measure.name}' ist in "
|
||||
f"{BASE_LABEL[BaseUnit(angabe.base)]} hinterlegt und passt nicht zur "
|
||||
f"Art dieses Artikels ({BASE_LABEL[product.base_unit]}). Mit einer "
|
||||
f"Zweiteinheit am Artikel ginge es."
|
||||
)
|
||||
return ergebnis
|
||||
|
||||
|
||||
def _bekanntes_mass(db: Session, token: str):
|
||||
"""Das Hausmaß mit diesem Namen oder dieser Kurzform – sonst ``None``."""
|
||||
from ..models import Measure
|
||||
|
||||
t = (token or "").strip().lower()
|
||||
for measure in db.query(Measure).all():
|
||||
if t == measure.name.lower() or (measure.short and t == measure.short.lower()):
|
||||
return measure
|
||||
return None
|
||||
|
||||
|
||||
def resolve_product_unit(db: Session, unit_id: int) -> tuple[BaseUnit, int]:
|
||||
"""Ermittelt zu einer gewählten Einheit die kanonische Basiseinheit + Anzeige-ID."""
|
||||
unit = db.get(Unit, unit_id)
|
||||
|
||||
@@ -40,8 +40,13 @@ def options_list(fd: FieldDefinition) -> list[str]:
|
||||
return [str(o) for o in data] if isinstance(data, list) else []
|
||||
|
||||
|
||||
def _ancestry(db: Session, category_id: int) -> list[Category]:
|
||||
"""Kategorien von der Wurzel bis zur angegebenen (einschließlich)."""
|
||||
def ancestry(db: Session, category_id: int) -> list[Category]:
|
||||
"""Kategorien von der Wurzel bis zur angegebenen (einschließlich).
|
||||
|
||||
Auch von ``services/vererbung.py`` benutzt – dort allerdings umgedreht,
|
||||
weil ein einzelner geerbter Wert vom NÄCHSTEN Vorfahren kommen soll,
|
||||
während Felder von allen Vorfahren gesammelt werden.
|
||||
"""
|
||||
chain: list[Category] = []
|
||||
seen: set[int] = set()
|
||||
cid: int | None = category_id
|
||||
@@ -67,7 +72,7 @@ def effective_field_definitions(
|
||||
if category_id is None:
|
||||
return []
|
||||
result: list[tuple[FieldDefinition, bool]] = []
|
||||
for cat in _ancestry(db, category_id):
|
||||
for cat in ancestry(db, category_id):
|
||||
defs = (
|
||||
db.query(FieldDefinition)
|
||||
.filter(FieldDefinition.category_id == cat.id)
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from collections.abc import Sequence
|
||||
from datetime import date
|
||||
from datetime import date, timedelta
|
||||
|
||||
from sqlalchemy import asc, func
|
||||
from sqlalchemy.orm import Session
|
||||
@@ -18,7 +18,7 @@ from ..models import (
|
||||
Product,
|
||||
User,
|
||||
)
|
||||
from .conversion import to_base
|
||||
from .conversion import article_unit, to_base
|
||||
from .dates import clean_precision, normalize_best_before
|
||||
from .loans import nicht_verliehen
|
||||
|
||||
@@ -414,10 +414,17 @@ def consolidate_lot_group(
|
||||
Wird nach jedem Umlagern/Aufteilen aufgerufen – zwei gleich gelagerte Chargen
|
||||
mit demselben MHD sind für den Nutzer dieselbe Charge und sollen als eine
|
||||
erscheinen. Der Bestand bleibt unverändert, die Historie (Bewegungen) auch.
|
||||
|
||||
**Angebrochene Chargen sind davon ausgenommen und werden NIE zusammengefasst.**
|
||||
Eine offene Packung mit eigenem Verbrauchsdatum ist etwas anderes als eine
|
||||
ungeöffnete mit demselben MHD; ohne diese Ausnahme würde die offene Packung
|
||||
beim nächsten Einlagern am selben Ort still einkassiert und ihr kürzeres
|
||||
Verbrauchsdatum ginge verloren. Bitte beim nächsten Umbau hier stehen lassen.
|
||||
"""
|
||||
query = db.query(Lot).filter(
|
||||
Lot.product_id == product_id,
|
||||
Lot.best_before_precision == best_before_precision,
|
||||
Lot.opened_on.is_(None),
|
||||
)
|
||||
query = (
|
||||
query.filter(Lot.best_before.is_(None))
|
||||
@@ -452,6 +459,8 @@ def consolidate_duplicate_lots(db: Session) -> int:
|
||||
db.query(
|
||||
Lot.product_id, Lot.best_before, Lot.best_before_precision, Lot.location_id
|
||||
)
|
||||
# Angebrochene bleiben ausgenommen, siehe consolidate_lot_group.
|
||||
.filter(Lot.opened_on.is_(None))
|
||||
.group_by(
|
||||
Lot.product_id, Lot.best_before, Lot.best_before_precision, Lot.location_id
|
||||
)
|
||||
@@ -467,6 +476,7 @@ def consolidate_duplicate_lots(db: Session) -> int:
|
||||
Lot.best_before_precision == precision,
|
||||
Lot.best_before.is_(None) if best_before is None else Lot.best_before == best_before,
|
||||
Lot.location_id.is_(None) if location_id is None else Lot.location_id == location_id,
|
||||
Lot.opened_on.is_(None),
|
||||
)
|
||||
.scalar()
|
||||
)
|
||||
@@ -487,7 +497,8 @@ def check_out_lot(
|
||||
note: str | None = None,
|
||||
) -> list[dict]:
|
||||
"""Bucht gezielt von EINER Charge ab (manuelle Auswahl statt FEFO)."""
|
||||
needed = to_base(db, product, quantity, unit)
|
||||
# Hausmasse sind beim Auslagern erlaubt („2 EL"), beim Einlagern nicht.
|
||||
needed = to_base(db, product, quantity, unit, hausmasse=True)
|
||||
if needed > lot.quantity + 1e-9:
|
||||
raise StockError(
|
||||
f"Diese Charge hat nur {lot.quantity:g} {product.base_unit.value} "
|
||||
@@ -512,19 +523,140 @@ def check_out_lot(
|
||||
return affected
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Anbrechen und Teilverbrauch
|
||||
# --------------------------------------------------------------------------
|
||||
def abspalten(
|
||||
db: Session,
|
||||
lot: Lot,
|
||||
quantity: float,
|
||||
location_id: str | None,
|
||||
*,
|
||||
gleicher_ort_erlaubt: bool = False,
|
||||
) -> Lot:
|
||||
"""``quantity`` Basiseinheiten als neue Charge mit gleichem MHD abzweigen.
|
||||
|
||||
Reine Umbuchung, keine Bewegung – der Gesamtbestand ändert sich nicht. Gibt
|
||||
die neue Charge zurück (noch nicht konsolidiert; das entscheidet der
|
||||
Aufrufer, denn beim Anbrechen darf gerade NICHT konsolidiert werden).
|
||||
|
||||
``gleicher_ort_erlaubt`` ist der Unterschied zwischen den beiden Anlässen:
|
||||
Beim Aufteilen auf einen anderen Lagerort wäre derselbe Ort sinnlos, beim
|
||||
Anbrechen ist er der Normalfall – die offene Packung bleibt dort liegen,
|
||||
wo sie war.
|
||||
"""
|
||||
if quantity <= 0:
|
||||
raise StockError("Menge muss größer als 0 sein")
|
||||
if quantity > lot.quantity - 1e-9:
|
||||
raise StockError(
|
||||
f"So viel enthält die Charge nicht (vorhanden: {lot.quantity:g})."
|
||||
)
|
||||
if not gleicher_ort_erlaubt and (location_id or None) == (lot.location_id or None):
|
||||
raise StockError("Bitte einen anderen Lagerort als den aktuellen wählen.")
|
||||
|
||||
lot.quantity -= quantity
|
||||
neu = Lot(
|
||||
product_id=lot.product_id,
|
||||
quantity=quantity,
|
||||
best_before=lot.best_before,
|
||||
best_before_precision=lot.best_before_precision,
|
||||
location_id=location_id,
|
||||
)
|
||||
db.add(neu)
|
||||
db.flush()
|
||||
return neu
|
||||
|
||||
|
||||
def anbrechen(db: Session, product: Product, lot: Lot, quantity: float | None = None) -> Lot:
|
||||
"""Eine Packung der Charge anbrechen und als eigene Charge führen.
|
||||
|
||||
Aus 4000 ml (4 × 1 l) wird eine offene Charge mit 1000 ml und eine
|
||||
ungeöffnete mit 3000 ml. Ohne das Abspalten würden die restlichen 3 l das
|
||||
kurze Verbrauchsdatum der geöffneten Packung mittragen, obwohl sie noch zu
|
||||
sind.
|
||||
|
||||
``quantity`` leer = eine Artikeleinheit (Packung, sonst Anzeigeeinheit);
|
||||
ist die Charge kleiner, wird sie als Ganzes angebrochen.
|
||||
"""
|
||||
from .vererbung import oeffnungsfrist
|
||||
|
||||
if lot.opened_on is not None:
|
||||
return lot # schon offen – nichts zu tun
|
||||
|
||||
menge = quantity
|
||||
if menge is None:
|
||||
faktor, _label = article_unit(product)
|
||||
menge = faktor or lot.quantity
|
||||
menge = min(menge, lot.quantity)
|
||||
|
||||
ziel = lot if menge >= lot.quantity - 1e-9 else abspalten(
|
||||
db, lot, menge, lot.location_id, gleicher_ort_erlaubt=True
|
||||
)
|
||||
|
||||
heute = date.today()
|
||||
ziel.opened_on = heute
|
||||
ziel.opened_quantity = ziel.quantity
|
||||
ziel.consume_by = heute + timedelta(days=oeffnungsfrist(db, product))
|
||||
db.flush()
|
||||
return ziel
|
||||
|
||||
|
||||
def verbrauchen(
|
||||
db: Session,
|
||||
product: Product,
|
||||
lot: Lot,
|
||||
quantity: float,
|
||||
unit: str,
|
||||
user: User | None,
|
||||
note: str | None = None,
|
||||
auto_open: bool = True,
|
||||
) -> tuple[list[dict], Lot | None, bool]:
|
||||
"""Teilmenge aus einer Charge verbrauchen, bei Bedarf vorher anbrechen.
|
||||
|
||||
Gibt (betroffene Chargen, offene Charge oder None wenn leer, angebrochen?)
|
||||
zurück. Die Umrechnung läuft über ``to_base`` und kennt damit auch die
|
||||
Hausmaße („2 EL") – deshalb wird hier zuerst gerechnet und danach
|
||||
angebrochen: Scheitert die Einheit, soll keine Packung offen sein.
|
||||
"""
|
||||
# Erst rechnen: Scheitert die Einheit, soll keine Packung grundlos offen sein.
|
||||
menge_base = to_base(db, product, quantity, unit, hausmasse=True)
|
||||
angebrochen = False
|
||||
ziel = lot
|
||||
if lot.opened_on is None and auto_open:
|
||||
ziel = anbrechen(db, product, lot, max(menge_base, article_unit(product)[0] or 0.0))
|
||||
angebrochen = True
|
||||
# Bewusst mit der ROH-Eingabe weiter, nicht mit menge_base: ``unit_used`` an
|
||||
# der Bewegung soll festhalten, was der Nutzer getippt hat („2 EL"), nicht
|
||||
# das Ergebnis der Umrechnung. Die zweite Umrechnung liefert denselben Wert.
|
||||
affected = check_out_lot(db, product, ziel, quantity, unit, user, note)
|
||||
offen = None if ziel.quantity <= 1e-9 else ziel
|
||||
return affected, offen, angebrochen
|
||||
|
||||
|
||||
def _fefo_lots(db: Session, product_id: int) -> list[Lot]:
|
||||
"""Lots eines Produkts, sortiert nach Ablaufdatum (NULL zuletzt), dann Alter."""
|
||||
"""Lots eines Produkts, sortiert nach dem WIRKSAMEN Datum (NULL zuletzt).
|
||||
|
||||
Wirksam ist das frühere aus MHD und Verbrauchsdatum (``Lot.faellig_am``).
|
||||
Eine angebrochene Packung kommt damit meist von selbst zuerst, weil ihr
|
||||
Verbrauchsdatum näher liegt – aber eine ungeöffnete Charge, die morgen
|
||||
abläuft, geht vor. Erst bei gleichem Datum wird das Angebrochene vorgezogen,
|
||||
damit nicht eine zweite Packung aufgeht, während eine offen ist.
|
||||
"""
|
||||
lots = (
|
||||
db.query(Lot)
|
||||
.filter(Lot.product_id == product_id, Lot.quantity > 0)
|
||||
.order_by(asc(Lot.created_at))
|
||||
.all()
|
||||
)
|
||||
# NULL-best_before ans Ende (nach Datum aufsteigend). In Python sortieren, damit
|
||||
# es über SQLite und Postgres identisch funktioniert.
|
||||
# In Python sortieren, damit es über SQLite und Postgres identisch arbeitet.
|
||||
return sorted(
|
||||
lots,
|
||||
key=lambda lot: (lot.best_before is None, lot.best_before or date.max, lot.id),
|
||||
key=lambda lot: (
|
||||
lot.faellig_am is None,
|
||||
lot.faellig_am or date.max,
|
||||
lot.opened_on is None,
|
||||
lot.id,
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
@@ -541,7 +673,7 @@ def check_out(
|
||||
Gibt die Liste der betroffenen Chargen mit abgebuchter Menge zurück.
|
||||
Wirft StockError, wenn der Gesamtbestand nicht ausreicht.
|
||||
"""
|
||||
needed = to_base(db, product, quantity, unit)
|
||||
needed = to_base(db, product, quantity, unit, hausmasse=True)
|
||||
available = current_stock(db, product.id)
|
||||
if needed > available + 1e-9:
|
||||
raise StockError(
|
||||
|
||||
@@ -0,0 +1,205 @@
|
||||
"""Werte, die über den Kategorie-Baum geerbt werden: Öffnungsfrist und Hausmaße.
|
||||
|
||||
Die Regel ist bei beiden dieselbe und bewusst eine andere als bei den selbst
|
||||
definierten Feldern: Dort werden die Felder **aller** Vorfahren gesammelt
|
||||
(``services/fields.py::effective_field_definitions``), hier gewinnt der
|
||||
**nächste** Vorfahr mit einem Eintrag. Ein einzelner Wert kann nur einmal
|
||||
gelten — „Backwaren: 1 EL = 10 g" darf von „Mehl: 1 EL = 9 g" überschrieben
|
||||
werden, ohne dass beide gleichzeitig zählen.
|
||||
|
||||
Reihenfolge immer: Artikel → nächste Kategorie mit Wert → … → global.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Callable, TypeVar
|
||||
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from ..models import (
|
||||
BaseUnit,
|
||||
CategoryMeasure,
|
||||
Measure,
|
||||
Product,
|
||||
ProductMeasure,
|
||||
Setting,
|
||||
)
|
||||
from .fields import ancestry
|
||||
|
||||
T = TypeVar("T")
|
||||
|
||||
# Globale Öffnungsfrist. Pflichtwert: Ohne ihn hätte eine angebrochene Packung
|
||||
# ohne Kategorie-Eintrag kein Verbrauchsdatum, und der ganze Zweck entfiele.
|
||||
OPEN_DAYS_KEY = "open_days"
|
||||
|
||||
|
||||
def _vorfahren_abwaerts(db: Session, category_id: int | None):
|
||||
"""Kategorien vom Artikel aufwärts: nächste zuerst, Wurzel zuletzt.
|
||||
|
||||
``ancestry`` liefert die Kette Wurzel-zuerst (dort richtig, weil Felder von
|
||||
oben nach unten gelesen werden); hier wird sie umgedreht.
|
||||
"""
|
||||
if category_id is None:
|
||||
return []
|
||||
return list(reversed(ancestry(db, category_id)))
|
||||
|
||||
|
||||
def naechster_wert(
|
||||
db: Session, category_id: int | None, lese: Callable[[int], T | None]
|
||||
) -> T | None:
|
||||
"""Ersten gesetzten Wert entlang der Kategorie-Kette nach oben suchen."""
|
||||
for cat in _vorfahren_abwaerts(db, category_id):
|
||||
wert = lese(cat.id)
|
||||
if wert is not None:
|
||||
return wert
|
||||
return None
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Öffnungsfrist
|
||||
# --------------------------------------------------------------------------
|
||||
def globale_oeffnungsfrist(db: Session) -> int:
|
||||
"""Globaler Wert in Tagen – Muster wie ``get_expiry_warning_days``."""
|
||||
from ..config import get_settings
|
||||
|
||||
vorgabe = get_settings().open_days_default
|
||||
row = db.get(Setting, OPEN_DAYS_KEY)
|
||||
if row is None:
|
||||
return vorgabe
|
||||
try:
|
||||
tage = int(row.value)
|
||||
except (TypeError, ValueError):
|
||||
return vorgabe
|
||||
return tage if tage > 0 else vorgabe
|
||||
|
||||
|
||||
def oeffnungsfrist(db: Session, product: Product) -> int:
|
||||
"""Wie viele Tage eine angebrochene Packung dieses Artikels noch hält."""
|
||||
if product.open_days is not None and product.open_days > 0:
|
||||
return product.open_days
|
||||
geerbt = naechster_wert(
|
||||
db,
|
||||
product.category_id,
|
||||
lambda cid: _kategorie_frist(db, cid),
|
||||
)
|
||||
return geerbt if geerbt is not None else globale_oeffnungsfrist(db)
|
||||
|
||||
|
||||
def _kategorie_frist(db: Session, category_id: int) -> int | None:
|
||||
from ..models import Category
|
||||
|
||||
cat = db.get(Category, category_id)
|
||||
if cat is None or cat.open_days is None or cat.open_days <= 0:
|
||||
return None
|
||||
return cat.open_days
|
||||
|
||||
|
||||
def frist_herkunft(db: Session, product: Product) -> tuple[int, str]:
|
||||
"""Frist plus Klartext, woher sie kommt – für den Platzhalter in der Maske."""
|
||||
if product.open_days is not None and product.open_days > 0:
|
||||
return product.open_days, "Artikel"
|
||||
for cat in _vorfahren_abwaerts(db, product.category_id):
|
||||
if cat.open_days is not None and cat.open_days > 0:
|
||||
return cat.open_days, f"Kategorie: {cat.name}"
|
||||
return globale_oeffnungsfrist(db), "Einstellungen"
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Hausmaße
|
||||
# --------------------------------------------------------------------------
|
||||
class MassAngabe:
|
||||
"""Ein für einen Artikel auflösbares Hausmaß samt Herkunft."""
|
||||
|
||||
__slots__ = ("measure", "amount", "base", "herkunft")
|
||||
|
||||
def __init__(self, measure: Measure, amount: float, base: str, herkunft: str):
|
||||
self.measure = measure
|
||||
self.amount = amount
|
||||
self.base = base
|
||||
self.herkunft = herkunft
|
||||
|
||||
|
||||
def _mass_fuer_artikel(db: Session, product: Product, measure_id: int) -> MassAngabe | None:
|
||||
eigen = (
|
||||
db.query(ProductMeasure)
|
||||
.filter(
|
||||
ProductMeasure.product_id == product.id,
|
||||
ProductMeasure.measure_id == measure_id,
|
||||
)
|
||||
.first()
|
||||
)
|
||||
measure = db.get(Measure, measure_id)
|
||||
if measure is None:
|
||||
return None
|
||||
if eigen is not None:
|
||||
return MassAngabe(measure, eigen.amount, eigen.base, "Artikel")
|
||||
for cat in _vorfahren_abwaerts(db, product.category_id):
|
||||
row = (
|
||||
db.query(CategoryMeasure)
|
||||
.filter(
|
||||
CategoryMeasure.category_id == cat.id,
|
||||
CategoryMeasure.measure_id == measure_id,
|
||||
)
|
||||
.first()
|
||||
)
|
||||
if row is not None:
|
||||
return MassAngabe(measure, row.amount, row.base, f"Kategorie: {cat.name}")
|
||||
return None
|
||||
|
||||
|
||||
def verfuegbare_masse(db: Session, product: Product) -> list[MassAngabe]:
|
||||
"""Alle Hausmaße, die für diesen Artikel eine Menge haben.
|
||||
|
||||
Grundlage für die Einheitenauswahl im Verbrauchen-Dialog und für den
|
||||
Hinweis, woher die Menge stammt.
|
||||
"""
|
||||
ergebnis: list[MassAngabe] = []
|
||||
for measure in db.query(Measure).order_by(Measure.position, Measure.id).all():
|
||||
angabe = _mass_fuer_artikel(db, product, measure.id)
|
||||
if angabe is not None:
|
||||
ergebnis.append(angabe)
|
||||
return ergebnis
|
||||
|
||||
|
||||
def mass_aufloesen(db: Session, product: Product, token: str) -> MassAngabe | None:
|
||||
"""Ein Eingabe-Token („EL", „esslöffel", „Tasse") zum Hausmaß auflösen.
|
||||
|
||||
Vergleicht Name und Kurzform ohne Rücksicht auf Groß-/Kleinschreibung.
|
||||
``None`` heißt: Entweder gibt es das Maß nicht, oder es ist für diesen
|
||||
Artikel (und seine Kategorien) ohne Menge — beides behandelt der Aufrufer
|
||||
gleich, nämlich als „Maß hier nicht hinterlegt".
|
||||
"""
|
||||
t = (token or "").strip().lower()
|
||||
if not t:
|
||||
return None
|
||||
for measure in db.query(Measure).all():
|
||||
namen = {measure.name.lower()}
|
||||
if measure.short:
|
||||
namen.add(measure.short.lower())
|
||||
if t in namen:
|
||||
return _mass_fuer_artikel(db, product, measure.id)
|
||||
return None
|
||||
|
||||
|
||||
def mass_in_basiseinheit(db: Session, product: Product, token: str, menge: float) -> float | None:
|
||||
"""Menge in einem Hausmaß in die Basiseinheit des Artikels umrechnen.
|
||||
|
||||
``None`` heißt „Maß für diesen Artikel nicht hinterlegt" — der Aufrufer
|
||||
entscheidet, ob das ein Fehler ist (Buchung) oder nur eine Lücke, die man
|
||||
anlegen kann (Rezeptabgleich).
|
||||
"""
|
||||
angabe = mass_aufloesen(db, product, token)
|
||||
if angabe is None:
|
||||
return None
|
||||
from .conversion import in_artikel_basis
|
||||
|
||||
roh = menge * angabe.amount
|
||||
try:
|
||||
quell = BaseUnit(angabe.base)
|
||||
except ValueError:
|
||||
return None
|
||||
if quell == product.base_unit:
|
||||
return roh
|
||||
# Art passt nicht zur Basiseinheit des Artikels: derselbe Weg wie bei jeder
|
||||
# artfremden Einheit, naemlich ueber die Zweiteinheit des Artikels.
|
||||
return in_artikel_basis(product, roh, quell)
|
||||
Reference in New Issue
Block a user