kerimatilgan/provisionsmanager95
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 13 Wiki Activity

Airtime je Händler, Jahresbonus-Staffel, Export überarbeitet, natives Windows-Fenster

Browse Source 
- Airtime: Auszahlung in % je Händler (0 % = keine). Im Export als eine Summenzeile,
  die Einzelposten in einer eigenen Airtime-Liste (zweite Excel-Datei).
- Jahresbonus Neuaktivierung: Betrag je Karte nach Staffel (Standard 1-9: 5 € ... ab 40: voll),
  Standard-Staffel änderbar, eigene Staffel je Händler möglich.
- Provisionsarten: Airtime/Jahresbonus werden erkannt, Behandlung je Provisionsart umstellbar.
- Export: freenet und Vodafone standardmäßig in einer Datei, Positionen mit 0,00 € weglassen.
- Händler-Dialog: GROSSBUCHSTABEN-Regel als Häkchen (ging verloren, wenn „Hinzufügen“ vergessen wurde).
- Windows: Hauptfenster ist ein echtes Programmfenster mit unsichtbarem Rahmen – Andocken am
  Bildschirmrand, Win+Pfeiltasten und natives Größe-Ziehen; Trennsteg baut erst beim Loslassen neu auf.
- DB-Schema v3 (Migration), Tests für alles Neue.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Kerim AtilganandClaude Opus 5.5 committed 2026-11-02 17:23:48 +01:00
1 parent c0b740db06
commit 0880ab2d42
14 files changed
+1399 -119
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

