Gruppen und Kategorien getrennt, EAN-Codes an der Gruppe automatisch gefuehrt

Die Umbenennung von Gruppen in "Kategorien" war falsch: Es sind zwei
verschiedene Dinge. Sie ist zurueckgenommen, Kategorien kommen als eigene Ebene
dazu.

GRUPPE zaehlt Bestaende mehrerer Marken zusammen - Mehl von Rewe, Aldi und
Migros ergeben "5 kg Mehl". Dafuer Mindestbestand mit Einheit und EAN-Codes.
KATEGORIE ordnet allein die Artikelliste ("zeig mir alle Suesswaren"), ist
verschachtelbar wie ein Lagerort und hat weder Bestand noch EAN-Codes. Ein
Artikel kann beides, eines oder keines haben.

Die Vermischung war aelter als die Umbenennung: guessGroup in offUtils.js hat
aus der Open-Food-Facts-KATEGORIE eine GRUPPE geraten. Das ist entfernt. Die
OFF-Einordnung steuert jetzt die Kategorie, wo sie hingehoert; eine Gruppe
entsteht nur ueber einen hinterlegten Gruppen-Code oder bewusste Auswahl.

EAN-Codes an der Gruppe: Das war kein Anzeigefehler. Beim Anlegen eines Artikels
wurde ausschliesslich group_id gesetzt - ein Gruppen-Code entstand nie, die
Liste war tatsaechlich leer. Die Meldung "bereits vergeben" kam daher, dass der
Code am Artikel hing. Jetzt pflegt services/group_codes.py den Code mit: beim
Zuordnen kommt er hinzu, beim Gruppenwechsel wandert er mit, beim Entfernen der
Gruppe oder Loeschen des Artikels verschwindet er. Beim Scannen aendert sich
nichts an der Reihenfolge - der Artikel wird weiterhin zuerst gefunden; der
Gruppen-Eintrag ist Beleg in der Verwaltung und Rueckfall. Traegt man denselben
Code von Hand nach, ist das kein Fehler mehr, sondern die Auskunft, dass er ueber
den Artikel bereits dort steht.

Kategorien im Backend: neue Tabelle mit parent_id (Muster von Location),
products.category_id per ADD COLUMN IF NOT EXISTS nachgezogen, deutsche
zweistufige Startliste analog zu den eingebauten Einheiten. Die Startliste wird
nur angelegt, wenn ueberhaupt noch keine Kategorie existiert - wer sie bewusst
leerraeumt, findet sie nicht wieder. Beim Setzen einer Oberkategorie wird
geprueft, dass keine Kategorie sich selbst oder einem eigenen Nachfahren
untergeordnet wird; sonst entstuende ein Ring und jede Baumdarstellung liefe
endlos. Der Produktfilter schliesst Unterkategorien ein, category_id=0 liefert
die Artikel ohne Kategorie. Export und Import fuehren die Kategorie als Pfad
("Suesswaren & Snacks > Schokolade") in einer Spalte, damit die CSV in Excel
bedienbar bleibt.

Web: neue Seite Kategorien mit Baumdarstellung, Filter ueber der Produktliste,
getrennte Auswahlfelder im Produktformular mit je einer Zeile Erklaerung, und
beim Einlagern laesst sich eine Gruppe samt Einheit und Mindestbestand direkt
anlegen, ohne den Vorgang zu verlassen.

iOS: Kategorie-Filter ueber der Produktliste, Unterkategorien eingerueckt. Die
Artikelzeile nennt jetzt das Gebinde und warnt, wenn der Mindestbestand
unterschritten ist (rot) oder weniger als ein Viertel Luft bleibt (orange).
Getrennte Auswahlfelder fuer Kategorie und Gruppe, Gruppe direkt anlegbar.

Ausserdem die Eingabefelder in der App: .textFieldStyle(.roundedBorder) zeichnet
in der dunklen Darstellung einen fast schwarzen Kasten. Ersetzt durch eine
Systemfuellung, die sich Hell und Dunkel anpasst und zurueckhaltend bleibt.

