Eigene Felder: Spalten in der Artikelliste und Export nach Feldwerten
Eigene Felder waren bisher nur im Artikelformular zu sehen. Zwei Luecken
daraus: In den Listen tauchten sie gar nicht auf, und es gab keinen Weg,
gezielt nach einem Feldwert zu exportieren.
SPALTEN. Je eigenem Feld eine Spalte in der Artikelliste, Schluessel
feld:<id> wie im Etikettenexport (die ID und nicht key, der ist nur je
Kategorie eindeutig). Reine Oberflaechenarbeit: GET /products liefert die
Werte laengst mit, Products.jsx warf sie nur weg. Filtern, Sortieren,
Ein-/Ausblenden und das Merken erbt die Spalte von DataTable.
Ja/Nein erscheint als Haken, liefert zum Filtern aber "Ja"/"Nein" - und
"Nein" auch ohne gespeicherten Wert: Wer den Haken wegnimmt, loescht die
Zeile, "nein" und "nie gesetzt" sind in den Daten dasselbe. Zahlen sortieren
als Zahl, sonst stuende "10" vor "9".
DataTable lernt dafuer defaultHidden: Alle Feldspalten starten verborgen und
sind erst auf Wunsch da - sonst hinge die Liste je nach Haushalt voller
Spalten, die fuer die meisten Zeilen gar nicht gelten.
Dabei einen vorhandenen Fehler gefunden: urlState las die Sortierung mit
split(":") und nahm das erste Stueck als Spalte. Bei "feld:12:asc" kam
dadurch "feld" heraus, und die Sortierung fiel beim Neuladen still weg. Jetzt
am LETZTEN Doppelpunkt getrennt.
EXPORT. Die Etikettenvorlagen bekommen einen Wertefilter: feldfilter in der
Konfiguration, mehrere Bedingungen UND-verknuepft, genau verglichen ohne
Ruecksicht auf Gross-/Kleinschreibung, leerer Wert heisst "ohne Wert".
Gefiltert wird in Python ueber die ohnehin geladenen Feldwerte - auf value
liegt kein Index, und "fehlende Zeile zaehlt als leer" braeuchte in SQL je
Bedingung ein NOT EXISTS.
Der Filter gilt auch fuer Einzelstuecke; der Wert haengt am Artikel des
Stuecks. Ein geloeschtes Feld laesst seine Bedingung wegfallen, genau wie
eine Spalte zu einem geloeschten Feld still verschwindet.
Die Sicherung schreibt den Filter wie die Spalten auf Kategorie::Label um -
ohne das zeigte er nach dem Zurueckspielen auf ein fremdes Feld, und der
Export gaebe mehr Zeilen aus als das Original. Dafuer ist _konfiguration aus
dem Router als konfiguration_schreiben in den Dienst gezogen: Sonst haetten
DREI Stellen denselben JSON-Text gebaut.
Zehn neue Tests, 540 gruen. Keine Schemaaenderung - konfiguration ist freies
JSON, alte Vorlagen lesen sich als leerer Filter.
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
83f7134459
commit
dd57d3356a
@@ -54,7 +54,7 @@ def kabel(db):
|
||||
return cat, fd
|
||||
|
||||
|
||||
def _vorlage(db, spalten, art="items", kategorie_ids=None, trenn=","):
|
||||
def _vorlage(db, spalten, art="items", kategorie_ids=None, trenn=",", feldfilter=None):
|
||||
v = EtikettenVorlage(
|
||||
name=f"Test {len(db.query(EtikettenVorlage).all())}",
|
||||
art=art,
|
||||
@@ -62,6 +62,7 @@ def _vorlage(db, spalten, art="items", kategorie_ids=None, trenn=","):
|
||||
"spalten": spalten,
|
||||
"kategorie_ids": kategorie_ids or [],
|
||||
"trennzeichen": trenn,
|
||||
"feldfilter": feldfilter or [],
|
||||
}),
|
||||
)
|
||||
db.add(v)
|
||||
@@ -226,7 +227,12 @@ def test_kaputte_konfiguration_ergibt_vorgaben(db):
|
||||
db.commit()
|
||||
|
||||
konf = konfiguration_lesen(v)
|
||||
assert konf == {"spalten": [], "kategorie_ids": [], "trennzeichen": ","}
|
||||
assert konf == {
|
||||
"spalten": [],
|
||||
"kategorie_ids": [],
|
||||
"trennzeichen": ",",
|
||||
"feldfilter": [],
|
||||
}
|
||||
|
||||
|
||||
def test_unerlaubtes_trennzeichen_faellt_auf_komma_zurueck(db):
|
||||
@@ -399,3 +405,236 @@ def test_lbx_mit_schlichtem_namen_bleibt_unveraendert(db, admin):
|
||||
|
||||
assert 'filename="kabel.lbx"' in antwort.headers["content-disposition"]
|
||||
_disposition_pruefen(antwort, "kabel.lbx")
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Wertefilter: nur Zeilen mit bestimmten Feldwerten
|
||||
# --------------------------------------------------------------------------
|
||||
@pytest.fixture()
|
||||
def haken(db):
|
||||
"""Kategorie „Kleidung" mit einem Ja/Nein-Feld „Verliehen"."""
|
||||
cat = Category(name="Kleidung", tracking=CategoryTracking.object.value)
|
||||
db.add(cat)
|
||||
db.flush()
|
||||
fd = FieldDefinition(
|
||||
category_id=cat.id, label="Verliehen", key="verliehen", field_type="boolean"
|
||||
)
|
||||
db.add(fd)
|
||||
db.commit()
|
||||
db.refresh(cat)
|
||||
db.refresh(fd)
|
||||
return cat, fd
|
||||
|
||||
|
||||
def _artikel(db, cat, name, fd=None, wert=None):
|
||||
"""Artikel, optional mit einem Feldwert. ``wert=None`` legt KEINE Zeile an."""
|
||||
product = Product(name=name, category_id=cat.id, package_size=1)
|
||||
db.add(product)
|
||||
db.flush()
|
||||
if fd is not None and wert is not None:
|
||||
db.add(ProductFieldValue(
|
||||
product_id=product.id, field_definition_id=fd.id, value=wert
|
||||
))
|
||||
db.commit()
|
||||
db.refresh(product)
|
||||
return product
|
||||
|
||||
|
||||
def _namen(db, vorlage):
|
||||
"""Die Namensspalte des erzeugten CSV, ohne Kopfzeile."""
|
||||
return _zeilen(csv_erzeugen(db, vorlage))[1:]
|
||||
|
||||
|
||||
def test_feldfilter_waehlt_nur_passende_artikel(db, haken):
|
||||
cat, fd = haken
|
||||
_artikel(db, cat, "Jacke", fd, "true")
|
||||
_artikel(db, cat, "Hose", fd, "false")
|
||||
v = _vorlage(db, ["name"], art="products",
|
||||
feldfilter=[{"feld_id": fd.id, "wert": "ja"}])
|
||||
|
||||
assert _namen(db, v) == ["Jacke"]
|
||||
|
||||
|
||||
def test_feldfilter_nein_trifft_auch_artikel_ohne_zeile(db, haken):
|
||||
"""Der Kern: Haken wegnehmen loescht die Zeile.
|
||||
|
||||
„nein" und „nie gesetzt" sind in den Daten dasselbe. Ohne diese Gleichung
|
||||
faende „alle mit Nein" nur die, die einmal angehakt und wieder abgehakt
|
||||
wurden – und das ist fast niemand.
|
||||
"""
|
||||
cat, fd = haken
|
||||
_artikel(db, cat, "Jacke", fd, "true")
|
||||
_artikel(db, cat, "Hose", fd, "false")
|
||||
_artikel(db, cat, "Schal") # nie angefasst, gar keine Zeile
|
||||
v = _vorlage(db, ["name"], art="products",
|
||||
feldfilter=[{"feld_id": fd.id, "wert": "nein"}])
|
||||
|
||||
assert sorted(_namen(db, v)) == ["Hose", "Schal"]
|
||||
|
||||
|
||||
def test_leerer_wert_trifft_artikel_ohne_wert(db, kabel):
|
||||
cat, fd = kabel
|
||||
_artikel(db, cat, "Mit Laenge", fd, "5")
|
||||
_artikel(db, cat, "Ohne Laenge")
|
||||
v = _vorlage(db, ["name"], art="products",
|
||||
feldfilter=[{"feld_id": fd.id, "wert": ""}])
|
||||
|
||||
assert _namen(db, v) == ["Ohne Laenge"]
|
||||
|
||||
|
||||
def test_feldfilter_vergleicht_genau_nicht_teilweise(db, kabel):
|
||||
cat, fd = kabel
|
||||
_artikel(db, cat, "Kurz", fd, "3")
|
||||
_artikel(db, cat, "Lang", fd, "30")
|
||||
v = _vorlage(db, ["name"], art="products",
|
||||
feldfilter=[{"feld_id": fd.id, "wert": "3"}])
|
||||
|
||||
assert _namen(db, v) == ["Kurz"]
|
||||
|
||||
|
||||
def test_mehrere_bedingungen_muessen_alle_zutreffen(db, haken):
|
||||
cat, fd_bool = haken
|
||||
fd_text = FieldDefinition(
|
||||
category_id=cat.id, label="Farbe", key="farbe", field_type="text"
|
||||
)
|
||||
db.add(fd_text)
|
||||
db.commit()
|
||||
db.refresh(fd_text)
|
||||
|
||||
blau = _artikel(db, cat, "Blaue Jacke", fd_bool, "true")
|
||||
db.add(ProductFieldValue(
|
||||
product_id=blau.id, field_definition_id=fd_text.id, value="blau"
|
||||
))
|
||||
rot = _artikel(db, cat, "Rote Jacke", fd_bool, "true")
|
||||
db.add(ProductFieldValue(
|
||||
product_id=rot.id, field_definition_id=fd_text.id, value="rot"
|
||||
))
|
||||
db.commit()
|
||||
|
||||
v = _vorlage(db, ["name"], art="products", feldfilter=[
|
||||
{"feld_id": fd_bool.id, "wert": "ja"},
|
||||
{"feld_id": fd_text.id, "wert": "blau"},
|
||||
])
|
||||
|
||||
assert _namen(db, v) == ["Blaue Jacke"]
|
||||
|
||||
|
||||
def test_feldfilter_und_kategorie_greifen_zusammen(db, haken):
|
||||
cat, fd = haken
|
||||
zweite = Category(name="Werkzeug", tracking=CategoryTracking.object.value)
|
||||
db.add(zweite)
|
||||
db.commit()
|
||||
db.refresh(zweite)
|
||||
|
||||
_artikel(db, cat, "Jacke", fd, "true")
|
||||
# Gleicher Feldwert, andere Kategorie – die Kategorie muss ihn aussperren.
|
||||
fremder = _artikel(db, zweite, "Hammer")
|
||||
db.add(ProductFieldValue(
|
||||
product_id=fremder.id, field_definition_id=fd.id, value="true"
|
||||
))
|
||||
db.commit()
|
||||
|
||||
v = _vorlage(db, ["name"], art="products", kategorie_ids=[cat.id],
|
||||
feldfilter=[{"feld_id": fd.id, "wert": "ja"}])
|
||||
|
||||
assert _namen(db, v) == ["Jacke"]
|
||||
|
||||
|
||||
def test_feldfilter_wirkt_auch_bei_einzelstuecken(db, haken):
|
||||
"""Der Wert haengt am Artikel – das Stueck erbt ihn."""
|
||||
cat, fd = haken
|
||||
verliehen = _artikel(db, cat, "Jacke", fd, "true")
|
||||
daheim = _artikel(db, cat, "Hose", fd, "false")
|
||||
db.add(Item(uid="UIDAAAAA", product_id=verliehen.id))
|
||||
db.add(Item(uid="UIDBBBBB", product_id=daheim.id))
|
||||
db.commit()
|
||||
|
||||
v = _vorlage(db, ["produkt"], art="items",
|
||||
feldfilter=[{"feld_id": fd.id, "wert": "ja"}])
|
||||
|
||||
assert _namen(db, v) == ["Jacke"]
|
||||
|
||||
|
||||
def test_geloeschtes_feld_im_filter_zerreisst_den_export_nicht(db, haken):
|
||||
"""Wie bei einer Spalte zu einem geloeschten Feld: die Bedingung faellt weg.
|
||||
|
||||
Der Export wird dadurch WEITER, nicht leer – die harmlosere der beiden
|
||||
Fehlrichtungen, und hier festgehalten, damit sie nicht versehentlich kippt.
|
||||
"""
|
||||
cat, fd = haken
|
||||
_artikel(db, cat, "Jacke", fd, "true")
|
||||
_artikel(db, cat, "Hose", fd, "false")
|
||||
v = _vorlage(db, ["name"], art="products",
|
||||
feldfilter=[{"feld_id": fd.id, "wert": "ja"}])
|
||||
db.delete(fd)
|
||||
db.commit()
|
||||
|
||||
assert sorted(_namen(db, v)) == ["Hose", "Jacke"]
|
||||
|
||||
|
||||
def test_kaputter_feldfilter_ergibt_keinen_filter(db):
|
||||
for nr, roh in enumerate(('{"feldfilter": "quatsch"}',
|
||||
'{"feldfilter": [{"feld_id": "abc"}]}',
|
||||
'{"feldfilter": [42]}')):
|
||||
v = EtikettenVorlage(name=f"Kaputt {nr}", art="items", konfiguration=roh)
|
||||
db.add(v)
|
||||
db.commit()
|
||||
assert konfiguration_lesen(v)["feldfilter"] == []
|
||||
|
||||
|
||||
def test_feldfilter_uebersteht_die_sicherung(db, haken):
|
||||
"""Feld-IDs sind zwischen zwei Instanzen nicht dieselben.
|
||||
|
||||
Deshalb steht in der Sicherung „Kategorie::Label" statt einer ID – und
|
||||
zwar fuer Spalten UND Filter. Fehlte die Umschreibung beim Filter, zeigte
|
||||
er nach dem Zurueckspielen auf ein fremdes Feld oder waere still weg, und
|
||||
der Export gaebe mehr Zeilen aus als das Original.
|
||||
"""
|
||||
import json as _json
|
||||
|
||||
from app.routers.transfer import _import_json, export_backup_json
|
||||
from app.seed import ensure_builtin_units
|
||||
|
||||
cat, fd = haken
|
||||
person = User(username="chef", password_hash="x", role=Role.admin)
|
||||
db.add(person)
|
||||
_artikel(db, cat, "Jacke", fd, "true")
|
||||
_artikel(db, cat, "Hose", fd, "false")
|
||||
v = _vorlage(db, ["name"], art="products",
|
||||
feldfilter=[{"feld_id": fd.id, "wert": "ja"}])
|
||||
v.name = "Verliehenes"
|
||||
db.commit()
|
||||
|
||||
inhalt = export_backup_json(db=db, _=person).body
|
||||
gesichert = _json.loads(inhalt)["etiketten_vorlagen"][0]
|
||||
# Nach Pfad und Label, nie nach ID.
|
||||
assert gesichert["feldfilter"] == [{"feld": "Kleidung::Verliehen", "wert": "ja"}]
|
||||
|
||||
from app.database import Base
|
||||
from sqlalchemy import create_engine
|
||||
from sqlalchemy.orm import sessionmaker
|
||||
from sqlalchemy.pool import StaticPool
|
||||
|
||||
motor = create_engine(
|
||||
"sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool
|
||||
)
|
||||
Base.metadata.create_all(bind=motor)
|
||||
zweite = sessionmaker(bind=motor)()
|
||||
ensure_builtin_units(zweite)
|
||||
zweiter_nutzer = User(username="chef", password_hash="x", role=Role.admin)
|
||||
zweite.add(zweiter_nutzer)
|
||||
zweite.commit()
|
||||
|
||||
_import_json(zweite, inhalt, zweiter_nutzer, "add")
|
||||
|
||||
neu = zweite.query(EtikettenVorlage).filter(
|
||||
EtikettenVorlage.name == "Verliehenes"
|
||||
).one()
|
||||
neues_feld = zweite.query(FieldDefinition).filter(
|
||||
FieldDefinition.label == "Verliehen"
|
||||
).one()
|
||||
konf = konfiguration_lesen(neu)
|
||||
# Auf die ID der ZWEITEN Instanz umgeschrieben, Wert unveraendert.
|
||||
assert konf["feldfilter"] == [{"feld_id": neues_feld.id, "wert": "ja"}]
|
||||
assert _namen(zweite, neu) == ["Jacke"]
|
||||
zweite.close()
|
||||
|
||||
Reference in New Issue
Block a user