provtool/gui/dialogs.py
+286 -35
View File
@@ -5,15 +5,16 @@ import tkinter as tk
from tkinter import filedialog, ttk
from provtool import APP_NAME, APP_ORG, __version__
from provtool import regeln
from provtool.db import CAPS_ANBIETER, CAPS_WERT, Datenbank, Haendler
from provtool.gui import win95 as w
from provtool.importer import ANBIETER
from provtool.money import fmt, fmt_percent, parse_cent, parse_percent
# 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)"}
KENNUNG_ARTEN = {"freenet": "freenet (Unterhändler-Nr.)", "vodafone": "Vodafone (VO-Nr.)"}
CAPS_TEXT = "Kunden-Nachname komplett in GROSSBUCHSTABEN"
from provtool.money import fmt, fmt_percent, parse_percent
CAPS_HAKEN = "Vodafone-Kunden mit Nachnamen in GROSSBUCHSTABEN gehören zu diesem Händler"
# =========================================================================== Händlerverwaltung
@@ -51,6 +52,7 @@ class HaendlerDialog(w.Dialog):
g.pack(fill="x")
self.v_name, self.v_ap, self.v_mail = tk.StringVar(), tk.StringVar(), tk.StringVar()
self.v_proz, self.v_aktiv = tk.StringVar(value="100"), tk.BooleanVar(value=True)
self.v_air = tk.StringVar(value="0")
for r, (lbl, var) in enumerate((("Name / Firma:", self.v_name), ("Ansprechpartner:", self.v_ap),
("E-Mail:", self.v_mail))):
tk.Label(g, text=lbl, anchor="w").grid(row=r, column=0, sticky="w", pady=2)
@@ -61,14 +63,20 @@ class HaendlerDialog(w.Dialog):
tk.Entry(pf, textvariable=self.v_proz, width=7, justify="right").pack(side="left")
tk.Label(pf, text="% der Provision").pack(side="left", padx=4)
tk.Checkbutton(g, text="Aktiv", variable=self.v_aktiv).grid(row=3, column=2, sticky="e")
tk.Label(g, text="Notiz:", anchor="nw").grid(row=4, column=0, sticky="nw", pady=2)
self.t_notiz = tk.Text(g, width=36, height=3, font=w.FONT)
self.t_notiz.grid(row=4, column=1, columnspan=2, sticky="we", pady=2)
tk.Label(g, text="Airtime:", anchor="w").grid(row=4, column=0, sticky="w", pady=2)
af = tk.Frame(g, bg=w.FACE)
af.grid(row=4, column=1, columnspan=2, sticky="w")
self.e_air = tk.Entry(af, textvariable=self.v_air, width=7, justify="right")
self.e_air.pack(side="left")
tk.Label(af, text="% der Airtime (0 % = keine Airtime)").pack(side="left", padx=4)
tk.Label(g, text="Notiz:", anchor="nw").grid(row=5, column=0, sticky="nw", pady=2)
self.t_notiz = tk.Text(g, width=36, height=2, font=w.FONT)
self.t_notiz.grid(row=5, column=1, columnspan=2, sticky="we", pady=2)
g.columnconfigure(1, weight=1)
g2 = w.gruppe(rechts, "Kennungen (ordnet Positionen diesem Händler zu)")
g2.pack(fill="both", expand=True, pady=(8, 0))
r2, self.kliste = w.scroll_tree(g2, columns=("anbieter", "wert"), show="headings", height=4,
r2, self.kliste = w.scroll_tree(g2, columns=("anbieter", "wert"), show="headings", height=3,
selectmode="browse")
self.kliste.heading("anbieter", text="Anbieter")
self.kliste.heading("wert", text="Unterhändler-Nr. / VO-Nr.")
@@ -89,10 +97,27 @@ class HaendlerDialog(w.Dialog):
ke.bind("<Return>", lambda e: self._kennung_dazu())
w.knopf(kf, "Hinzufügen", self._kennung_dazu).pack(side="left")
w.knopf(kf, "Entfernen", self._kennung_weg).pack(side="left", padx=4)
self.v_caps = tk.BooleanVar(value=False)
self.cb_caps = tk.Checkbutton(g2, text=CAPS_HAKEN, variable=self.v_caps, anchor="w")
self.cb_caps.pack(fill="x", pady=(4, 0))
g4 = w.gruppe(rechts, "Jahresbonus Neuaktivierung (Betrag je Karte nach Staffel)")
g4.pack(fill="x", pady=(8, 0))
self.v_eigen_staffel = tk.BooleanVar(value=False)
sf = tk.Frame(g4, bg=w.FACE)
sf.pack(fill="x")
tk.Radiobutton(sf, text="Standard-Staffel", variable=self.v_eigen_staffel, value=False,
command=self._staffel_zeigen).pack(side="left")
tk.Radiobutton(sf, text="Eigene Staffel für diesen Händler", variable=self.v_eigen_staffel, value=True,
command=self._staffel_zeigen).pack(side="left", padx=(8, 0))
w.knopf(sf, "Bearbeiten...", self._staffel_bearbeiten).pack(side="right")
self.l_staffel = tk.Label(g4, text="", anchor="w", justify="left", fg=w.NAVY, wraplength=560)
self.l_staffel.pack(fill="x", pady=(2, 0))
self._eigene_staffel: regeln.Staffel | None = None
g3 = w.gruppe(rechts, "Abweichende Auszahlung je Provisionsart")
g3.pack(fill="both", expand=True, pady=(8, 0))
r3, self.rliste = w.scroll_tree(g3, columns=("art", "proz"), show="headings", height=4, selectmode="browse")
r3, self.rliste = w.scroll_tree(g3, columns=("art", "proz"), show="headings", height=3, selectmode="browse")
self.rliste.heading("art", text="Provisionsart")
self.rliste.heading("proz", text="Auszahlung")
self.rliste.column("art", width=240)
@@ -112,9 +137,14 @@ class HaendlerDialog(w.Dialog):
self._liste_laden(auswahl_id)
if neue_kennung:
self._neu()
self._kennungen = [neue_kennung]
if neue_kennung[0] == CAPS_ANBIETER:
self.v_caps.set(True)
else:
self._kennungen = [neue_kennung]
self._kennungen_zeigen()
self.minsize(640, 460)
elif self.liste.selection():
self._auswahl() # sofort füllen – sonst wächst der Dialog erst nach der Größenberechnung
self.minsize(660, 560)
# ---- intern
@staticmethod
@@ -122,9 +152,42 @@ class HaendlerDialog(w.Dialog):
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")
self._ke.focus_set()
def _caps_einstellen(self, hid: int, an: bool):
"""GROSSBUCHSTABEN-Häkchen: gesperrt, wenn die Regel schon einem anderen Händler gehört."""
self.v_caps.set(an)
besitzer = self.db.kennung_map().get((CAPS_ANBIETER, CAPS_WERT))
if besitzer and besitzer != hid:
h = self.db.haendler(besitzer)
self.cb_caps.configure(state="disabled", text=f"GROSSBUCHSTABEN-Regel: gehört zu „{h.name if h else '?'}“")
else:
self.cb_caps.configure(state="normal", text=CAPS_HAKEN)
def _staffel_zeigen(self):
eigen = self.v_eigen_staffel.get()
if eigen and self._eigene_staffel is None:
self._eigene_staffel = list(self.db.standard_staffel())
st = self._eigene_staffel if eigen else self.db.standard_staffel()
self.l_staffel.configure(text=("Eigene Staffel: " if eigen else "Standard: ")
+ regeln.staffel_beschreibung(st, kurz=True))
def _staffel_bearbeiten(self):
if not self.v_eigen_staffel.get():
if w.frage(self, "Jahresbonus-Staffel",
"Die Standard-Staffel gilt für alle Händler ohne eigene Staffel.\n\n"
"Soll dieser Händler eine eigene Staffel bekommen?\n"
"(Die Standard-Staffel ändern Sie unter Händler > Standard-Staffel Jahresbonus...)",
ja="Eigene Staffel", nein="Abbrechen"):
self.v_eigen_staffel.set(True)
else:
return
neu = StaffelDialog(self, self._eigene_staffel or self.db.standard_staffel(),
f"Jahresbonus-Staffel – {self.v_name.get().strip() or 'neuer Händler'}",
standard=self.db.standard_staffel()).zeigen()
if neu is not None:
self._eigene_staffel = neu
self._staffel_zeigen()
def _liste_laden(self, auswahl_id=None):
self.liste.delete(*self.liste.get_children())
@@ -150,20 +213,23 @@ class HaendlerDialog(w.Dialog):
self.v_ap.set(h.ansprechpartner)
self.v_mail.set(h.email)
self.v_proz.set(fmt_percent(h.standard_prozent).replace(" %", ""))
self.v_air.set(fmt_percent(h.airtime_prozent).replace(" %", ""))
self.v_aktiv.set(h.aktiv)
self.t_notiz.delete("1.0", "end")
self.t_notiz.insert("1.0", h.notiz or "")
self._kennungen = self.db.kennungen(h.id)
kenn = self.db.kennungen(h.id)
self._kennungen = [k for k in kenn if k[0] != CAPS_ANBIETER]
self._caps_einstellen(h.id, (CAPS_ANBIETER, CAPS_WERT) in kenn)
self._eigene_staffel = list(h.staffel) if h.staffel is not None else None
self.v_eigen_staffel.set(h.staffel is not None)
self._staffel_zeigen()
self._kennungen_zeigen()
self._regeln_zeigen()
def _kennungen_zeigen(self):
self.kliste.delete(*self.kliste.get_children())
for i, (a, v) in enumerate(self._kennungen):
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))
self.kliste.insert("", "end", iid=str(i), values=(ANBIETER.get(a, a), v))
def _regeln_zeigen(self):
self.rliste.delete(*self.rliste.get_children())
@@ -177,15 +243,20 @@ class HaendlerDialog(w.Dialog):
for v in (self.v_name, self.v_ap, self.v_mail):
v.set("")
self.v_proz.set("100")
self.v_air.set("0")
self.v_aktiv.set(True)
self.t_notiz.delete("1.0", "end")
self._kennungen = []
self._caps_einstellen(0, False)
self._eigene_staffel = None
self.v_eigen_staffel.set(False)
self._staffel_zeigen()
self._kennungen_zeigen()
self._regeln_zeigen()
def _kennung_dazu(self):
anb = self._anbieter_key(self.v_kanb.get())
wert = CAPS_WERT if anb == CAPS_ANBIETER else self.v_kwert.get().strip()
wert = self.v_kwert.get().strip()
if not wert:
return
if (anb, wert) not in self._kennungen:
@@ -216,12 +287,21 @@ class HaendlerDialog(w.Dialog):
except ValueError:
w.warnung(self, "Händler", "Die Standard-Auszahlung muss eine Zahl sein (z. B. 100 oder 85,5).")
return
try:
air = parse_percent(self.v_air.get() or "0")
except ValueError:
w.warnung(self, "Händler", "Die Airtime-Auszahlung muss eine Zahl sein (z. B. 0, 50 oder 100).")
return
if self.v_kwert.get().strip():
self._kennung_dazu()
h = Haendler(self.aktuell.id if self.aktuell else 0, name, self.v_ap.get().strip(), self.v_mail.get().strip(),
self.t_notiz.get("1.0", "end").strip(), proz, self.v_aktiv.get())
self.t_notiz.get("1.0", "end").strip(), proz, self.v_aktiv.get(), air,
self._eigene_staffel if self.v_eigen_staffel.get() else None)
kennungen = list(self._kennungen)
if self.v_caps.get() and str(self.cb_caps.cget("state")) != "disabled":
kennungen.append((CAPS_ANBIETER, CAPS_WERT))
try:
hid = self.db.haendler_speichern(h, self._kennungen)
hid = self.db.haendler_speichern(h, kennungen)
except Exception as exc: # sqlite3.IntegrityError / ValueError
msg = str(exc)
if "UNIQUE" in msg and "haendler.name" in msg:
@@ -309,6 +389,171 @@ class ProzentDialog(w.Dialog):
return super().zeigen(self._e)
# =========================================================================== Jahresbonus-Staffel
class StaffelDialog(w.Dialog):
"""Staffel bearbeiten: je Stufe „ab N Karten“ und Betrag je Karte (oder „voll“)."""
def __init__(self, master, staffel: regeln.Staffel, titel: str = "Jahresbonus-Staffel",
standard: regeln.Staffel | None = None):
super().__init__(master, titel)
self.standard = standard
f = tk.Frame(self, bg=w.FACE)
f.pack(fill="both", expand=True, padx=12, pady=(10, 4))
tk.Label(f, justify="left", anchor="w", wraplength=380, text=(
"Jahresbonus Neuaktivierung: Der Händler bekommt je Karte den Betrag der Stufe, die zu seiner "
"Anzahl Karten in der Abrechnung passt. „voll“ = ganzer Betrag laut Abrechnung. Nie mehr als "
"die Provision laut Abrechnung; Stornos zählen ab.")).pack(fill="x")
kopf = tk.Frame(f, bg=w.FACE)
kopf.pack(fill="x", pady=(8, 2))
tk.Label(kopf, text="ab Karten", width=9, anchor="w").pack(side="left")
tk.Label(kopf, text="Betrag je Karte (oder „voll“)", anchor="w").pack(side="left", padx=(8, 0))
self.tabelle = tk.Frame(f, bg=w.FACE)
self.tabelle.pack(fill="x")
self.zeilen: list[tuple[tk.Frame, tk.StringVar, tk.StringVar]] = []
for ab, cent in staffel:
self._zeile(ab, cent)
kk = tk.Frame(f, bg=w.FACE)
kk.pack(fill="x", pady=(6, 0))
w.knopf(kk, "Stufe hinzufügen", self._dazu).pack(side="left")
w.knopf(kk, "Letzte entfernen", self._weg).pack(side="left", padx=4)
if standard is not None:
w.knopf(kk, "Wie Standard", lambda: self._setzen(standard)).pack(side="right")
self.knopfleiste([("OK", self._ok), ("Abbrechen", self.abbrechen)]).pack(pady=(6, 10))
def _zeile(self, ab: int | str = "", cent: int | None | str = ""):
z = tk.Frame(self.tabelle, bg=w.FACE)
z.pack(fill="x", pady=1)
v_ab = tk.StringVar(value=str(ab))
v_bt = tk.StringVar(value="voll" if cent is None else (fmt(cent, symbol=False) if isinstance(cent, int)
else str(cent)))
tk.Entry(z, textvariable=v_ab, width=8, justify="right").pack(side="left")
tk.Entry(z, textvariable=v_bt, width=10, justify="right").pack(side="left", padx=(12, 0))
tk.Label(z, text="€ je Karte").pack(side="left", padx=4)
self.zeilen.append((z, v_ab, v_bt))
def _dazu(self):
letzte = self.zeilen[-1][1].get() if self.zeilen else "0"
try:
ab = int(letzte) + 5
except ValueError:
ab = ""
self._zeile(ab, "")
def _weg(self):
if len(self.zeilen) > 1:
self.zeilen.pop()[0].destroy()
def _setzen(self, staffel):
for z, _, _ in self.zeilen:
z.destroy()
self.zeilen = []
for ab, cent in staffel:
self._zeile(ab, cent)
def lesen(self) -> regeln.Staffel:
out = []
for i, (_, v_ab, v_bt) in enumerate(self.zeilen, start=1):
try:
ab = int(v_ab.get().strip())
except ValueError:
raise ValueError(f"Stufe {i}: „ab Karten“ muss eine ganze Zahl sein.") from None
text = v_bt.get().strip()
if text.lower() == "voll":
cent = None
else:
try:
cent = parse_cent(text)
except ValueError:
raise ValueError(f"Stufe {i}: Bitte einen Betrag (z. B. 5 oder 7,50) oder „voll“ eingeben.") \
from None
out.append((ab, cent))
return regeln.staffel_pruefen(out)
def _ok(self):
try:
self.result = self.lesen()
except ValueError as exc:
w.warnung(self, "Staffel", str(exc))
return
self.destroy()
# =========================================================================== Provisionsarten
TYP_AUTO = "Automatisch"
class ProvisionsartenDialog(w.Dialog):
"""Welche Provisionsart ist Airtime bzw. Jahresbonus? Erkannt wird automatisch, umstellbar je Art."""
def __init__(self, master, db: Datenbank):
super().__init__(master, "Provisionsarten", resizable=True)
self.db = db
self.geaendert = False
f = tk.Frame(self, bg=w.FACE)
f.pack(fill="both", expand=True, padx=10, pady=10)
tk.Label(f, anchor="w", justify="left", text=(
"Airtime wird pro Händler mit dem Airtime-Prozentsatz ausgezahlt und im Export als eigene Liste\n"
"geführt. Der Jahresbonus Neuaktivierung wird nach der Staffel berechnet.")).pack(fill="x")
r, self.tree = w.scroll_tree(f, columns=("art", "anzahl", "typ"), show="headings", height=12,
selectmode="browse")
for c, t, b, a in (("art", "Provisionsart", 300, "w"), ("anzahl", "Pos.", 50, "e"),
("typ", "Behandlung", 230, "w")):
self.tree.heading(c, text=t)
self.tree.column(c, width=b, anchor=a)
r.pack(fill="both", expand=True, pady=(6, 4))
self.tree.bind("<<TreeviewSelect>>", lambda e: self._auswahl())
u = tk.Frame(f, bg=w.FACE)
u.pack(fill="x")
tk.Label(u, text="Behandlung:").pack(side="left")
self.v_typ = tk.StringVar(value=TYP_AUTO)
self.cb = ttk.Combobox(u, textvariable=self.v_typ, state="readonly", width=36,
values=[TYP_AUTO] + list(regeln.TYPEN.values()))
self.cb.pack(side="left", padx=4)
w.knopf(u, "Übernehmen", self._setzen).pack(side="left")
self.knopfleiste([("Schließen", self.abbrechen)]).pack(pady=(0, 10))
self._laden()
self.minsize(620, 380)
def _laden(self, auswahl: str | None = None):
self.tree.delete(*self.tree.get_children())
fest = self.db.art_typen()
self._arten = {}
for i, (art, erkannt, n) in enumerate(self.db.provisionsarten()):
typ = fest.get(art)
text = regeln.TYPEN[typ] if typ else f"{TYP_AUTO}: {regeln.TYPEN[erkannt]}"
iid = str(i)
self._arten[iid] = art
self.tree.insert("", "end", iid=iid, values=(art or "(ohne)", n, text))
if art == auswahl:
self.tree.selection_set(iid)
self.tree.see(iid)
def _auswahl(self):
sel = self.tree.selection()
if not sel:
return
typ = self.db.art_typen().get(self._arten[sel[0]])
self.v_typ.set(regeln.TYPEN[typ] if typ else TYP_AUTO)
def _setzen(self):
sel = self.tree.selection()
if not sel:
w.info(self, "Provisionsarten", "Bitte zuerst eine Provisionsart in der Liste auswählen.")
return
art = self._arten[sel[0]]
wahl = self.v_typ.get()
typ = next((k for k, v in regeln.TYPEN.items() if v == wahl), None)
self.db.art_typ_setzen(art, typ)
self.geaendert = True
self._laden(art)
def abbrechen(self):
self.result = self.geaendert
self.destroy()
# =========================================================================== Abrechnungen
class AbrechnungenDialog(w.Dialog):
@@ -612,7 +857,7 @@ class ExportDialog(w.Dialog):
r, self.tree = w.scroll_tree(f, columns=("name", "anzahl", "summe"), show="tree headings", height=8,
selectmode="extended")
self.tree.heading("#0", text="")
self.tree.column("#0", width=30, stretch=False)
self.tree.column("#0", width=40, stretch=False)
for c, t, b, a in (("name", "Händler", 220, "w"), ("anzahl", "Pos.", 50, "e"), ("summe", "Auszahlung", 100, "e")):
self.tree.heading(c, text=t)
self.tree.column(c, width=b, anchor=a)
@@ -638,18 +883,22 @@ class ExportDialog(w.Dialog):
self.v_ordner = tk.StringVar(value=settings.get("export_ordner") or "")
tk.Entry(g, textvariable=self.v_ordner, width=40).grid(row=1, column=1, sticky="we", pady=2)
w.knopf(g, "Durchsuchen...", self._ordner).grid(row=1, column=2, padx=(4, 0))
self.v_anb = tk.BooleanVar(value=settings.get("export_pro_anbieter", True))
# Neuer Schlüssel: freenet und Vodafone stehen jetzt standardmäßig in EINER Datei
self.v_anb = tk.BooleanVar(value=settings.get("export_anbieter_getrennt", False))
self.v_null = tk.BooleanVar(value=settings.get("export_null_weglassen", True))
self.v_kopf = tk.BooleanVar(value=settings.get("export_kopfzeile", False))
self.v_sum = tk.BooleanVar(value=settings.get("export_summe", True))
self.v_auf = tk.BooleanVar(value=True)
tk.Checkbutton(g, text="Pro Anbieter (freenet / Vodafone) eine eigene Datei",
variable=self.v_anb).grid(row=2, column=0, columnspan=3, sticky="w")
tk.Checkbutton(g, text="Kopfzeile mit Spaltennamen", variable=self.v_kopf).grid(row=3, column=0, columnspan=3,
sticky="w")
tk.Checkbutton(g, text="Summenzeile unter der Tabelle", variable=self.v_sum).grid(row=4, column=0,
columnspan=3, sticky="w")
tk.Checkbutton(g, text="Ordner nach dem Export öffnen", variable=self.v_auf).grid(row=5, column=0,
columnspan=3, sticky="w")
for zeile, (text, var) in enumerate((
("freenet und Vodafone in getrennte Dateien (sonst beide in einer)", self.v_anb),
("Positionen mit 0,00 € weglassen", self.v_null),
("Kopfzeile mit Spaltennamen", self.v_kopf),
("Summenzeile unter der Tabelle", self.v_sum),
("Ordner nach dem Export öffnen", self.v_auf)), start=2):
tk.Checkbutton(g, text=text, variable=var).grid(row=zeile, column=0, columnspan=3, sticky="w")
tk.Label(g, text="Airtime steht in der Abrechnung als eine Summenzeile, die Einzelposten kommen in eine\n"
"eigene Datei „... - Airtime - ...xlsx“.", fg=w.SHADOW, justify="left", anchor="w").grid(
row=7, column=0, columnspan=3, sticky="w", pady=(4, 0))
g.columnconfigure(1, weight=1)
self.knopfleiste([("Exportieren", self._ok), ("Abbrechen", self.abbrechen)]).pack(pady=(0, 10))
@@ -683,11 +932,13 @@ class ExportDialog(w.Dialog):
self._ordner()
if not self.v_ordner.get().strip():
return
self.settings.update(export_ordner=self.v_ordner.get().strip(), export_pro_anbieter=self.v_anb.get(),
export_kopfzeile=self.v_kopf.get(), export_summe=self.v_sum.get())
self.settings.update(export_ordner=self.v_ordner.get().strip(), export_anbieter_getrennt=self.v_anb.get(),
export_null_weglassen=self.v_null.get(), export_kopfzeile=self.v_kopf.get(),
export_summe=self.v_sum.get())
self.settings.pop("export_pro_anbieter", None)
self.result = dict(ids=ids, ordner=self.v_ordner.get().strip(), titel=self.v_titel.get().strip(),
pro_anbieter=self.v_anb.get(), kopfzeile=self.v_kopf.get(), summe=self.v_sum.get(),
oeffnen=self.v_auf.get())
pro_anbieter=self.v_anb.get(), null_weglassen=self.v_null.get(),
kopfzeile=self.v_kopf.get(), summe=self.v_sum.get(), oeffnen=self.v_auf.get())
self.destroy()