Getestet: 54 pytest-Tests gruen, 14 davon neu (Nachfahren-Sammler, OFF-Zuordnung
inklusive Vorrang der Unterkategorie, und die komplette Codepflege an der
Gruppe). Gegen die laufende API geprueft: Startliste ohne Dubletten, Filter auf
Ober- und Unterkategorie, Ringschutz, Loeschen einer Kategorie laesst Artikel
und Unterkategorien bestehen, Export/Import-Rundlauf mit Kategoriepfad, und der
Durchlauf aus der Meldung - Artikel mit Gruppe anlegen, Code steht danach in der
Gruppe. Web-Build und iOS-Geraetebuild fehler- und warnungsfrei.
Die Oberflaechen habe ich nicht selbst bedient.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

ios/Sources/ListViews.swift

@@ -5,10 +5,10 @@ func formatAmount(_ value: Double) -> String {
     value == value.rounded() ? String(Int(value)) : String(format: "%.2f", value)
 }
 
-/// Kennzeichnung "Kategorie" an einer Listenzeile.
-struct CategoryBadge: View {
+/// Kennzeichnung "Gruppe" an einer Listenzeile.
+struct GroupBadge: View {
     var body: some View {
-        Text("Kategorie")
+        Text("Gruppe")
             .font(.caption2)
             .padding(.horizontal, 6)
             .padding(.vertical, 2)
@@ -18,7 +18,7 @@ struct CategoryBadge: View {
     }
 }
 
-/// Zeile mit Symbol links, damit Artikel und Kategorie unterscheidbar sind.
+/// Zeile mit Symbol links, damit Artikel und Gruppe unterscheidbar sind.
 struct ListRow<Trailing: View>: View {
     let systemImage: String
     let title: String
@@ -70,13 +70,13 @@ struct ShoppingListView: View {
                 }
             }
             if !groups.isEmpty {
-                Section("Kategorien unter Mindestbestand") {
+                Section("Gruppen unter Mindestbestand") {
                     ForEach(groups) { group in
                         ListRow(
                             systemImage: "square.stack.3d.up",
                             title: group.name,
                             subtitle: "fehlt \(formatAmount(group.deficit)) \(group.unitName) · \(group.productCount) Artikel"
-                        ) { CategoryBadge() }
+                        ) { GroupBadge() }
                     }
                 }
             }
@@ -173,23 +173,49 @@ struct ExpiringView: View {
 struct ProductListView: View {
     @State private var query = ""
     @State private var products: [Product] = []
+    @State private var categories: [CategoryItem] = []
+    /// nil = alle, 0 = ohne Kategorie, sonst die ID (Unterkategorien zaehlen mit).
+    @State private var categoryId: Int?
     @State private var busy = false
 
+    private var filterLabel: String {
+        if categoryId == 0 { return "Ohne Kategorie" }
+        if let id = categoryId, let treffer = categories.first(where: { $0.id == id }) {
+            return treffer.name
+        }
+        return "Alle Kategorien"
+    }
+
     var body: some View {
         List {
-            ForEach(products) { product in
-                NavigationLink {
-                    ProductDetailView(product: product)
+            Section {
+                Menu {
+                    Button("Alle Kategorien") { pick(nil) }
+                    Button("Ohne Kategorie") { pick(0) }
+                    Divider()
+                    ForEach(categoryTree()) { eintrag in
+                        Button(eintrag.label) { pick(eintrag.item.id) }
+                    }
                 } label: {
-                    ListRow(
-                        systemImage: "shippingbox",
-                        title: product.name,
-                        subtitle: "\(formatAmount(product.stockInArticleUnits)) \(product.articleUnitLabel)"
-                    ) { EmptyView() }
+                    HStack {
+                        Label("Kategorie", systemImage: "line.3.horizontal.decrease.circle")
+                        Spacer()
+                        Text(filterLabel).foregroundStyle(.secondary)
+                    }
                 }
             }
-            if products.isEmpty && !busy {
-                Text("Keine Treffer").foregroundStyle(.secondary)
+
+            Section {
+                ForEach(products) { product in
+                    NavigationLink {
+                        ProductDetailView(product: product)
+                    } label: {
+                        ProductRow(product: product)
+                    }
+                }
+                if products.isEmpty && !busy {
+                    Text("Keine Treffer").foregroundStyle(.secondary)
+                }
             }
         }
         .searchable(text: $query, prompt: "Artikel suchen")
@@ -197,12 +223,89 @@ struct ProductListView: View {
         .navigationTitle("Produkte")
         .navigationBarTitleDisplayMode(.inline)
         .refreshable { await load() }
-        .task { await load() }
+        .task {
+            categories = (try? await APIClient.shared.categories()) ?? []
+            await load()
+        }
+    }
+
+    private func pick(_ id: Int?) {
+        categoryId = id
+        Task { await load() }
+    }
+
+    /// Kategorien in Baumreihenfolge mit eingerueckter Beschriftung.
+    private struct TreeEntry: Identifiable {
+        let item: CategoryItem
+        let depth: Int
+        var id: Int { item.id }
+        var label: String { String(repeating: "   ", count: depth) + item.name }
+    }
+
+    private func categoryTree() -> [TreeEntry] {
+        let ids = Set(categories.map(\.id))
+        var result: [TreeEntry] = []
+
+        func walk(_ node: CategoryItem, _ depth: Int) {
+            result.append(TreeEntry(item: node, depth: depth))
+            for child in categories.filter({ $0.parentId == node.id }) {
+                walk(child, depth + 1)
+            }
+        }
+        // Waisen (Oberkategorie geloescht) gelten als oberste Ebene.
+        for root in categories.filter({ $0.parentId == nil || !ids.contains($0.parentId!) }) {
+            walk(root, 0)
+        }
+        return result
     }
 
     private func load() async {
         busy = true
         defer { busy = false }
-        products = (try? await APIClient.shared.searchProducts(query)) ?? []
+        products = (try? await APIClient.shared.searchProducts(query, categoryId: categoryId)) ?? []
+    }
+}
+
+/// Artikelzeile mit Gebinde und Hinweis auf den Mindestbestand.
+struct ProductRow: View {
+    let product: Product
+
+    var body: some View {
+        HStack(spacing: 12) {
+            Image(systemName: "shippingbox")
+                .font(.body).foregroundStyle(.secondary).frame(width: 24)
+            VStack(alignment: .leading, spacing: 2) {
+                Text(product.name)
+                Text(bestand)
+                    .font(.caption).foregroundStyle(.secondary)
+                if let hinweis = mindestbestand {
+                    Text(hinweis).font(.caption2).foregroundStyle(farbe)
+                }
+            }
+            Spacer()
+        }
+    }
+
+    private var bestand: String {
+        var text = "\(formatAmount(product.stockInArticleUnits)) \(product.articleUnitLabel)"
+        // Bei einem Gebinde die Basismenge dahinter, damit "2 Glas" greifbar wird.
+        if let size = product.packageSize, size > 0 {
+            text += " · à \(formatAmount(size)) \(DisplaySettings.baseUnitLabel(product.baseUnit))"
+        }
+        return text
+    }
+
+    private var mindestbestand: String? {
+        guard let anzeige = product.minStockDisplay else { return nil }
+        let einheit = product.minStockUnitLabel ?? ""
+        switch product.stockLevel {
+        case .below: return "unter Mindestbestand (\(formatAmount(anzeige)) \(einheit))"
+        case .close: return "bald nachkaufen (Minimum \(formatAmount(anzeige)) \(einheit))"
+        case .ok, .none: return nil
+        }
+    }
+
+    private var farbe: Color {
+        product.stockLevel == .below ? .red : .orange
     }
 }