Einkaufsliste bekommt ein Gedaechtnis - und den Knopf aus dem Rezept
Die Einkaufsliste war vollstaendig GERECHNET: Artikel unter ihrem
Mindestbestand, Gruppen unter ihrem, Bedarfe je Lagerort. Das bleibt, es
ist die Staerke der Liste. Was fehlte, war ein Ort fuer "Milch gehoert
drauf, weil ich das sage" - und damit auch fuer "diese Zutaten fehlen mir
fuer das Rezept". Der Knopf konnte nirgends hinschreiben.
Zwei Tabellen dafuer, und die Trennung ist der Kern:
shopping_entries haelt, was jemand bewusst draufgesetzt hat. Genau eines
von Artikel, Gruppe oder Freitext - der Freitext ist unverzichtbar, denn
eine Rezeptzutat ohne Artikel ("Ras el Hanout") kommt nur so auf den
Zettel, und gerade die unbekannte Zutat ist die, die man vergisst.
shopping_checks haelt nur den HAKEN an einem gerechneten Posten, nicht
den Posten. Die gerechneten Vorschlaege duerfen keine Zeile bekommen: Sie
aendern sich mit jedem Einlagern, eine materialisierte Kopie waere sofort
falsch. Abhaken ging deshalb bisher nur im Browser und war nach dem
Neuladen weg - mitten im Supermarkt.
Aus einem Rezept uebernommen wird die FEHLMENGE, nicht die Rezeptmenge:
Wer 250 g braucht und 100 g hat, kauft 150 g. Gerechnet wird frisch mit
der Portionszahl, die auf dem Schirm steht. Je Rezept und Ziel gibt es
hoechstens einen offenen Eintrag - ein zweiter Druck nach dem Hochdrehen
der Portionen rechnet die Menge neu, statt die Liste zu verdoppeln. Ueber
verschiedene Rezepte hinweg bleiben es getrennte Zeilen, denn derselbe
Artikel kann zweimal fehlen. Ein abgehakter Eintrag blockiert nichts -
abgehakt heisst gekauft.
Mengen formatiert dieselbe Funktion wie beim Rezeptabgleich, damit die
Liste eine Sprache spricht: "2 Packungen" statt "1500 ml", aufgerundet,
weil man keine halbe Packung kauft.
In der Oberfläche eine eigene Karte "Selbst draufgesetzt" mit Eingabefeld,
Herkunftsangabe ("fuer Pfannkuchen") und "Erledigte entfernen", das beide
Quellen zusammen aufraeumt - fuer den Nutzer ist es eine Liste. Das
Abhaken wandert sofort und speichert im Hintergrund; schlaegt es fehl,
springt der Haken zurueck. Die Seite holt jetzt alles mit einem Aufruf
statt mit drei.
Von Hand geprueft gegen eine Mealie-Attrappe: Pfannkuchen fuer 48
Portionen ergibt 2 Packungen Mehl, 2 Packungen Milch, 3 Packungen Eier
und "Ras el Hanout" als Notiz; derselbe Knopf bei 96 Portionen
aktualisiert diese vier statt acht daraus zu machen; ein Haken
ueberlebt das Neuladen. 17 neue Tests, Suite bei 512.
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
f02e9a3840
commit
795e233a1b
@@ -0,0 +1,287 @@
|
||||
"""Die gespeicherte Seite der Einkaufsliste.
|
||||
|
||||
Gerechnet wird die Liste in ``routers/views.py`` – Artikel unter ihrem
|
||||
Mindestbestand, Gruppen unter ihrem, Bedarfe je Lagerort. Das bleibt so. Hier
|
||||
liegt daneben das, was jemand **bewusst** draufgesetzt hat: eigene Einträge,
|
||||
übernommene Rezeptzutaten, und das dauerhafte Abhaken der gerechneten
|
||||
Vorschläge.
|
||||
|
||||
Beides getrennt zu halten ist Absicht. Die gerechneten Posten dürfen keine
|
||||
Zeilen in der Datenbank bekommen: Sie ändern sich mit jedem Einlagern, und eine
|
||||
materialisierte Kopie würde sofort von der Wirklichkeit abweichen. Was gemerkt
|
||||
wird, ist nur der Haken daran.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from ..models import (
|
||||
Group,
|
||||
Product,
|
||||
ShoppingCheck,
|
||||
ShoppingEntry,
|
||||
User,
|
||||
)
|
||||
from .einkaufsliste_text import fehlmengen_text
|
||||
|
||||
|
||||
class EintragFehler(ValueError):
|
||||
"""Unbrauchbarer Eintrag – der Router macht daraus eine 400."""
|
||||
|
||||
|
||||
def _jetzt() -> datetime:
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Eigene Einträge
|
||||
# --------------------------------------------------------------------------
|
||||
def eintraege(db: Session, *, mit_erledigten: bool = True) -> list[ShoppingEntry]:
|
||||
"""Alle gespeicherten Einträge, offene zuerst.
|
||||
|
||||
Zeigt ein Eintrag auf einen Artikel oder eine Gruppe, die es nicht mehr
|
||||
gibt, fällt er hier still heraus: Auf SQLite greift kein Fremdschlüssel, und
|
||||
einen gelöschten Artikel kann man nicht einkaufen.
|
||||
"""
|
||||
reihen = db.query(ShoppingEntry).order_by(
|
||||
ShoppingEntry.done, ShoppingEntry.created_at
|
||||
).all()
|
||||
gueltig = [e for e in reihen if _ziel_existiert(db, e)]
|
||||
if mit_erledigten:
|
||||
return gueltig
|
||||
return [e for e in gueltig if not e.done]
|
||||
|
||||
|
||||
def _ziel_existiert(db: Session, eintrag: ShoppingEntry) -> bool:
|
||||
if eintrag.product_id is not None:
|
||||
return db.get(Product, eintrag.product_id) is not None
|
||||
if eintrag.group_id is not None:
|
||||
return db.get(Group, eintrag.group_id) is not None
|
||||
return bool(eintrag.free_text)
|
||||
|
||||
|
||||
def bezeichnung(db: Session, eintrag: ShoppingEntry) -> str:
|
||||
"""Was auf dem Zettel steht."""
|
||||
if eintrag.product_id is not None:
|
||||
produkt = db.get(Product, eintrag.product_id)
|
||||
return produkt.name if produkt is not None else ""
|
||||
if eintrag.group_id is not None:
|
||||
gruppe = db.get(Group, eintrag.group_id)
|
||||
return gruppe.name if gruppe is not None else ""
|
||||
return eintrag.free_text or ""
|
||||
|
||||
|
||||
@dataclass
|
||||
class _Menge:
|
||||
"""Die Form, die ``fehlmengen_text`` erwartet.
|
||||
|
||||
Umweg mit Absicht: So formatiert die Einkaufsliste ihre Mengen mit genau
|
||||
derselben Funktion wie der Rezeptabgleich („2 Packungen" statt „1000 ml",
|
||||
aufgerundet auf ganze Gebinde). Zwei Formatierungen wuerden auseinander
|
||||
laufen.
|
||||
"""
|
||||
|
||||
art: str
|
||||
ziel_id: int | None
|
||||
fehlt_base: float | None
|
||||
basis_einheit: str
|
||||
|
||||
|
||||
def mengen_text(db: Session, eintrag: ShoppingEntry) -> str:
|
||||
"""„2 Packungen" bzw. „150 g" – leer, wenn keine Menge dransteht."""
|
||||
if not eintrag.quantity_base:
|
||||
return ""
|
||||
art = "product" if eintrag.product_id is not None else "group"
|
||||
return fehlmengen_text(db, _Menge(
|
||||
art=art, ziel_id=eintrag.product_id or eintrag.group_id,
|
||||
fehlt_base=eintrag.quantity_base, basis_einheit=eintrag.base or "",
|
||||
))
|
||||
|
||||
|
||||
def anlegen(
|
||||
db: Session,
|
||||
*,
|
||||
product_id: int | None = None,
|
||||
group_id: int | None = None,
|
||||
free_text: str | None = None,
|
||||
quantity_base: float | None = None,
|
||||
base: str | None = None,
|
||||
source: str = "manual",
|
||||
recipe_slug: str | None = None,
|
||||
recipe_name: str | None = None,
|
||||
user: User | None = None,
|
||||
) -> ShoppingEntry:
|
||||
"""Einen Eintrag anlegen. Genau ein Ziel, und es muss existieren."""
|
||||
text = (free_text or "").strip() or None
|
||||
ziele = [z for z in (product_id, group_id, text) if z is not None]
|
||||
if len(ziele) != 1:
|
||||
raise EintragFehler(
|
||||
"Ein Eintrag zeigt auf genau eines: einen Artikel, eine Gruppe oder "
|
||||
"einen freien Text."
|
||||
)
|
||||
if product_id is not None and db.get(Product, product_id) is None:
|
||||
raise EintragFehler("Diesen Artikel gibt es nicht.")
|
||||
if group_id is not None and db.get(Group, group_id) is None:
|
||||
raise EintragFehler("Diese Gruppe gibt es nicht.")
|
||||
if quantity_base is not None and quantity_base <= 0:
|
||||
raise EintragFehler("Eine Menge muss größer als 0 sein.")
|
||||
|
||||
eintrag = ShoppingEntry(
|
||||
product_id=product_id, group_id=group_id, free_text=text,
|
||||
quantity_base=quantity_base, base=base, source=source,
|
||||
recipe_slug=recipe_slug, recipe_name=recipe_name,
|
||||
created_by=(user.id if user is not None else None),
|
||||
)
|
||||
db.add(eintrag)
|
||||
db.commit()
|
||||
db.refresh(eintrag)
|
||||
return eintrag
|
||||
|
||||
|
||||
def abhaken(db: Session, eintrag: ShoppingEntry, done: bool) -> ShoppingEntry:
|
||||
eintrag.done = done
|
||||
eintrag.done_at = _jetzt() if done else None
|
||||
db.commit()
|
||||
db.refresh(eintrag)
|
||||
return eintrag
|
||||
|
||||
|
||||
def loeschen(db: Session, eintrag: ShoppingEntry) -> None:
|
||||
db.delete(eintrag)
|
||||
db.commit()
|
||||
|
||||
|
||||
def erledigte_entfernen(db: Session) -> int:
|
||||
"""Alles Abgehakte weg – eigene Einträge und die Haken an den gerechneten.
|
||||
|
||||
Ein Durchgang nach dem Einkauf. Bewusst beides zusammen: Für den Nutzer ist
|
||||
es eine Liste, auch wenn sie aus zwei Quellen kommt.
|
||||
"""
|
||||
anzahl = 0
|
||||
for eintrag in db.query(ShoppingEntry).filter(ShoppingEntry.done.is_(True)).all():
|
||||
db.delete(eintrag)
|
||||
anzahl += 1
|
||||
for haken in db.query(ShoppingCheck).all():
|
||||
db.delete(haken)
|
||||
anzahl += 1
|
||||
db.commit()
|
||||
return anzahl
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Haken an den gerechneten Posten
|
||||
# --------------------------------------------------------------------------
|
||||
def abgehakte(db: Session) -> list[str]:
|
||||
return [h.key for h in db.query(ShoppingCheck).all()]
|
||||
|
||||
|
||||
def haken_setzen(db: Session, key: str, user: User | None = None) -> None:
|
||||
sauber = (key or "").strip()[:80]
|
||||
if not sauber:
|
||||
raise EintragFehler("Ohne Kennung lässt sich kein Haken merken.")
|
||||
if db.get(ShoppingCheck, sauber) is None:
|
||||
db.add(ShoppingCheck(
|
||||
key=sauber, user_id=(user.id if user is not None else None),
|
||||
))
|
||||
db.commit()
|
||||
|
||||
|
||||
def haken_loesen(db: Session, key: str) -> None:
|
||||
haken = db.get(ShoppingCheck, (key or "").strip()[:80])
|
||||
if haken is not None:
|
||||
db.delete(haken)
|
||||
db.commit()
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Aus einem Rezept übernehmen
|
||||
# --------------------------------------------------------------------------
|
||||
def aus_rezept(
|
||||
db: Session,
|
||||
pruefungen: list,
|
||||
*,
|
||||
slug: str,
|
||||
name: str,
|
||||
user: User | None = None,
|
||||
) -> tuple[list[ShoppingEntry], int]:
|
||||
"""Was für dieses Rezept fehlt, auf die Liste setzen.
|
||||
|
||||
Übernommen wird, was fehlt oder zu wenig ist — mit der **Fehlmenge**, nicht
|
||||
der Rezeptmenge: Wer 250 g braucht und 100 g hat, kauft 150 g.
|
||||
|
||||
Zutaten ohne Zuordnung kommen als Freitext drauf. Das ist der wichtigere
|
||||
Teil, als es klingt: Gerade die unbekannte Zutat ist die, die man vergisst.
|
||||
|
||||
Je Rezept und Ziel gibt es höchstens einen offenen Eintrag. Ein zweiter
|
||||
Druck auf den Knopf — etwa nach dem Hochdrehen der Portionen — rechnet die
|
||||
Menge neu, statt die Liste zu verdoppeln. Über verschiedene Rezepte hinweg
|
||||
bleiben es getrennte Zeilen, denn derselbe Artikel kann zweimal fehlen.
|
||||
|
||||
Rückgabe: die betroffenen Einträge und wie viele davon aktualisiert (statt
|
||||
neu angelegt) wurden.
|
||||
"""
|
||||
betroffen: list[ShoppingEntry] = []
|
||||
aktualisiert = 0
|
||||
|
||||
for p in pruefungen:
|
||||
if p.status in ("fehlt", "zu_wenig"):
|
||||
menge = p.fehlt_base if p.fehlt_base else None
|
||||
vorhanden = _offener_eintrag(
|
||||
db, slug, product_id=(p.ziel_id if p.art == "product" else None),
|
||||
group_id=(p.ziel_id if p.art == "group" else None),
|
||||
)
|
||||
if vorhanden is not None:
|
||||
vorhanden.quantity_base = menge
|
||||
vorhanden.base = p.basis_einheit or None
|
||||
aktualisiert += 1
|
||||
betroffen.append(vorhanden)
|
||||
continue
|
||||
betroffen.append(anlegen(
|
||||
db,
|
||||
product_id=(p.ziel_id if p.art == "product" else None),
|
||||
group_id=(p.ziel_id if p.art == "group" else None),
|
||||
quantity_base=menge, base=p.basis_einheit or None,
|
||||
source="recipe", recipe_slug=slug, recipe_name=name, user=user,
|
||||
))
|
||||
elif p.status == "kein_treffer":
|
||||
text = (p.food or p.text or "").strip()[:120]
|
||||
if not text:
|
||||
continue
|
||||
vorhanden = _offener_eintrag(db, slug, free_text=text)
|
||||
if vorhanden is not None:
|
||||
aktualisiert += 1
|
||||
betroffen.append(vorhanden)
|
||||
continue
|
||||
betroffen.append(anlegen(
|
||||
db, free_text=text, source="recipe",
|
||||
recipe_slug=slug, recipe_name=name, user=user,
|
||||
))
|
||||
|
||||
db.commit()
|
||||
return betroffen, aktualisiert
|
||||
|
||||
|
||||
def _offener_eintrag(
|
||||
db: Session,
|
||||
slug: str,
|
||||
*,
|
||||
product_id: int | None = None,
|
||||
group_id: int | None = None,
|
||||
free_text: str | None = None,
|
||||
) -> ShoppingEntry | None:
|
||||
"""Ein noch nicht abgehakter Eintrag dieses Rezepts für dasselbe Ziel."""
|
||||
frage = db.query(ShoppingEntry).filter(
|
||||
ShoppingEntry.recipe_slug == slug,
|
||||
ShoppingEntry.done.is_(False),
|
||||
)
|
||||
if product_id is not None:
|
||||
frage = frage.filter(ShoppingEntry.product_id == product_id)
|
||||
elif group_id is not None:
|
||||
frage = frage.filter(ShoppingEntry.group_id == group_id)
|
||||
else:
|
||||
frage = frage.filter(ShoppingEntry.free_text == free_text)
|
||||
return frage.first()
|
||||
Reference in New Issue
Block a user