Vodafone: Zuordnung über Kundennamen in GROSSBUCHSTABEN, feste Händler-Zuweisung, nur erste Seite

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

provtool/db.py

@@ -11,7 +11,7 @@ from pathlib import Path
 from provtool.importer import ImportErgebnis
 from provtool.money import apply_percent
 
-SCHEMA_VERSION = 1
+SCHEMA_VERSION = 2
 
 SCHEMA = """
 CREATE TABLE IF NOT EXISTS meta (schluessel TEXT PRIMARY KEY, wert TEXT);
@@ -83,6 +83,16 @@ CREATE INDEX IF NOT EXISTS ix_position_abr ON position(abrechnung_id);
 
 UNZUGEORDNET = 0  # Pseudo-Händler-ID für Positionen ohne bekannte Kennung
 
+# Sonder-Kennung: Vodafone-Positionen, deren Kundenname komplett in GROSSBUCHSTABEN steht
+# (so erfasst ein Unterhändler seine Kunden). Hat Vorrang vor der VO-Nr.
+CAPS_ANBIETER = "vodafone_caps"
+CAPS_WERT = "*"
+
+
+def ist_grossgeschrieben(name: str | None) -> bool:
+    buchstaben = [c for c in (name or "") if c.isalpha() and c != "ß"]
+    return len(buchstaben) >= 2 and all(c.isupper() for c in buchstaben)
+
 
 @dataclass
 class Haendler:
@@ -107,9 +117,18 @@ class Datenbank:
         self.con.row_factory = sqlite3.Row
         self.con.execute("PRAGMA foreign_keys = ON")
         self.con.executescript(SCHEMA)
+        self._migrieren()
         self.con.execute("INSERT OR IGNORE INTO meta VALUES ('schema_version', ?)", (str(SCHEMA_VERSION),))
         self.con.commit()
 
+    def _migrieren(self):
+        spalten = {r[1] for r in self.con.execute("PRAGMA table_info(position)")}
+        if "haendler_fest" not in spalten:
+            # NULL = automatisch über Kennungen, sonst fest zugewiesene Händler-ID (0 = bewusst keiner)
+            self.con.execute("ALTER TABLE position ADD COLUMN haendler_fest INTEGER")
+        self.con.execute("UPDATE meta SET wert=? WHERE schluessel='schema_version'", (str(SCHEMA_VERSION),))
+        self.con.commit()
+
     def close(self):
         self.con.close()
 
@@ -163,6 +182,9 @@ class Datenbank:
                 besitzer = self.con.execute("SELECT h.name FROM kennung k JOIN haendler h ON h.id=k.haendler_id "
                                             "WHERE k.anbieter=? AND k.wert=?", (anbieter, wert)).fetchone()
                 if besitzer:
+                    if anbieter == CAPS_ANBIETER:
+                        raise ValueError("Die Regel „Vodafone-Kundenname in GROSSBUCHSTABEN“ ist bereits dem "
+                                         f"Händler „{besitzer[0]}“ zugeordnet – sie kann nur einen Händler haben.")
                     raise ValueError(f"Die Kennung {wert} ({anbieter}) ist bereits dem Händler „{besitzer[0]}“ zugeordnet.")
                 self.con.execute("INSERT INTO kennung (haendler_id, anbieter, wert) VALUES (?,?,?)", (hid, anbieter, wert))
         return hid
@@ -179,6 +201,20 @@ class Datenbank:
         return {(r[0], r[1]): r[2] for r in self.con.execute(
             "SELECT k.anbieter, k.wert, k.haendler_id FROM kennung k JOIN haendler h ON h.id=k.haendler_id WHERE h.aktiv=1")}
 
+    def zuordner(self):
+        """Liefert eine Funktion (anbieter, kennung, name, haendler_fest) -> Händler-ID."""
+        kmap = self.kennung_map()
+        caps = kmap.get((CAPS_ANBIETER, CAPS_WERT))
+        aktive = {h.id for h in self.haendler_liste(nur_aktive=True)}
+
+        def finde(anbieter: str, kennung: str, name: str | None = None, fest: int | None = None) -> int:
+            if fest is not None:
+                return fest if (fest == UNZUGEORDNET or fest in aktive) else UNZUGEORDNET
+            if caps and anbieter == "vodafone" and ist_grossgeschrieben(name):
+                return caps
+            return kmap.get((anbieter, kennung), UNZUGEORDNET)
+        return finde
+
     # ------------------------------------------------------------------ Regeln
     def regeln(self, hid: int) -> dict[str, float]:
         return {r[0]: r[1] for r in self.con.execute(
@@ -241,7 +277,7 @@ class Datenbank:
             self.con.execute("DELETE FROM abrechnung_datei WHERE id=?", (datei_id,))
 
     def importieren(self, aid: int, erg: ImportErgebnis) -> int:
-        kmap = self.kennung_map()
+        finde = self.zuordner()
         start = self.con.execute("SELECT coalesce(max(reihenfolge), 0) FROM position WHERE abrechnung_id=?",
                                  (aid,)).fetchone()[0]
         with self.con:
@@ -250,7 +286,7 @@ class Datenbank:
                 (aid, erg.datei, erg.sha256, erg.format, _now(), len(erg.positionen)))
             did = cur.lastrowid
             for i, p in enumerate(erg.positionen, start=start + 1):
-                hid = kmap.get((p.anbieter, p.kennung), UNZUGEORDNET)
+                hid = finde(p.anbieter, p.kennung, p.name)
                 proz = self.prozent_fuer(hid, p.provisionsart)
                 self.con.execute(
                     "INSERT INTO position (abrechnung_id, datei_id, reihenfolge, anbieter, zeitraum, provisionsart, kennung, "
@@ -265,14 +301,31 @@ class Datenbank:
 
     def positionen(self, aid: int) -> list[dict]:
         """Alle Positionen mit aktueller Händler-Zuordnung (über die Kennungen)."""
-        kmap = self.kennung_map()
+        finde = self.zuordner()
         out = []
         for r in self.con.execute("SELECT * FROM position WHERE abrechnung_id=? ORDER BY reihenfolge", (aid,)):
             d = dict(r)
-            d["haendler_id"] = kmap.get((d["anbieter"], d["kennung"]), UNZUGEORDNET)
+            d["haendler_id"] = finde(d["anbieter"], d["kennung"], d["name"], d["haendler_fest"])
             out.append(d)
         return out
 
+    def haendler_zuweisen(self, pids: list[int], hid: int | None) -> None:
+        """Weist Positionen fest einem Händler zu (hid=None: wieder automatisch zuordnen).
+        Nicht manuell geänderte Beträge werden nach den Regeln des neuen Händlers berechnet."""
+        with self.con:
+            for pid in pids:
+                self.con.execute("UPDATE position SET haendler_fest=? WHERE id=?", (hid, pid))
+        finde = self.zuordner()
+        with self.con:
+            for pid in pids:
+                r = self.con.execute("SELECT * FROM position WHERE id=?", (pid,)).fetchone()
+                if r is None or r["manuell"]:
+                    continue
+                neu_hid = finde(r["anbieter"], r["kennung"], r["name"], r["haendler_fest"])
+                proz = self.prozent_fuer(neu_hid, r["provisionsart"])
+                self.con.execute("UPDATE position SET betrag=?, prozent=? WHERE id=?",
+                                 (apply_percent(r["betrag_orig"], proz), proz, pid))
+
     def betrag_setzen(self, pid: int, cent: int) -> None:
         with self.con:
             self.con.execute("UPDATE position SET betrag=?, manuell=1, prozent=NULL WHERE id=?", (cent, pid))

provtool/gui/app.py

@@ -116,6 +116,8 @@ class App:
         h = tk.Menu(m, tearoff=0)
         h.add_command(label="Händler verwalten…", accelerator="Strg+H", command=self.haendler)
         h.add_command(label="Kennung des Eintrags zuordnen…", command=self.kennung_zuordnen_auswahl)
+        h.add_command(label="Auswahl fest einem Händler zuweisen…", command=self.haendler_zuweisen)
+        h.add_command(label="Auswahl automatisch zuordnen", command=lambda: self.haendler_zuweisen(automatisch=True))
         m.add_cascade(label="Händler", menu=h, underline=0)
 
         hi = tk.Menu(m, tearoff=0)
@@ -328,7 +330,8 @@ class App:
                 kunde = " ".join(x for x in (p["vorname"], p["name"]) if x) or "(ohne Name)"
                 t.insert(giid, "end", iid=f"p{p['id']}", text=kunde,
                          values=(_datum_de(p["datum"]), p["rufnummer"], p["tarif"], _zeitraum_kurz(p["zeitraum"]),
-                                 p["kennung"], fmt(p["betrag_orig"]),
+                                 p["kennung"] + (" (fest)" if p["haendler_fest"] is not None else ""),
+                                 fmt(p["betrag_orig"]),
                                  "manuell" if p["manuell"] else fmt_percent(p["prozent"]), fmt(p["betrag"])),
                          tags=tuple(tags))
         name = {ALLE: "Alle Positionen", UNZUGEORDNET: "Nicht zugeordnet"}.get(
@@ -641,11 +644,28 @@ class App:
         m.add_command(label="Auf Regel zurücksetzen", command=self.zuruecksetzen)
         m.add_separator()
         m.add_command(label="Auszahlung 0 € (nicht auszahlen)", command=lambda: self._null())
+        m.add_separator()
+        m.add_command(label="Händler zuweisen…", command=self.haendler_zuweisen)
+        m.add_command(label="Automatisch zuordnen", command=lambda: self.haendler_zuweisen(automatisch=True))
         if self.ansicht == UNZUGEORDNET or self.ansicht == ALLE:
-            m.add_separator()
             m.add_command(label="Kennung einem Händler zuordnen…", command=self.kennung_zuordnen_auswahl)
         m.tk_popup(e.x_root, e.y_root)
 
+    def haendler_zuweisen(self, automatisch: bool = False):
+        sel, pids, _ = self._auswahl_info()
+        if not pids:
+            w.info(self.root, "Händler zuweisen", "Bitte zuerst Positionen oder eine Gruppe auswählen.")
+            return
+        if automatisch:
+            hid = None
+        else:
+            hid = dlg.HaendlerWaehlen(self.root, self.db, len(pids)).zeigen()
+            if hid is None:
+                return
+        self.db.haendler_zuweisen(pids, hid)
+        self.db.touch(self.aid)
+        self._aktualisieren()
+
     def _null(self):
         sel, pids, _ = self._auswahl_info()
         self.db.prozent_anwenden(pids, 0.0)
@@ -746,7 +766,8 @@ class App:
     def hilfe(self):
         w.info(self.root, "Kurzanleitung",
                "1.  Händler anlegen (Strg+H): Name, Standard-Auszahlung in % und die Kennungen –\n"
-               "     bei freenet die Unterhändlernummer, bei Vodafone die VO-Nr.\n\n"
+               "     bei freenet die Unterhändlernummer, bei Vodafone die VO-Nr. oder die Regel\n"
+               "     „Name in GROSSBUCHSTABEN“. Einzelne Positionen: Rechtsklick ▸ Händler zuweisen.\n\n"
                "2.  Neue Abrechnung (Strg+N), z. B. „Oktober 2026“.\n\n"
                "3.  Dateien importieren (Strg+I) – mehrere CSV/Excel auf einmal möglich,\n"
                "     auch alle Wochenlisten eines Monats.\n\n"

provtool/gui/dialogs.py

@@ -5,9 +5,14 @@ import tkinter as tk
 from tkinter import filedialog, ttk
 
 from provtool import APP_NAME, APP_ORG, __version__
-from provtool.db import Datenbank, Haendler
+from provtool.db import CAPS_ANBIETER, CAPS_WERT, Datenbank, Haendler
 from provtool.gui import win95 as w
 from provtool.importer import ANBIETER
+
+# Auswahl im Händler-Dialog: Schlüssel → Anzeige
+KENNUNG_ARTEN = {"freenet": "freenet (Unterhändler-Nr.)", "vodafone": "Vodafone (VO-Nr.)",
+                 CAPS_ANBIETER: "Vodafone (Name in GROSSBUCHSTABEN)"}
+CAPS_TEXT = "Kunden-Nachname komplett in GROSSBUCHSTABEN"
 from provtool.money import fmt, fmt_percent, parse_percent
 
 
@@ -68,15 +73,18 @@ class HaendlerDialog(w.Dialog):
         self.kliste.heading("anbieter", text="Anbieter")
         self.kliste.heading("wert", text="Unterhändler-Nr. / VO-Nr.")
         self.kliste.column("anbieter", width=90)
-        self.kliste.column("wert", width=200)
+        self.kliste.column("wert", width=260)
         r2.pack(fill="both", expand=True)
         kf = tk.Frame(g2, bg=w.FACE)
         kf.pack(fill="x", pady=(4, 0))
-        self.v_kanb = tk.StringVar(value="freenet")
-        cb = ttk.Combobox(kf, textvariable=self.v_kanb, values=list(ANBIETER.values()), width=10, state="readonly")
+        self.v_kanb = tk.StringVar(value=KENNUNG_ARTEN["freenet"])
+        cb = ttk.Combobox(kf, textvariable=self.v_kanb, values=list(KENNUNG_ARTEN.values()), width=34,
+                          state="readonly")
         cb.pack(side="left")
+        cb.bind("<<ComboboxSelected>>", lambda e: self._art_gewaehlt())
         self.v_kwert = tk.StringVar()
-        ke = tk.Entry(kf, textvariable=self.v_kwert, width=18)
+        ke = tk.Entry(kf, textvariable=self.v_kwert, width=14)
+        self._ke = ke
         ke.pack(side="left", padx=4)
         ke.bind("<Return>", lambda e: self._kennung_dazu())
         w.knopf(kf, "Hinzufügen", self._kennung_dazu).pack(side="left")
@@ -111,7 +119,12 @@ class HaendlerDialog(w.Dialog):
     # ---- intern
     @staticmethod
     def _anbieter_key(anzeige: str) -> str:
-        return next((k for k, v in ANBIETER.items() if v == anzeige), anzeige)
+        return next((k for k, v in KENNUNG_ARTEN.items() if v == anzeige), anzeige)
+
+    def _art_gewaehlt(self):
+        caps = self._anbieter_key(self.v_kanb.get()) == CAPS_ANBIETER
+        self.v_kwert.set("")
+        self._ke.configure(state="disabled" if caps else "normal")
 
     def _liste_laden(self, auswahl_id=None):
         self.liste.delete(*self.liste.get_children())
@@ -147,7 +160,10 @@ class HaendlerDialog(w.Dialog):
     def _kennungen_zeigen(self):
         self.kliste.delete(*self.kliste.get_children())
         for i, (a, v) in enumerate(self._kennungen):
-            self.kliste.insert("", "end", iid=str(i), values=(ANBIETER.get(a, a), v))
+            if a == CAPS_ANBIETER:
+                self.kliste.insert("", "end", iid=str(i), values=("Vodafone", CAPS_TEXT))
+            else:
+                self.kliste.insert("", "end", iid=str(i), values=(ANBIETER.get(a, a), v))
 
     def _regeln_zeigen(self):
         self.rliste.delete(*self.rliste.get_children())
@@ -168,10 +184,10 @@ class HaendlerDialog(w.Dialog):
         self._regeln_zeigen()
 
     def _kennung_dazu(self):
-        wert = self.v_kwert.get().strip()
+        anb = self._anbieter_key(self.v_kanb.get())
+        wert = CAPS_WERT if anb == CAPS_ANBIETER else self.v_kwert.get().strip()
         if not wert:
             return
-        anb = self._anbieter_key(self.v_kanb.get())
         if (anb, wert) not in self._kennungen:
             self._kennungen.append((anb, wert))
         self.v_kwert.set("")
@@ -486,6 +502,36 @@ class KennungZuordnen(w.Dialog):
         self.destroy()
 
 
+class HaendlerWaehlen(w.Dialog):
+    """Feste Zuweisung ausgewählter Positionen zu einem Händler."""
+
+    KEINER = "(keinem Händler – nicht auszahlen)"
+
+    def __init__(self, master, db: Datenbank, anzahl: int):
+        super().__init__(master, "Händler zuweisen")
+        self._hmap = {h.name: h.id for h in db.haendler_liste(nur_aktive=True)}
+        tk.Label(self, text=f"{anzahl} Position(en) fest zuweisen an:", anchor="w").pack(fill="x", padx=12,
+                                                                                          pady=(12, 4))
+        self.cb = ttk.Combobox(self, values=list(self._hmap) + [self.KEINER], state="readonly", width=40)
+        self.cb.pack(padx=12, pady=4)
+        tk.Label(self, text="Die feste Zuweisung hat Vorrang vor Kennungen und der GROSSBUCHSTABEN-Regel.\n"
+                            "Rückgängig: Rechtsklick ▸ „Automatisch zuordnen“.", justify="left",
+                 fg=w.SHADOW).pack(fill="x", padx=12)
+        self.bind("<Return>", lambda e: self._ok())
+        self.knopfleiste([("OK", self._ok), ("Abbrechen", self.abbrechen)]).pack(pady=12)
+
+    def _ok(self):
+        name = self.cb.get()
+        if not name:
+            w.warnung(self, "Händler zuweisen", "Bitte einen Händler auswählen.")
+            return
+        self.result = 0 if name == self.KEINER else self._hmap[name]
+        self.destroy()
+
+    def zeigen(self, fokus=None):
+        return super().zeigen(self.cb)
+
+
 # =========================================================================== Export
 
 class ExportDialog(w.Dialog):

provtool/importer.py

@@ -288,13 +288,16 @@ def lies_datei(path: str | Path) -> ImportErgebnis:
         )
 
     warnungen: list[str] = []
-    # Vodafone/Euronics: Das Blatt "All" enthält alle Abrechnungsläufe. Sind zusätzlich
-    # Einzelblätter befüllt, würden Positionen doppelt gezählt – daher nur "All" verwenden.
-    alle = [g for g in gefunden if g[0].lower() == "all"]
-    if alle and len(gefunden) > 1:
-        uebrig = [g[0] for g in gefunden if g is not alle[0]]
-        warnungen.append(f"Nur Blatt „All“ übernommen, Einzelblätter ignoriert: {', '.join(uebrig)}")
-        gefunden = alle
+    # Vodafone/Euronics: Maßgeblich ist nur die erste Seite ("All") – sie enthält alle
+    # Abrechnungsläufe. Weitere Blätter würden Positionen doppelt zählen.
+    if any(f.key == VodafoneFormat.key for _, f, _ in gefunden):
+        erstes = blaetter[0][0]
+        uebrig = [g[0] for g in gefunden if g[0] != erstes]
+        gefunden = [g for g in gefunden if g[0] == erstes]
+        if uebrig:
+            warnungen.append(f"Nur die erste Seite „{erstes}“ übernommen, ignoriert: {', '.join(uebrig)}")
+        if not gefunden:
+            raise ImportFehler(f"Auf der ersten Seite von „{path.name}“ wurde keine Vodafone-Abrechnung gefunden.")
 
     positionen = [p for _, _, ps in gefunden for p in ps]
     formate = sorted({f.key for _, f, _ in gefunden})