From 7692c79269d6b72787bbf34f31d31c9d91ac92a1 Mon Sep 17 00:00:00 2001 From: TheMockTv Date: Thu, 3 Sep 2026 22:49:19 +0200 Subject: [PATCH] Rechnungsnummer: einmal einrichten, danach fest MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Seine Ansage: 'er sollte es aber, wenn er neu startet, weil er ja eine Excel hat, im Popup einmal setzen - das waere fair. Aber ab da ist die fest, nicht aenderbar ausser ueber Storno und Berichtigen.' Beim ersten Start fragt das Programm einmal, wo die Nummer weiterlaufen soll. Vorgeschlagen wird, was Ordner und Nummernbuch hergeben; niedriger nimmt es nicht an, und vor dem Uebernehmen wird noch einmal gefragt. Danach steht nummer_eingerichtet in der config, und die Einstellungen zeigen den Zaehler nur noch an - mit dem Verweis auf Storno und Berichtigung (§ 14 Abs. 4 Nr. 4 UStG, § 146 Abs. 4 AO). Der Jahreswechsel bleibt automatisch: im neuen Jahr faengt es wieder bei 001 an, und die Rechnungen des Vorjahres heben nichts an. Auch das steht jetzt im Pruefstand ('beim jahreswechsel sollte die nach dem - zeichen auf 000 gehen, weil neues jahr'). Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01GYeAfLtccFrbU3MTj1MMTx --- app.py | 95 +++++++++++++++++++++++++++++++++++++++++ config.py | 4 ++ einstellungen.py | 20 +++++++++ pruef_nummernsperre.py | 97 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 216 insertions(+) diff --git a/app.py b/app.py index 56734b9..b42c7db 100644 --- a/app.py +++ b/app.py @@ -94,6 +94,8 @@ class RechnungsApp(ThemeMixin, KorrekturMixin, EinstellungenMixin, tk.Tk): self.after(250, self._frage_speicherort_falls_noetig) # ... und danach nach dem gemeinsamen Ordner fuer das Nummernbuch. self.after(400, self._frage_gemeinsam_falls_noetig) + # ... und danach einmalig nach dem Stand der Rechnungsnummer. + self.after(600, self._frage_nummer_falls_noetig) self.after(500, self._push_abholen) @@ -596,6 +598,99 @@ class RechnungsApp(ThemeMixin, KorrekturMixin, EinstellungenMixin, tk.Tk): self.buch_lbl.configure(text=f"Nummernbuch: {anzahl} Nummern", foreground=self.col_muted) + def _frage_nummer_falls_noetig(self): + """Beim ersten Start einmal nach dem Stand der Rechnungsnummer fragen. + + Er kommt aus einer Excel-Tabelle mit laufender Nummer - die muss er + einmal nennen koennen, sonst faengt das Programm bei 001 an und vergibt + Nummern ein zweites Mal. Danach ist der Zaehler zu. + """ + if TESTLAUF or self.cfg.get("nummer_eingerichtet"): + return + jahr = int(self.cfg.get("rechnung_jahr", 0) or datetime.date.today().year) + gefunden = self.hoechster_stand(jahr) + vorschlag = max(gefunden, int(self.cfg.get("rechnung_zaehler", 0) or 0)) + + d = tk.Toplevel(self) + d.title("Rechnungsnummer einrichten") + d.transient(self) + d.resizable(False, False) + self._style_dialog(d) + wert = tk.StringVar(value=str(vorschlag)) + fertig = {"ok": False} + + rahmen = ttk.Frame(d, padding=18) + rahmen.pack(fill="both", expand=True) + ttk.Label(rahmen, text="Wo soll die Rechnungsnummer weiterlaufen?", + font=("Segoe UI", 13, "bold")).grid(row=0, column=0, columnspan=2, sticky="w") + ttk.Label(rahmen, wraplength=620, justify="left", text=( + "Trag die zuletzt vergebene Nummer ein – die aus deiner bisherigen Liste. " + "Die nächste Rechnung bekommt dann die Nummer danach.\n\n" + "Das wird EINMAL eingerichtet. Danach steht der Zähler fest: eine " + "ausgestellte Rechnung wird nur noch über Storno oder Berichtigung " + "korrigiert, und jede Nummer gibt es nur einmal " + "(§ 14 Abs. 4 Nr. 4 UStG).")).grid( + row=1, column=0, columnspan=2, sticky="w", pady=(8, 12)) + + if gefunden: + tk.Label(rahmen, wraplength=620, justify="left", fg="#1f5c3d", + font=("Segoe UI", 9, "bold"), + text=f"Im Rechnungsordner und im Nummernbuch steht schon " + f"{jahr}-{gefunden:03d} – niedriger geht es nicht.").grid( + row=2, column=0, columnspan=2, sticky="w", pady=(0, 10)) + + ttk.Label(rahmen, text=f"Zuletzt vergeben: {jahr} –").grid(row=3, column=0, sticky="e") + ttk.Entry(rahmen, textvariable=wert, width=10, justify="center").grid( + row=3, column=1, sticky="w", padx=(8, 0)) + hinweis = tk.Label(rahmen, text="", wraplength=620, justify="left", fg="#a00000", + font=("Segoe UI", 9)) + hinweis.grid(row=4, column=0, columnspan=2, sticky="w", pady=(8, 0)) + + def uebernehmen(): + try: + zahl = int(parse_num(wert.get())) + except (TypeError, ValueError): + zahl = -1 + if zahl < gefunden: + hinweis.configure(text=f"Mindestens {gefunden} – so weit ist schon vergeben.") + return + if zahl < 0: + hinweis.configure(text="Bitte eine Zahl eintragen (0 = es geht bei 001 los).") + return + if not messagebox.askyesno( + "Sind Sie sicher?", + f"Die nächste Rechnung bekommt die Nummer {jahr}-{zahl + 1:03d}.\n\n" + "Das lässt sich danach nicht mehr ändern.\n\n" + "Ja = so übernehmen\n" + "Nein = zurück zur Eingabe", icon="question", default="yes", parent=d): + return + self.cfg["rechnung_jahr"] = jahr + self.cfg["rechnung_zaehler"] = zahl + self.cfg["nummer_eingerichtet"] = True + try: + config.save_config(self.cfg) + except OSError as e: # noqa: BLE001 + messagebox.showwarning("Nicht gespeichert", + f"Der Stand ließ sich nicht speichern:\n{e}", parent=d) + return + fertig["ok"] = True + d.destroy() + + knoepfe = ttk.Frame(rahmen) + knoepfe.grid(row=5, column=0, columnspan=2, sticky="ew", pady=(16, 0)) + ttk.Button(knoepfe, text="Übernehmen", width=16, command=uebernehmen).pack(side="right") + ttk.Button(knoepfe, text="Später", width=12, command=d.destroy).pack(side="left") + + d.protocol("WM_DELETE_WINDOW", d.destroy) + d.bind("", lambda _e: d.destroy()) + d.update_idletasks() + x = self.winfo_rootx() + max(0, (self.winfo_width() - d.winfo_reqwidth()) // 2) + d.geometry(f"+{max(0, x)}+{self.winfo_rooty() + 110}") + d.grab_set() + self.wait_window(d) + if fertig["ok"]: + self._neue_nummer_vorschlagen() + def hoechster_stand(self, jahr=None): """Hoechster JE VERGEBENER Zaehler dieses Jahres - aus beiden Quellen. diff --git a/config.py b/config.py index 0b2a5fb..90f6d5e 100644 --- a/config.py +++ b/config.py @@ -142,6 +142,10 @@ DEFAULT_CONFIG = { "montage": DEFAULT_MONTAGE, # Das Angebot hat eine EIGENE Reihe (2026-A001): es darf keine # Rechnungsnummer verbrauchen - die gehoert zu einer echten Rechnung. + # Einmal beim ersten Start gesetzt (er kommt aus einer Excel-Tabelle mit + # laufender Nummer). Danach steht der Zaehler fest - geaendert wird eine + # Rechnung nur noch ueber Storno oder Berichtigung. + "nummer_eingerichtet": False, "angebot_jahr": 0, "angebot_zaehler": 0, # Alle Steuern als EINE benannte Liste. diff --git a/einstellungen.py b/einstellungen.py index 0ea2588..ddc2b54 100644 --- a/einstellungen.py +++ b/einstellungen.py @@ -399,6 +399,26 @@ class EinstellungenMixin: ttk.Button(btns, text="Abbrechen", command=d.destroy).pack(side="right") def dlg_nummer(self): + # Einmal eingerichtet, dann zu: eine ausgestellte Rechnung wird nur noch + # ueber Storno oder Berichtigung korrigiert (§ 14 Abs. 4 Nr. 4 UStG, + # § 146 Abs. 4 AO). Angezeigt wird der Stand trotzdem - man will ja + # nachsehen koennen. + if self.cfg.get("nummer_eingerichtet"): + jahr = self.cfg.get("rechnung_jahr") + zaehler = int(self.cfg.get("rechnung_zaehler", 0) or 0) + hoch = self.hoechster_stand(jahr) + messagebox.showinfo( + "Rechnungsnummer", + f"Zuletzt vergeben: {jahr}-{max(zaehler, hoch):03d}\n" + f"Die nächste Rechnung bekommt {jahr}-{max(zaehler, hoch) + 1:03d}.\n\n" + "Der Zähler wurde einmal eingerichtet und lässt sich nicht mehr ändern. " + "Eine ausgestellte Rechnung wird über „Storno“ oder „Berichtigen“ " + "korrigiert – jede Nummer darf es nur einmal geben " + "(§ 14 Abs. 4 Nr. 4 UStG).") + return + return self._dlg_nummer_einrichten() + + def _dlg_nummer_einrichten(self): d = tk.Toplevel(self) d.title("Rechnungsnummer") d.transient(self) diff --git a/pruef_nummernsperre.py b/pruef_nummernsperre.py index 436a7f6..6893504 100644 --- a/pruef_nummernsperre.py +++ b/pruef_nummernsperre.py @@ -198,6 +198,103 @@ nummerndialog(2) pruefe(f.cfg.get("rechnung_zaehler") == 91, f"und auch dann geht es nicht zurueck ({f.cfg.get('rechnung_zaehler')})") +# ---- 7. Der Erststart: EINMAL setzen duerfen --------------------------- +# Er kommt aus einer Excel-Tabelle mit laufender Nummer - die muss er einmal +# nennen koennen. Danach ist der Zaehler zu. +f.cfg["nummer_eingerichtet"] = False +f.cfg["rechnung_jahr"] = JAHR +config.save_config(f.cfg) +A.TESTLAUF = False # den Erststart-Dialog wirklich zeigen + + +def erststart(zahl, erwartet_ja=True): + """Popup oeffnen, Zahl eintragen, Uebernehmen druecken.""" + antwort = {"gefragt": False} + + def sicher(titel, text, **kw): + antwort["gefragt"] = True + return erwartet_ja + + messagebox.askyesno = sicher + + def klick(rest=40): + tops = [w for w in f.winfo_children() if w.winfo_class() == "Toplevel"] + if tops: + top = tops[-1] + felder = felder_von(top) + if felder: + felder[0].delete(0, "end") + felder[0].insert(0, str(zahl)) + for k in knoepfe_von(top): + if "bernehmen" in str(k.cget("text")): + k.invoke() + return + if rest: + f.after(100, lambda: klick(rest - 1)) + + f.after(200, klick) + f._frage_nummer_falls_noetig() + for w in [w for w in f.winfo_children() if w.winfo_class() == "Toplevel"]: + w.destroy() + return antwort["gefragt"] + + +hoch_jetzt = f.hoechster_stand(JAHR) +erststart(hoch_jetzt - 5, True) +pruefe(not f.cfg.get("nummer_eingerichtet"), + "eine Zahl UNTER dem Vergebenen wird beim Erststart nicht angenommen") + +gefragt = erststart(500, True) +pruefe(gefragt, "vor dem Uebernehmen wird noch einmal gefragt") +pruefe(f.cfg.get("nummer_eingerichtet") is True, "danach ist der Zaehler eingerichtet") +pruefe(f.cfg.get("rechnung_zaehler") == 500, f"und steht auf 500 ({f.cfg.get('rechnung_zaehler')})") + +# ---- 8. Ab jetzt ist er zu ------------------------------------------- +meldungen = [] +messagebox.showinfo = lambda *a, **k: meldungen.append(a[1] if len(a) > 1 else "") +vorher = f.cfg.get("rechnung_zaehler") +f.dlg_nummer() +f.update() +offen = [w for w in f.winfo_children() if w.winfo_class() == "Toplevel"] +pruefe(not offen, "die Einstellungen oeffnen kein Eingabefenster mehr") +pruefe(f.cfg.get("rechnung_zaehler") == vorher, + f"der Zaehler bleibt, wie er ist ({f.cfg.get('rechnung_zaehler')})") +pruefe(any("Storno" in m for m in meldungen), + f"und es wird auf Storno/Berichtigen verwiesen ({meldungen})") + +# Und der Erststart fragt nicht noch einmal +f.after(200, lambda: None) +f._frage_nummer_falls_noetig() +pruefe(not [w for w in f.winfo_children() if w.winfo_class() == "Toplevel"], + "beim naechsten Start wird nicht wieder gefragt") + +# ---- 9. Jahreswechsel: nach dem Bindestrich faengt es wieder bei 001 an -- +# "beim jahreswechsel sollte die nach dem - zeichen auf 000 gehen, weil neues +# jahr". Der Zaehler des VORjahres darf dabei nichts anheben. +import datetime as _dt + +heute = _dt.date.today().year +f.cfg["rechnung_jahr"] = heute - 1 +f.cfg["rechnung_zaehler"] = 442 +f.cfg["nummer_eingerichtet"] = True +config.save_config(f.cfg) +f._neue_nummer_vorschlagen() +pruefe(f.r_nummer.get() == f"{heute}-001", + f"im neuen Jahr wird {heute}-001 vorgeschlagen ({f.r_nummer.get()})") + +# Auch dann, wenn im Ordner noch die hohen Nummern des Vorjahres liegen. +alt_pdf = os.path.join(ordner, f"Rechnung_{heute - 1}-442_Vorjahr.pdf") +open(alt_pdf, "wb").write(b"%PDF-1.4 kein echtes PDF, nur der Name zaehlt") +vor_dem_anlegen = 91 # so weit ist DIESES Jahr aus den Schritten davor +pruefe(f.hoechster_stand(heute) == vor_dem_anlegen, + f"die Rechnung aus dem Vorjahr hebt dieses Jahr NICHT an " + f"({f.hoechster_stand(heute)}, erwartet {vor_dem_anlegen})") +pruefe(f.hoechster_stand(heute - 1) == 442, + f"fuer ihr eigenes Jahr aber schon ({f.hoechster_stand(heute - 1)})") +f._neue_nummer_vorschlagen() +pruefe(f.r_nummer.get() == f"{heute}-001", + f"und es bleibt bei {heute}-001 ({f.r_nummer.get()})") + f.destroy() if not fehler: shutil.rmtree(tmp, ignore_errors=True)