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
@@ -12,6 +12,7 @@ from ..database import get_db
|
||||
from ..deps import get_current_user, require_admin
|
||||
from ..models import (
|
||||
Category,
|
||||
CategoryMeasure,
|
||||
CategoryTracking,
|
||||
FieldDefinition,
|
||||
Product,
|
||||
@@ -82,7 +83,10 @@ def create_category(
|
||||
tracking = parent.tracking
|
||||
else:
|
||||
tracking = CategoryTracking.object.value
|
||||
category = Category(name=payload.name, parent_id=payload.parent_id, tracking=tracking)
|
||||
category = Category(
|
||||
name=payload.name, parent_id=payload.parent_id, tracking=tracking,
|
||||
open_days=payload.open_days,
|
||||
)
|
||||
db.add(category)
|
||||
db.commit()
|
||||
db.refresh(category)
|
||||
@@ -156,6 +160,11 @@ def delete_category(
|
||||
db.query(FieldDefinition).filter(
|
||||
FieldDefinition.category_id == category_id
|
||||
).delete(synchronize_session=False)
|
||||
# Hausmass-Mengen dieser Kategorie – aus demselben Grund ausdruecklich:
|
||||
# sonst blieben Waisen stehen und heften sich an neu vergebene IDs.
|
||||
db.query(CategoryMeasure).filter(
|
||||
CategoryMeasure.category_id == category_id
|
||||
).delete(synchronize_session=False)
|
||||
db.delete(category)
|
||||
db.commit()
|
||||
return Response(status_code=status.HTTP_204_NO_CONTENT)
|
||||
|
||||
@@ -283,14 +283,28 @@ def set_enforced(
|
||||
# --------------------------------------------------------------------------
|
||||
# Auswertungen
|
||||
# --------------------------------------------------------------------------
|
||||
def _zustand(best_before: date | None, heute: date, warnfrist: int) -> str:
|
||||
"""Ablaufzustand einer Charge: ohne MHD / abgelaufen / bald / in Ordnung."""
|
||||
def _zustand(
|
||||
best_before: date | None, heute: date, warnfrist: int, *, angebrochen: bool = False
|
||||
) -> str:
|
||||
"""Ablaufzustand einer Charge: abgelaufen / bald / angebrochen / ohne MHD / ok.
|
||||
|
||||
``best_before`` ist hier das WIRKSAME Datum – das frühere aus aufgedrucktem
|
||||
MHD und Verbrauchsdatum (``Lot.faellig_am``).
|
||||
|
||||
Vorrang: abgelaufen > bald ablaufend > angebrochen > in Ordnung.
|
||||
Dringlichkeit schlägt Zustand: Eine angebrochene Packung, die morgen weg
|
||||
muss, gehört in „bald ablaufend" – sonst verstoeckte der ruhigere Zustand
|
||||
die Warnung. „angebrochen" ist damit das, was offen ist und noch Zeit hat.
|
||||
"""
|
||||
if best_before is not None:
|
||||
if best_before < heute:
|
||||
return "expired"
|
||||
if (best_before - heute).days <= warnfrist:
|
||||
return "soon"
|
||||
if angebrochen:
|
||||
return "opened"
|
||||
if best_before is None:
|
||||
return "no_date"
|
||||
if best_before < heute:
|
||||
return "expired"
|
||||
if (best_before - heute).days <= warnfrist:
|
||||
return "soon"
|
||||
return "ok"
|
||||
|
||||
|
||||
@@ -321,7 +335,10 @@ def _bestand_beitraege(
|
||||
continue
|
||||
faktor, _label = article_unit(product)
|
||||
menge = lot.quantity / (faktor or 1.0)
|
||||
beitraege.append((product, menge, _zustand(lot.best_before, heute, warnfrist)))
|
||||
beitraege.append((
|
||||
product, menge,
|
||||
_zustand(lot.faellig_am, heute, warnfrist, angebrochen=lot.ist_angebrochen),
|
||||
))
|
||||
|
||||
for product in db.query(Product).filter(Product.individual.is_(True)).all():
|
||||
# Verliehene Stuecke sind nicht im Haus und zaehlen deshalb nicht mit.
|
||||
@@ -374,7 +391,7 @@ def expiry_split(
|
||||
) -> ExpirySplit:
|
||||
heute = date.today()
|
||||
warnfrist = get_expiry_warning_days(db)
|
||||
summen = {"ok": 0.0, "soon": 0.0, "expired": 0.0, "no_date": 0.0}
|
||||
summen = {"ok": 0.0, "soon": 0.0, "expired": 0.0, "opened": 0.0, "no_date": 0.0}
|
||||
for _product, menge, zustand in _bestand_beitraege(db, heute, warnfrist):
|
||||
summen[zustand] += menge
|
||||
return ExpirySplit(**{k: round(v, 3) for k, v in summen.items()})
|
||||
@@ -417,7 +434,10 @@ def by_category(
|
||||
rollup_cache[cid] = ziel
|
||||
return ziel
|
||||
|
||||
leer = lambda: {"article_units": 0.0, "ok": 0.0, "soon": 0.0, "expired": 0.0, "no_date": 0.0}
|
||||
leer = lambda: {
|
||||
"article_units": 0.0, "ok": 0.0, "soon": 0.0,
|
||||
"expired": 0.0, "opened": 0.0, "no_date": 0.0,
|
||||
}
|
||||
eimer: dict[int | None, dict] = defaultdict(leer)
|
||||
for product, menge, zustand in _bestand_beitraege(db, heute, warnfrist):
|
||||
topf = eimer[rollup(product.category_id)]
|
||||
|
||||
@@ -0,0 +1,297 @@
|
||||
"""Hausmaße: die Namen (Stammdaten) und ihre Mengen je Kategorie und Artikel.
|
||||
|
||||
Der Name ist global („Esslöffel"), die Menge nicht: 1 EL Mehl sind 10 g, 1 EL
|
||||
Zucker 12 g. Deshalb zwei Ebenen – ein Maß anlegen ist Stammdatenpflege, ihm
|
||||
eine Menge geben hängt an Kategorie oder Artikel.
|
||||
"""
|
||||
|
||||
# ACHTUNG: Hier steht bewusst KEIN ``from __future__ import annotations`` –
|
||||
# aus demselben Grund wie in package_types.py (``-> None`` wuerde als
|
||||
# Antwortmodell gewertet und bricht mit 204 den Start des Dienstes ab).
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, status
|
||||
from sqlalchemy import func
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from ..database import get_db
|
||||
from ..deps import get_current_user, require_admin
|
||||
from ..models import (
|
||||
Category,
|
||||
CategoryMeasure,
|
||||
Measure,
|
||||
Product,
|
||||
ProductMeasure,
|
||||
User,
|
||||
)
|
||||
from ..schemas import (
|
||||
MeasureAmountIn,
|
||||
MeasureAmountOut,
|
||||
MeasureIn,
|
||||
MeasureOut,
|
||||
)
|
||||
from ..services.conversion import PACKAGE_TOKENS, find_unit
|
||||
from ..services.vererbung import verfuegbare_masse
|
||||
|
||||
router = APIRouter(tags=["measures"])
|
||||
|
||||
|
||||
def _measure_or_404(db: Session, measure_id: int) -> Measure:
|
||||
measure = db.get(Measure, measure_id)
|
||||
if measure is None:
|
||||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Maß nicht gefunden")
|
||||
return measure
|
||||
|
||||
|
||||
def _pruefe_namen(db: Session, name: str, short: str | None, ausser_id: int | None = None) -> None:
|
||||
"""Name und Kurzform müssen eindeutig und frei von Kollisionen sein.
|
||||
|
||||
Ein Maß, das genauso heißt wie eine verwaltete Einheit oder wie „Packung",
|
||||
wäre dauerhaft unerreichbar: ``to_base`` prüft beide vorher. Lieber hier
|
||||
ablehnen als still etwas anlegen, das nie greift.
|
||||
"""
|
||||
for wert, feld in ((name, "Name"), (short, "Kurzform")):
|
||||
if not wert:
|
||||
continue
|
||||
t = wert.strip().lower()
|
||||
if t in PACKAGE_TOKENS:
|
||||
raise HTTPException(
|
||||
status.HTTP_409_CONFLICT,
|
||||
f"'{wert}' ist als Packungs-Angabe vergeben und würde nie greifen.",
|
||||
)
|
||||
if find_unit(db, t) is not None:
|
||||
raise HTTPException(
|
||||
status.HTTP_409_CONFLICT,
|
||||
f"'{wert}' ist bereits eine verwaltete Einheit. Als Maß würde es "
|
||||
f"nie greifen, weil Einheiten zuerst geprüft werden.",
|
||||
)
|
||||
doppelt = db.query(Measure).filter(
|
||||
(func.lower(Measure.name) == t) | (func.lower(Measure.short) == t)
|
||||
)
|
||||
if ausser_id is not None:
|
||||
doppelt = doppelt.filter(Measure.id != ausser_id)
|
||||
if doppelt.first() is not None:
|
||||
raise HTTPException(status.HTTP_409_CONFLICT, f"{feld} '{wert}' gibt es schon.")
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Stammdaten
|
||||
# --------------------------------------------------------------------------
|
||||
@router.get("/measures", response_model=list[MeasureOut])
|
||||
def list_measures(
|
||||
db: Session = Depends(get_db), _: User = Depends(get_current_user)
|
||||
) -> list[Measure]:
|
||||
return db.query(Measure).order_by(Measure.position, Measure.id).all()
|
||||
|
||||
|
||||
@router.post("/measures", response_model=MeasureOut, status_code=status.HTTP_201_CREATED)
|
||||
def create_measure(
|
||||
payload: MeasureIn,
|
||||
db: Session = Depends(get_db),
|
||||
_: User = Depends(require_admin),
|
||||
) -> Measure:
|
||||
_pruefe_namen(db, payload.name, payload.short)
|
||||
measure = Measure(
|
||||
name=payload.name.strip(),
|
||||
short=(payload.short or "").strip() or None,
|
||||
position=payload.position,
|
||||
)
|
||||
db.add(measure)
|
||||
db.commit()
|
||||
db.refresh(measure)
|
||||
return measure
|
||||
|
||||
|
||||
@router.patch("/measures/{measure_id}", response_model=MeasureOut)
|
||||
def update_measure(
|
||||
measure_id: int,
|
||||
payload: MeasureIn,
|
||||
db: Session = Depends(get_db),
|
||||
_: User = Depends(require_admin),
|
||||
) -> Measure:
|
||||
"""Umbenennen – auch bei eingebauten Maßen, wie bei Einheiten und Gebinden.
|
||||
|
||||
Die Mengen hängen an der ID, nicht am Namen, und wandern deshalb mit.
|
||||
"""
|
||||
measure = _measure_or_404(db, measure_id)
|
||||
_pruefe_namen(db, payload.name, payload.short, ausser_id=measure.id)
|
||||
measure.name = payload.name.strip()
|
||||
measure.short = (payload.short or "").strip() or None
|
||||
measure.position = payload.position
|
||||
db.commit()
|
||||
db.refresh(measure)
|
||||
return measure
|
||||
|
||||
|
||||
@router.delete("/measures/{measure_id}", status_code=status.HTTP_204_NO_CONTENT)
|
||||
def delete_measure(
|
||||
measure_id: int,
|
||||
db: Session = Depends(get_db),
|
||||
_: User = Depends(require_admin),
|
||||
) -> None:
|
||||
"""Maß löschen – samt aller Mengen, die daran hängen.
|
||||
|
||||
Die Mengen werden ausdrücklich abgeräumt: SQLite setzt Fremdschlüssel nicht
|
||||
ohne Weiteres um, sonst blieben Waisen stehen (gleiche Begründung wie in
|
||||
``delete_category``).
|
||||
"""
|
||||
measure = _measure_or_404(db, measure_id)
|
||||
if measure.is_builtin:
|
||||
raise HTTPException(
|
||||
status.HTTP_400_BAD_REQUEST,
|
||||
"Eingebaute Maße lassen sich nicht löschen – umbenennen geht aber.",
|
||||
)
|
||||
db.query(CategoryMeasure).filter(CategoryMeasure.measure_id == measure.id).delete()
|
||||
db.query(ProductMeasure).filter(ProductMeasure.measure_id == measure.id).delete()
|
||||
db.delete(measure)
|
||||
db.commit()
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Mengen je Kategorie und Artikel
|
||||
# --------------------------------------------------------------------------
|
||||
@router.get("/products/{product_id}/measures", response_model=list[MeasureAmountOut])
|
||||
def product_measures(
|
||||
product_id: int,
|
||||
db: Session = Depends(get_db),
|
||||
_: User = Depends(get_current_user),
|
||||
) -> list[MeasureAmountOut]:
|
||||
"""Die für diesen Artikel WIRKSAMEN Maße, mit Herkunft.
|
||||
|
||||
Grundlage für die Einheitenauswahl beim Verbrauchen – dort soll „EL" nur
|
||||
auftauchen, wenn dafür auch eine Menge bekannt ist.
|
||||
"""
|
||||
product = db.get(Product, product_id)
|
||||
if product is None:
|
||||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Artikel nicht gefunden")
|
||||
return [
|
||||
MeasureAmountOut(
|
||||
measure_id=a.measure.id, name=a.measure.name, short=a.measure.short,
|
||||
amount=a.amount, base=a.base, herkunft=a.herkunft,
|
||||
)
|
||||
for a in verfuegbare_masse(db, product)
|
||||
]
|
||||
|
||||
|
||||
@router.put("/products/{product_id}/measures/{measure_id}", response_model=MeasureAmountOut)
|
||||
def set_product_measure(
|
||||
product_id: int,
|
||||
measure_id: int,
|
||||
payload: MeasureAmountIn,
|
||||
db: Session = Depends(get_db),
|
||||
_: User = Depends(require_admin),
|
||||
) -> MeasureAmountOut:
|
||||
"""Menge nur für diesen Artikel – schlägt die der Kategorie."""
|
||||
product = db.get(Product, product_id)
|
||||
if product is None:
|
||||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Artikel nicht gefunden")
|
||||
measure = _measure_or_404(db, measure_id)
|
||||
row = (
|
||||
db.query(ProductMeasure)
|
||||
.filter(ProductMeasure.product_id == product.id,
|
||||
ProductMeasure.measure_id == measure.id)
|
||||
.first()
|
||||
)
|
||||
if row is None:
|
||||
row = ProductMeasure(product_id=product.id, measure_id=measure.id,
|
||||
amount=payload.amount, base=payload.base.value)
|
||||
db.add(row)
|
||||
else:
|
||||
row.amount = payload.amount
|
||||
row.base = payload.base.value
|
||||
db.commit()
|
||||
return MeasureAmountOut(
|
||||
measure_id=measure.id, name=measure.name, short=measure.short,
|
||||
amount=row.amount, base=row.base, herkunft="Artikel",
|
||||
)
|
||||
|
||||
|
||||
@router.delete("/products/{product_id}/measures/{measure_id}",
|
||||
status_code=status.HTTP_204_NO_CONTENT)
|
||||
def delete_product_measure(
|
||||
product_id: int,
|
||||
measure_id: int,
|
||||
db: Session = Depends(get_db),
|
||||
_: User = Depends(require_admin),
|
||||
) -> None:
|
||||
"""Eigene Menge entfernen – danach gilt wieder die der Kategorie."""
|
||||
db.query(ProductMeasure).filter(
|
||||
ProductMeasure.product_id == product_id,
|
||||
ProductMeasure.measure_id == measure_id,
|
||||
).delete()
|
||||
db.commit()
|
||||
|
||||
|
||||
@router.get("/categories/{category_id}/measures", response_model=list[MeasureAmountOut])
|
||||
def category_measures(
|
||||
category_id: int,
|
||||
db: Session = Depends(get_db),
|
||||
_: User = Depends(get_current_user),
|
||||
) -> list[MeasureAmountOut]:
|
||||
"""Die an DIESER Kategorie hinterlegten Mengen (ohne die geerbten).
|
||||
|
||||
Bewusst ohne Vererbung: Diese Liste ist die Bearbeitungsansicht. Was ein
|
||||
Artikel am Ende wirklich bekommt, zeigt ``/products/{id}/measures``.
|
||||
"""
|
||||
if db.get(Category, category_id) is None:
|
||||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Kategorie nicht gefunden")
|
||||
rows = (
|
||||
db.query(CategoryMeasure, Measure)
|
||||
.join(Measure, CategoryMeasure.measure_id == Measure.id)
|
||||
.filter(CategoryMeasure.category_id == category_id)
|
||||
.order_by(Measure.position, Measure.id)
|
||||
.all()
|
||||
)
|
||||
return [
|
||||
MeasureAmountOut(
|
||||
measure_id=m.id, name=m.name, short=m.short,
|
||||
amount=cm.amount, base=cm.base, herkunft="Kategorie",
|
||||
)
|
||||
for cm, m in rows
|
||||
]
|
||||
|
||||
|
||||
@router.put("/categories/{category_id}/measures/{measure_id}", response_model=MeasureAmountOut)
|
||||
def set_category_measure(
|
||||
category_id: int,
|
||||
measure_id: int,
|
||||
payload: MeasureAmountIn,
|
||||
db: Session = Depends(get_db),
|
||||
_: User = Depends(require_admin),
|
||||
) -> MeasureAmountOut:
|
||||
"""Menge für eine Kategorie – gilt auch für ihre Unterkategorien."""
|
||||
if db.get(Category, category_id) is None:
|
||||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Kategorie nicht gefunden")
|
||||
measure = _measure_or_404(db, measure_id)
|
||||
row = (
|
||||
db.query(CategoryMeasure)
|
||||
.filter(CategoryMeasure.category_id == category_id,
|
||||
CategoryMeasure.measure_id == measure.id)
|
||||
.first()
|
||||
)
|
||||
if row is None:
|
||||
row = CategoryMeasure(category_id=category_id, measure_id=measure.id,
|
||||
amount=payload.amount, base=payload.base.value)
|
||||
db.add(row)
|
||||
else:
|
||||
row.amount = payload.amount
|
||||
row.base = payload.base.value
|
||||
db.commit()
|
||||
return MeasureAmountOut(
|
||||
measure_id=measure.id, name=measure.name, short=measure.short,
|
||||
amount=row.amount, base=row.base, herkunft="Kategorie",
|
||||
)
|
||||
|
||||
|
||||
@router.delete("/categories/{category_id}/measures/{measure_id}",
|
||||
status_code=status.HTTP_204_NO_CONTENT)
|
||||
def delete_category_measure(
|
||||
category_id: int,
|
||||
measure_id: int,
|
||||
db: Session = Depends(get_db),
|
||||
_: User = Depends(require_admin),
|
||||
) -> None:
|
||||
db.query(CategoryMeasure).filter(
|
||||
CategoryMeasure.category_id == category_id,
|
||||
CategoryMeasure.measure_id == measure_id,
|
||||
).delete()
|
||||
db.commit()
|
||||
@@ -6,6 +6,7 @@ from ..database import get_db
|
||||
from ..deps import get_current_user, require_admin
|
||||
from ..models import Setting, User
|
||||
from ..schemas import SettingOut
|
||||
from ..services.vererbung import globale_oeffnungsfrist
|
||||
|
||||
router = APIRouter(prefix="/settings", tags=["settings"])
|
||||
|
||||
@@ -19,6 +20,11 @@ SESSION_DAYS_KEY = "session_days"
|
||||
# Zehn Jahre. Wer laenger will, nimmt "unbegrenzt" – ein Token mit einem
|
||||
# Ablauf im naechsten Jahrhundert waere dasselbe, nur unehrlicher.
|
||||
SESSION_DAYS_MAX = 3650
|
||||
# Wie lange eine angebrochene Packung gilt, wenn weder Artikel noch Kategorie
|
||||
# etwas sagen. Pflichtwert: Ohne ihn haette eine offene Packung kein
|
||||
# Verbrauchsdatum, und das Anbrechen waere sinnlos.
|
||||
OPEN_DAYS_KEY = "open_days"
|
||||
OPEN_DAYS_MAX = 3650
|
||||
|
||||
|
||||
def get_expiry_warning_days(db: Session) -> int:
|
||||
@@ -76,6 +82,7 @@ def list_settings(
|
||||
known.setdefault(EXPIRY_WARNING_KEY, str(get_expiry_warning_days(db)))
|
||||
known.setdefault(RECEIPT_THRESHOLD_KEY, str(get_receipt_match_threshold(db)))
|
||||
known.setdefault(SESSION_DAYS_KEY, str(get_session_days(db)))
|
||||
known.setdefault(OPEN_DAYS_KEY, str(globale_oeffnungsfrist(db)))
|
||||
return [SettingOut(key=k, value=v) for k, v in known.items()]
|
||||
|
||||
|
||||
@@ -86,6 +93,17 @@ def set_setting(
|
||||
db: Session = Depends(get_db),
|
||||
_: User = Depends(require_admin),
|
||||
) -> SettingOut:
|
||||
if key == OPEN_DAYS_KEY:
|
||||
# Gleiche Begruendung wie unten: ein Tippfehler darf nicht still auf die
|
||||
# Vorgabe zurueckfallen, waehrend der Admin glaubt, er haette etwas gesetzt.
|
||||
try:
|
||||
tage = int(value)
|
||||
except ValueError:
|
||||
raise HTTPException(400, "Haltbarkeit nach dem Anbrechen muss eine Zahl in Tagen sein")
|
||||
if not 1 <= tage <= OPEN_DAYS_MAX:
|
||||
raise HTTPException(400, f"Haltbarkeit nach dem Anbrechen: 1 bis {OPEN_DAYS_MAX} Tage")
|
||||
value = str(tage)
|
||||
|
||||
if key == SESSION_DAYS_KEY:
|
||||
# Ohne diese Pruefung wuerde get_session_days einen Tippfehler still
|
||||
# auf die Vorgabe zurueckdrehen – und der Admin glaubte, es sei gesetzt.
|
||||
|
||||
@@ -13,6 +13,9 @@ from ..schemas import (
|
||||
CheckInResponse,
|
||||
CheckOutRequest,
|
||||
CheckOutResponse,
|
||||
LotConsume,
|
||||
LotConsumeOut,
|
||||
LotOpen,
|
||||
LotOut,
|
||||
LotRow,
|
||||
LotSplit,
|
||||
@@ -25,6 +28,8 @@ from ..services.conversion import ConversionError, display_unit_info
|
||||
from ..services.dates import clean_precision, normalize_best_before
|
||||
from ..services.stock import (
|
||||
StockError,
|
||||
abspalten,
|
||||
anbrechen,
|
||||
check_in,
|
||||
check_out,
|
||||
check_out_lot,
|
||||
@@ -33,6 +38,7 @@ from ..services.stock import (
|
||||
object_add,
|
||||
object_relocate,
|
||||
object_remove,
|
||||
verbrauchen,
|
||||
)
|
||||
|
||||
router = APIRouter(tags=["stock"])
|
||||
@@ -321,32 +327,16 @@ def split_lot(
|
||||
lot = db.get(Lot, lot_id)
|
||||
if lot is None:
|
||||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Charge nicht gefunden")
|
||||
# Nur echt weniger als die Gesamtmenge lässt sich abteilen – die ganze Menge
|
||||
# zu verschieben ist Sache des Lagerort-Feldes, nicht des Aufteilens.
|
||||
if payload.quantity >= lot.quantity - 1e-9:
|
||||
raise HTTPException(
|
||||
status.HTTP_400_BAD_REQUEST,
|
||||
"So viel enthält die Charge nicht – zum kompletten Umlagern das "
|
||||
"Lagerort-Feld nutzen.",
|
||||
)
|
||||
if (payload.location_id or None) == (lot.location_id or None):
|
||||
raise HTTPException(
|
||||
status.HTTP_400_BAD_REQUEST,
|
||||
"Bitte einen anderen Lagerort als den aktuellen wählen.",
|
||||
)
|
||||
if payload.location_id is not None and db.get(Location, payload.location_id) is None:
|
||||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Lagerort nicht gefunden")
|
||||
|
||||
lot.quantity -= payload.quantity
|
||||
neu = Lot(
|
||||
product_id=lot.product_id,
|
||||
quantity=payload.quantity,
|
||||
best_before=lot.best_before,
|
||||
best_before_precision=lot.best_before_precision,
|
||||
location_id=payload.location_id,
|
||||
)
|
||||
db.add(neu)
|
||||
db.flush()
|
||||
# Die eigentliche Arbeit macht der Dienst; hier gilt weiter die strengere
|
||||
# Variante: nur echt weniger als die Gesamtmenge, und nur an einen ANDEREN
|
||||
# Ort. Das Anbrechen benutzt dieselbe Funktion mit gelockerten Regeln.
|
||||
try:
|
||||
neu = abspalten(db, lot, payload.quantity, payload.location_id)
|
||||
except StockError as fehler:
|
||||
raise HTTPException(status.HTTP_400_BAD_REQUEST, str(fehler)) from fehler
|
||||
# Liegt am Zielort schon eine Charge mit gleichem MHD, verschmelzen beide.
|
||||
survivor = consolidate_lot_group(
|
||||
db, lot.product_id, neu.best_before, neu.best_before_precision, payload.location_id
|
||||
@@ -356,6 +346,83 @@ def split_lot(
|
||||
return survivor
|
||||
|
||||
|
||||
@router.post("/lots/{lot_id}/open", response_model=LotOut)
|
||||
def open_lot(
|
||||
lot_id: int,
|
||||
payload: LotOpen,
|
||||
db: Session = Depends(get_db),
|
||||
_: User = Depends(get_current_user),
|
||||
) -> Lot:
|
||||
"""Eine Packung der Charge anbrechen und als eigene Charge führen.
|
||||
|
||||
Aus 4 × 1 l wird eine offene Charge mit 1 l (mit Verbrauchsdatum) und eine
|
||||
ungeöffnete mit 3 l. Bewusst **ohne** anschließende Konsolidierung: Die
|
||||
offene Packung soll gerade nicht mit der ungeöffneten verschmelzen.
|
||||
"""
|
||||
lot = db.get(Lot, lot_id)
|
||||
if lot is None:
|
||||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Charge nicht gefunden")
|
||||
product = db.get(Product, lot.product_id)
|
||||
if product is None:
|
||||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Artikel nicht gefunden")
|
||||
if product_tracking(db, product) == OBJECT:
|
||||
raise HTTPException(
|
||||
status.HTTP_400_BAD_REQUEST,
|
||||
"Nur Chargen lassen sich anbrechen. Gegenstände, die nur als Menge "
|
||||
"je Lagerort geführt werden, haben keine Packung.",
|
||||
)
|
||||
try:
|
||||
offen = anbrechen(db, product, lot, payload.quantity)
|
||||
except StockError as fehler:
|
||||
raise HTTPException(status.HTTP_400_BAD_REQUEST, str(fehler)) from fehler
|
||||
db.commit()
|
||||
db.refresh(offen)
|
||||
return offen
|
||||
|
||||
|
||||
@router.post("/lots/{lot_id}/consume", response_model=LotConsumeOut)
|
||||
def consume_lot(
|
||||
lot_id: int,
|
||||
payload: LotConsume,
|
||||
db: Session = Depends(get_db),
|
||||
user: User = Depends(get_current_user),
|
||||
) -> LotConsumeOut:
|
||||
"""Teilmenge aus einer Charge verbrauchen („100 ml verwendet", „2 EL").
|
||||
|
||||
War die Charge noch zu, wird sie dabei angebrochen (``auto_open``) – die
|
||||
Rückfrage dazu stellt die Oberfläche. Die Einheit kennt neben den
|
||||
verwalteten Einheiten auch die Hausmaße der Kategorie.
|
||||
"""
|
||||
lot = db.get(Lot, lot_id)
|
||||
if lot is None:
|
||||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Charge nicht gefunden")
|
||||
product = db.get(Product, lot.product_id)
|
||||
if product is None:
|
||||
raise HTTPException(status.HTTP_404_NOT_FOUND, "Artikel nicht gefunden")
|
||||
if product_tracking(db, product) == OBJECT:
|
||||
raise HTTPException(
|
||||
status.HTTP_400_BAD_REQUEST,
|
||||
"Gegenstände werden über 'Entfernen' (mit Grund) gebucht, nicht verbraucht.",
|
||||
)
|
||||
try:
|
||||
affected, offen, geoeffnet = verbrauchen(
|
||||
db, product, lot, payload.quantity, payload.unit, user,
|
||||
payload.note, payload.auto_open,
|
||||
)
|
||||
except ConversionError as fehler:
|
||||
raise HTTPException(status.HTTP_400_BAD_REQUEST, str(fehler)) from fehler
|
||||
except StockError as fehler:
|
||||
raise HTTPException(status.HTTP_409_CONFLICT, str(fehler)) from fehler
|
||||
db.commit()
|
||||
if offen is not None:
|
||||
db.refresh(offen)
|
||||
return LotConsumeOut(
|
||||
affected_lots=affected,
|
||||
lot=LotOut.model_validate(offen) if offen is not None else None,
|
||||
opened=geoeffnet,
|
||||
)
|
||||
|
||||
|
||||
@router.patch("/lots/{lot_id}", response_model=LotOut)
|
||||
def update_lot(
|
||||
lot_id: int,
|
||||
|
||||
@@ -260,6 +260,11 @@ def export_backup_json(
|
||||
"best_before": lot.best_before.isoformat() if lot.best_before else None,
|
||||
"best_before_precision": lot.best_before_precision,
|
||||
"location": loc_name.get(lot.location_id),
|
||||
# Angebrochene Packungen sollen eine Sicherung ueberleben –
|
||||
# sonst waere nach dem Zurueckspielen alles wieder zu.
|
||||
"opened_on": lot.opened_on.isoformat() if lot.opened_on else None,
|
||||
"consume_by": lot.consume_by.isoformat() if lot.consume_by else None,
|
||||
"opened_quantity": lot.opened_quantity,
|
||||
}
|
||||
for lot in lots
|
||||
],
|
||||
@@ -346,6 +351,27 @@ def export_labels(
|
||||
# --------------------------------------------------------------------------
|
||||
# Import (nur additiv)
|
||||
# --------------------------------------------------------------------------
|
||||
def _parse_tag(value) -> "date | None":
|
||||
"""ISO-Datum aus einer Sicherung lesen; Muell wird still zu None.
|
||||
|
||||
Der Import ist bewusst additiv und soll nicht an einer einzelnen Zeile
|
||||
scheitern – dieselbe Haltung wie bei ``_parse_best_before``.
|
||||
"""
|
||||
if not value:
|
||||
return None
|
||||
try:
|
||||
return date.fromisoformat(str(value)[:10])
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
def _zahl_oder_none(value) -> float | None:
|
||||
try:
|
||||
return float(value) if value is not None else None
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def _num(value) -> float | None:
|
||||
if value is None:
|
||||
return None
|
||||
@@ -989,6 +1015,9 @@ def _import_json(db: Session, content: bytes, user: User, mode: str) -> dict:
|
||||
best_before=best_before,
|
||||
best_before_precision=precision,
|
||||
location_id=location.id if location else None,
|
||||
opened_on=_parse_tag(lot_entry.get("opened_on")),
|
||||
consume_by=_parse_tag(lot_entry.get("consume_by")),
|
||||
opened_quantity=_zahl_oder_none(lot_entry.get("opened_quantity")),
|
||||
)
|
||||
db.add(lot)
|
||||
db.flush()
|
||||
|
||||
@@ -5,6 +5,7 @@ from datetime import date, timedelta
|
||||
from typing import Callable, TypeVar
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, status
|
||||
from sqlalchemy import and_, or_
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from ..database import get_db
|
||||
@@ -531,14 +532,26 @@ def expiring(
|
||||
today = date.today()
|
||||
threshold = today + timedelta(days=days)
|
||||
|
||||
# Gewarnt wird nach dem FRÜHEREN von MHD und Verbrauchsdatum. Die frühere
|
||||
# Vorbedingung „best_before IS NOT NULL" musste weg: Eine angebrochene
|
||||
# Packung ohne aufgedrucktes MHD hat nur ein Verbrauchsdatum – und genau um
|
||||
# die geht es hier.
|
||||
lots = (
|
||||
db.query(Lot)
|
||||
.filter(Lot.best_before.isnot(None), Lot.best_before <= threshold, Lot.quantity > 0)
|
||||
.order_by(Lot.best_before)
|
||||
.filter(
|
||||
Lot.quantity > 0,
|
||||
or_(
|
||||
and_(Lot.best_before.isnot(None), Lot.best_before <= threshold),
|
||||
and_(Lot.consume_by.isnot(None), Lot.consume_by <= threshold),
|
||||
),
|
||||
)
|
||||
.all()
|
||||
)
|
||||
result: list[ExpiringItem] = []
|
||||
for lot in lots:
|
||||
faellig = lot.faellig_am
|
||||
if faellig is None:
|
||||
continue # kann nicht vorkommen, der Filter oben schliesst es aus
|
||||
product = lot.product
|
||||
unit_name, unit_factor = display_unit_info(product)
|
||||
result.append(
|
||||
@@ -550,13 +563,23 @@ def expiring(
|
||||
base_unit=product.base_unit,
|
||||
best_before=lot.best_before,
|
||||
best_before_precision=lot.best_before_precision,
|
||||
days_left=(lot.best_before - today).days,
|
||||
opened_on=lot.opened_on,
|
||||
consume_by=lot.consume_by,
|
||||
warn_date=faellig,
|
||||
warn_source=(
|
||||
"consume_by" if lot.consume_by is not None and faellig == lot.consume_by
|
||||
else "best_before"
|
||||
),
|
||||
days_left=(faellig - today).days,
|
||||
package_size=product.package_size,
|
||||
package_label=product.package_label,
|
||||
unit_name=unit_name,
|
||||
unit_factor=unit_factor,
|
||||
)
|
||||
)
|
||||
# Nach dem wirksamen Datum sortieren – in Python, wie in _fefo_lots, damit
|
||||
# SQLite und Postgres dasselbe liefern.
|
||||
result.sort(key=lambda e: (e.warn_date, e.lot_id))
|
||||
return result
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user