From 4d9e30bc90d9636d740363e48f32c5aad9896a2c Mon Sep 17 00:00:00 2001 From: danny Date: Sun, 13 Sep 2026 20:09:31 +0200 Subject: [PATCH] 1.6.0: Squad-Reiter, Anmeldung und Abgleich im Programm - Neuer Hauptreiter SQUAD: Anmeldung und Registrierung; angemeldet alle Charaktere mit Zustand (KIA/MIA/WIA), Suche und Fraktionsfilter, fremde Akten als Dokument, Squads gruenden und verwalten, Einladungen annehmen, ablehnen, zurueckziehen; Konto abmelden oder loeschen - Akten werden nach dem Anmelden, kurz nach jeder Aenderung und alle 5 Minuten mit dem Server abgeglichen; Zustand unter der Aktenliste - Dokumentansicht als dokument_zeichnen() fuer eigene und fremde Akten; ohne Portraet scheint "KEIN PORTRAET" nicht mehr durch den Stempel - Release-Bau: Bezeichner wie "konto_loeschen" bekommen keine Umlaute mehr - sonst waeren vier Serveraktionen im Paket kaputt gewesen - Tests koennen mit SM_PROGRAMM gegen das gebaute Paket laufen - Datenschutz-Baustein fuer tyrveil.com, Anleitung und Doku auf 1.6.0 Co-Authored-By: Claude Opus 5 --- PROJEKT-UEBERGABE.md | 71 ++- README.md | 5 + akte.py | 333 ++++++----- installer/DATENSCHUTZ-BAUSTEIN.md | 75 +++ installer/HOCHLADEN.txt | 4 + installer/setup.iss | 2 +- squad.py | 945 ++++++++++++++++++++++++++++++ squad_manager.py | 13 +- start.pyw | 2 +- werkzeuge/abgleich_test.py | 6 +- werkzeuge/baue_release.py | 16 +- werkzeuge/oberflaeche_test.py | 264 +++++++++ 12 files changed, 1590 insertions(+), 146 deletions(-) create mode 100644 installer/DATENSCHUTZ-BAUSTEIN.md create mode 100644 squad.py create mode 100644 werkzeuge/oberflaeche_test.py diff --git a/PROJEKT-UEBERGABE.md b/PROJEKT-UEBERGABE.md index 836ab1c..f7db317 100644 --- a/PROJEKT-UEBERGABE.md +++ b/PROJEKT-UEBERGABE.md @@ -1,6 +1,6 @@ # Projektübergabe: Squad Manager -Stand: 13. September 2026 · Version 1.5.1 (Build 2) · Git-Repository im Quellordner +Stand: 13. September 2026 · Version 1.6.0 (Build 3) · Git-Repository im Quellordner Seit 3.2 wird über einen Inno-Setup-Installer und einen eingebauten Auto-Updater verteilt (Server: https://sva.tyrveil.com), siehe Abschnitt 4. @@ -50,6 +50,10 @@ akte.py Akte: Oberfläche (Liste, Formular, Dokumentansicht akte_modell.py Akte: Datenmodell und Speicherung, ohne tkinter akte_vorlagen.py Akte: Fraktionen, Dienstgrade, Verwendungen akte_karte.py Akte: PNG-Karte zum Teilen, Zwischenablage +konto.py Verbindung zum Server, Anmeldung (Token per DPAPI) +abgleich.py Abgleich lokaler Akten mit dem Server, ohne tkinter +hintergrund.py Netzwerkarbeit im Thread, Ergebnis im Tk-Hauptthread +squad.py Hauptreiter SQUAD: Anmeldung, Charaktere, Squads update_helfer.py spielt Updates ein, bei Bedarf mit Adminrechten server/ PHP-Server für Konten und Squads, siehe Abschnitt 4 start.pyw Startskript ohne Konsolenfenster @@ -150,8 +154,8 @@ gerade nicht gesendet werden darf, oder einen leeren String. Reihenfolge: | `set_dark_titlebar()` | Fenstertitelleiste dunkel | | `arm_autosave()` | speichert Einstellungen 600 ms nach jeder Änderung | -**Oberfläche:** Zwei Hauptreiter, *FUNK* (mit den Unterreitern „Mikrofon" -und „Tasten und Verhalten") und *AKTE*. Darunter für alle Module die +**Oberfläche:** Drei Hauptreiter, *FUNK* (mit den Unterreitern „Mikrofon" +und „Tasten und Verhalten"), *AKTE* und seit 1.6.0 *SQUAD*. Darunter für alle Module die Statusleiste mit den Knöpfen und der Zustandsanzeige (BEREITSCHAFT / HORCHT / SENDET / GESPERRT) — die Sprachaktivierung läuft weiter, während man in einem anderen Modul arbeitet. Der zuletzt gewählte Hauptreiter @@ -179,6 +183,35 @@ Dienst-Abschnitt — nicht still korrigieren. Island hat nur die vier Bereiche der Küstenwache, die Bundeswehr Heer, Luftwaffe und Marine mit eigenen Marine-Dienstgraden. +**Squad-Reiter und Abgleich (seit 1.6.0):** Ohne Konto zeigt *SQUAD* die +Anmeldung und Registrierung; alles andere läuft ohne Konto wie vorher. +Angemeldet: Unterreiter *Charaktere* (alle Spieler, Zustand KIA/MIA/WIA, +Suche, Fraktionsfilter, fremde Akte als Dokument), *Squads* (gründen, +Mitglieder, Führung übergeben, verlassen, auflösen) und *Einladungen*. +Konto → Abmelden oder Konto löschen. Alle Serveraufrufe über +`hintergrund.Hintergrund`, nie im Tk-Hauptthread. + +Die lokalen Akten bleiben Arbeitskopie. `squad.AbgleichSteuerung` stößt +`abgleich.abgleichen()` an: nach dem Anmelden, 4 s nach jeder Änderung +(`AkteSeite.bei_gespeichert`) und alle 5 min. Neben jeder Akte liegt +`server.json` mit Server-ID, Version, Prüfwert des Inhalts und +Porträt-Kennung des letzten Abgleichs. Nur lokal geändert → hochladen, nur +Server → herunterladen, beides → Konflikt: Serverfassung als +`konflikt-.json` neben die Akte, lokale Fassung gewinnt. Auf dem +Server gelöschte Akten wandern lokal in den Papierkorb. Der Papierkorb im +Programm merkt Akten in `akten/_abgleich_loeschen.json` zum Löschen auf dem +Server vor. Die Aktennummer vergibt der Server; der Abgleich schreibt sie +lokal zurück (`modell.speichern(zeit_setzen=False)`). Danach lädt +`AkteSeite.nach_abgleich()` geänderte Akten neu, die offene nur, wenn sie +selbst betroffen ist. + +Tests: `werkzeuge/abgleich_test.py` (zwei Rechner als eigene Prozesse mit +eigenem `%APPDATA%`, 34 Fälle) und `werkzeuge/oberflaeche_test.py` +(Programm gegen den Testserver, Anmeldung, Einladung annehmen, fremde +Akte, Konto löschen, mit Bildschirmfotos). Beide nutzen den Testserver aus +`server_test.py`; `konto.py` liest die Serveradresse aus `SM_SERVER` +(nur `http://127.0.0.1` ist neben HTTPS erlaubt). + **Teilen:** Knopf „Teilen …" in der Leiste der Akte. `akte_karte.karte()` zeichnet mit Pillow eine Karte 1200 × 675 (Discord zeigt das groß) — bewusst kein Bildschirmfoto, damit sie überall gleich aussieht. Inhalt: @@ -473,6 +506,30 @@ Programme ohne `build` in der Datei vergleichen gegen `LETZTE_ALTE_VERSION = "4.0"`. Der Bau warnt, wenn `BUILD` nicht höher ist als online. Getestet mit dem echten `pruefe_update()` aus 3.3 und 4.0. +**21 — `php -S` hängt unter Windows nach vielen Verbindungen.** +Der eingebaute Entwicklungsserver nahm nach einigen hundert schnellen +Anfragen keine Verbindung mehr an, obwohl der Prozess lief – im Test sah das +aus wie „offline". Der Testserver in `server_test.py` startet deshalb für +jede Anfrage ein eigenes `php-cgi` hinter einem Python-`ThreadingHTTPServer`. +Bei rätselhaften Zeitüberschreitungen im Test zuerst das Protokoll +`php-server.log` im Testordner ansehen. + +**22 — Änderungen nie am Zeitstempel erkennen.** +`geaendert` in der Akte ist nur sekundengenau. Der erste Abgleich verglich +ihn und übersah Änderungen in derselben Sekunde wie ein Abgleich – der +Zwei-Rechner-Test fand es. Seitdem vergleicht `abgleich.inhalt_hash()` den +Inhalt. + +**23 — Der Release-Bau darf keine Bezeichner umschreiben.** +Der Bau setzt in Zeichenketten echte Umlaute ein. In 1.6.0 machte er so +aus der Aktion `"konto_loeschen"` ein `"konto_löschen"` – der Server hätte +„unbekannte Aktion" geantwortet. Alle Tests liefen gegen die Quelle und +waren grün. Seitdem überspringt `baue_release.ist_bezeichner()` +Zeichenketten aus Kleinbuchstaben, Ziffern und `_ . - /`. **Vor jedem +Release die Tests auch gegen das Paket laufen lassen:** +`SM_PROGRAMM=dist\paket\Programm` für `abgleich_test.py` und +`oberflaeche_test.py`. + --- ## 6. Umgebung @@ -512,6 +569,14 @@ zu löschen: `SquadManager-3.3.*` und `SquadVoiceActivation-3.2.*`. Offen, ob bei den Freunden die Nachinstallation von Pillow über `start.pyw` geklappt hat (erstes Update mit neuem Paket). +**Stand 1.6.0:** Server eingerichtet und erreichbar (Tabellen bestätigt, +`einrichten.php` gelöscht). Vor dem Hochladen von 1.6.0 zuerst +`sva-privat/app` ersetzen – `charaktere.php` liefert neu die +`portraet_kennung`. Den Text aus `installer/DATENSCHUTZ-BAUSTEIN.md` muss der +Nutzer selbst in tyrveil.com/rechtliches einbauen (Laravel-Seite, kein +Zugriff). Offen: Unbestätigte Konten werden nicht automatisch gelöscht; +Konfliktdateien meldet das Programm nur in der Statuszeile. + **Installationen unter „Programme" (Erkenntnis 19).** Wer 3.x für alle Benutzer installiert hat, kommt per Updater nicht weiter und muss 4.0 einmal mit dem Installer einspielen. Der entfernt die alte Installation dabei diff --git a/README.md b/README.md index 46f24a8..1421018 100644 --- a/README.md +++ b/README.md @@ -17,6 +17,11 @@ Technische Dokumentation und alle bekannten Fallstricke: | `akte_modell.py` | Modul Akte: Datenmodell und Speicherung | | `akte_vorlagen.py` | Modul Akte: Fraktionen, Dienstgrade, Verwendungen | | `akte_karte.py` | Modul Akte: PNG-Karte zum Teilen | +| `konto.py` | Verbindung zum Server, Anmeldung | +| `abgleich.py` | Abgleich der Akten mit dem Server | +| `hintergrund.py` | Netzwerkarbeit im Hintergrund-Thread | +| `squad.py` | Hauptreiter SQUAD: Charaktere, Squads, Einladungen | +| `server/` | PHP-Server für Konten und Squads auf sva.tyrveil.com | | `update_helfer.py` | spielt Updates ein, bei Bedarf mit Adminrechten | | `start.pyw` | Startskript ohne Konsolenfenster | | `make_icon.py` | erzeugt `icon.ico` aus `icon.png` | diff --git a/akte.py b/akte.py index db621ca..faa006e 100644 --- a/akte.py +++ b/akte.py @@ -12,6 +12,7 @@ from tkinter import ttk, filedialog, messagebox from PIL import Image, ImageOps, ImageTk +import abgleich import akte_karte import akte_modell as modell import akte_vorlagen as vorlagen @@ -169,6 +170,8 @@ class AkteSeite(ttk.Frame): self._laedt = False self._fotos = {} self.modus = "ansicht" + # Setzt der Squad-Reiter: Nach jeder Aenderung wird der Abgleich angestossen + self.bei_gespeichert = None self._aufbau() self.bind_all("", self._mausrad, add="+") @@ -197,6 +200,10 @@ class AkteSeite(ttk.Frame): pady=(8, 0), padx=(0, 4)) ttk.Button(links, text="Papierkorb", command=self.in_papierkorb).grid( row=2, column=1, sticky="ew", pady=(8, 0)) + self.abgleich_var = tk.StringVar(value="") + self.abgleich_zeile = ttk.Label(links, textvariable=self.abgleich_var, style="Dim.TLabel", + wraplength=236, justify="left") + self.abgleich_zeile.grid(row=3, column=0, columnspan=2, sticky="w", pady=(8, 0)) rechts = ttk.Frame(self) rechts.grid(row=0, column=1, sticky="nsew", pady=(8, 0)) @@ -412,6 +419,7 @@ class AkteSeite(ttk.Frame): return self.modus = "bearbeiten" self.akten_laden(akte["id"]) + self._gespeichert() def in_papierkorb(self): if self.aktuell is None: @@ -424,9 +432,12 @@ class AkteSeite(ttk.Frame): "_papierkorb verschoben und lässt sich von dort zurückholen."): return self.speichern_sofort() + # Vor dem Verschieben: server.json liegt im Aktenordner + abgleich.loeschen_vormerken(self.aktuell["id"]) modell.in_papierkorb(self.aktuell["id"]) self.aktuell = None self.akten_laden() + self._gespeichert() # -- Teilen -------------------------------------------------------------- def teilen_menue(self): @@ -643,6 +654,7 @@ class AkteSeite(ttk.Frame): messagebox.showerror("Porträt", str(fehler)) return self._vorschau_aktualisieren() + self._gespeichert() def portraet_entfernen(self): if self.aktuell is None or modell.portraet_pfad(self.aktuell["id"]) is None: @@ -650,6 +662,7 @@ class AkteSeite(ttk.Frame): modell.portraet_entfernen(self.aktuell["id"]) self._fotos = {k: v for k, v in self._fotos.items() if k[0] != self.aktuell["id"]} self._vorschau_aktualisieren() + self._gespeichert() # -- Speichern ----------------------------------------------------------- def _speichern_planen(self): @@ -669,6 +682,44 @@ class AkteSeite(ttk.Frame): self._geaendert_flag = False except OSError as fehler: messagebox.showerror("Akte", f"Die Akte konnte nicht gespeichert werden:\n{fehler}") + return + self._gespeichert() + + def _gespeichert(self): + if self.bei_gespeichert is not None: + self.bei_gespeichert() + + # -- Abgleich mit dem Server --------------------------------------------- + def abgleich_zustand(self, text, art): + farben = {"ok": FG_DIM, "laeuft": FG_DIM, "aus": FG_DIM, "offline": AMBER, "fehler": RED} + self.abgleich_var.set(text) + self.abgleich_zeile.configure(foreground=farben.get(art, FG_DIM)) + + def nach_abgleich(self, geaendert): + """ + Der Abgleich hat lokale Akten neu geschrieben - Liste und offene Akte + neu einlesen. Ungespeicherte Eingaben gehen vor: Sie werden zuerst + gesichert und beim naechsten Abgleich hochgeladen. + """ + if not geaendert: + return + self.speichern_sofort() + auswahl = self.aktuell["id"] if self.aktuell else None + self._fotos = {k: v for k, v in self._fotos.items() if k[0] not in geaendert} + if auswahl is None or auswahl in geaendert: + self.aktuell = None + self.akten_laden(auswahl) + return + # Die offene Akte ist unveraendert: nur die Liste auffrischen, damit + # Scrollstand und Eingabefokus bleiben + offen = self.aktuell + self.akten = [offen if a["id"] == auswahl else a for a in modell.alle_akten()] + self.liste.delete(*self.liste.get_children()) + for akte in self.akten: + self.liste.insert("", "end", iid=akte["id"], + values=(modell.listenname(akte), akte["aktennummer"])) + if self.liste.exists(auswahl): + self.liste.selection_set(auswahl) # -- Mausrad ------------------------------------------------------------- def _mausrad(self, ereignis): @@ -697,153 +748,167 @@ class AkteSeite(ttk.Frame): def ansicht_zeichnen(self): self._zeichen_job = None - c = self.dok - c.delete("all") - a = self.aktuell - if a is None: + if self.aktuell is None: + self.dok.delete("all") return - breite = max(c.winfo_width(), 540) - rand = 14 - links, rechts = rand + 22, breite - rand - 22 - dienst, pers = a.get("dienst", {}), a.get("personalien", {}) - status = dienst.get("status", "aktiv") - gefallen = status == "gefallen" - schrift = FG_DIM if gefallen else FG - akzent = FG_DIM if gefallen else OLIVE_HI - y = rand + 18 + akte_id = self.aktuell["id"] + dokument_zeichnen(self.dok, self.aktuell, lambda groesse: self._foto(akte_id, groesse)) - c.create_text(links, y, anchor="nw", fill=FG_DIM, font=FONT_DOK_KLEIN, - text=f"AKTE NR. {a.get('aktennummer', '')}") - c.create_text(rechts, y, anchor="ne", fill=FG_DIM, font=FONT_DOK_KLEIN, - text="SQUAD MANAGER · PERSONALWESEN") - y += 26 - c.create_text(links + 10, y + 6, anchor="nw", text="PERSONALAKTE", - fill=AMBER, font=FONT_STEMPEL, tags="stempel") - x0, y0, x1, y1 = c.bbox("stempel") - c.create_rectangle(x0 - 10, y0 - 6, x1 + 10, y1 + 6, outline=AMBER, width=2) - y = y1 + 26 - # Portraet rechts oben - pb, ph = 150, 190 - px1, px0 = rechts, rechts - pb - py0, py1 = y, y + ph - c.create_rectangle(px0 - 5, py0 - 5, px1 + 5, py1 + 5, outline=LINE) - foto = self._foto(a["id"], (pb, ph)) - if foto: - c.create_image((px0 + px1) // 2, (py0 + py1) // 2, image=foto) - else: - c.create_rectangle(px0, py0, px1, py1, fill=BG, outline="") +def dokument_zeichnen(c, a, foto_fuer): + """ + Zeichnet eine Akte als Dokument auf die Zeichenflaeche c. + + foto_fuer((breite, hoehe)) liefert das Portraet als PhotoImage oder + None. Genutzt von der eigenen Akte und im Squad-Reiter fuer fremde + Akten, deren Portraet vom Server kommt. + """ + c.delete("all") + breite = max(c.winfo_width(), 540) + rand = 14 + links, rechts = rand + 22, breite - rand - 22 + dienst, pers = a.get("dienst", {}), a.get("personalien", {}) + status = dienst.get("status", "aktiv") + gefallen = status == "gefallen" + schrift = FG_DIM if gefallen else FG + akzent = FG_DIM if gefallen else OLIVE_HI + y = rand + 18 + + c.create_text(links, y, anchor="nw", fill=FG_DIM, font=FONT_DOK_KLEIN, + text=f"AKTE NR. {a.get('aktennummer', '')}") + c.create_text(rechts, y, anchor="ne", fill=FG_DIM, font=FONT_DOK_KLEIN, + text="SQUAD MANAGER · PERSONALWESEN") + y += 26 + c.create_text(links + 10, y + 6, anchor="nw", text="PERSONALAKTE", + fill=AMBER, font=FONT_STEMPEL, tags="stempel") + x0, y0, x1, y1 = c.bbox("stempel") + c.create_rectangle(x0 - 10, y0 - 6, x1 + 10, y1 + 6, outline=AMBER, width=2) + y = y1 + 26 + + # Portraet rechts oben + pb, ph = 150, 190 + px1, px0 = rechts, rechts - pb + py0, py1 = y, y + ph + c.create_rectangle(px0 - 5, py0 - 5, px1 + 5, py1 + 5, outline=LINE) + foto = foto_fuer((pb, ph)) + if foto: + c.create_image((px0 + px1) // 2, (py0 + py1) // 2, image=foto) + else: + c.create_rectangle(px0, py0, px1, py1, fill=BG, outline="") + # Unter einem Stempel wuerde der Text nur durchscheinen + if dienst.get("status", "aktiv") not in ("gefallen", "vermisst"): c.create_text((px0 + px1) // 2, (py0 + py1) // 2, text="KEIN\nPORTRÄT", fill=FG_DIM, font=FONT_DOK_KLEIN, justify="center") - # Kopfdaten links neben dem Portraet - textbreite = px0 - links - 30 - name = " ".join(t for t in (pers.get("vorname", ""), pers.get("nachname", "")) if t) - callsign = pers.get("callsign", "") - titel = callsign.upper() if callsign else (name or "OHNE NAMEN") - oben = y - t = c.create_text(links, oben, anchor="nw", text=titel, fill=akzent, - font=FONT_CALLSIGN, width=textbreite) - oben = c.bbox(t)[3] + 4 - zweite = " ".join(x for x in (dienst.get("rang", ""), name if callsign else "") if x) - if zweite: - t = c.create_text(links, oben, anchor="nw", text=zweite, fill=schrift, - font=FONT_NAME, width=textbreite) - oben = c.bbox(t)[3] + 14 - else: - oben += 10 - for zeile in (" · ".join(x for x in (dienst.get("fraktion", ""), - dienst.get("teilstreitkraft", "")) if x), - dienst.get("verwendung", ""), - f"STATUS: {status.upper()}"): - if zeile: - t = c.create_text(links, oben, anchor="nw", text=zeile, fill=schrift, - font=FONT_DOK, width=textbreite) - oben = c.bbox(t)[3] + 4 + # Kopfdaten links neben dem Portraet + textbreite = px0 - links - 30 + name = " ".join(t for t in (pers.get("vorname", ""), pers.get("nachname", "")) if t) + callsign = pers.get("callsign", "") + titel = callsign.upper() if callsign else (name or "OHNE NAMEN") + oben = y + t = c.create_text(links, oben, anchor="nw", text=titel, fill=akzent, + font=FONT_CALLSIGN, width=textbreite) + oben = c.bbox(t)[3] + 4 + zweite = " ".join(x for x in (dienst.get("rang", ""), name if callsign else "") if x) + if zweite: + t = c.create_text(links, oben, anchor="nw", text=zweite, fill=schrift, + font=FONT_NAME, width=textbreite) + oben = c.bbox(t)[3] + 14 + else: + oben += 10 + for zeile in (" · ".join(x for x in (dienst.get("fraktion", ""), + dienst.get("teilstreitkraft", "")) if x), + dienst.get("verwendung", ""), + f"STATUS: {status.upper()}"): + if zeile: + t = c.create_text(links, oben, anchor="nw", text=zeile, fill=schrift, + font=FONT_DOK, width=textbreite) + oben = c.bbox(t)[3] + 4 - if status in ("gefallen", "vermisst"): - self._stempel(c, (px0 + px1) / 2, (py0 + py1) / 2, status.upper(), - RED if gefallen else AMBER) - y = max(oben, py1) + 30 + if status in ("gefallen", "vermisst"): + _stempel(c, (px0 + px1) / 2, (py0 + py1) / 2, status.upper(), + RED if gefallen else AMBER) + y = max(oben, py1) + 30 - def abschnitt(titel, y): - c.create_text(links, y, anchor="nw", text=titel, fill=akzent, font=FONT_DOK_FETT) - c.create_line(links, y + 20, rechts, y + 20, fill=LINE) - return y + 30 + def abschnitt(titel, y): + c.create_text(links, y, anchor="nw", text=titel, fill=akzent, font=FONT_DOK_FETT) + c.create_line(links, y + 20, rechts, y + 20, fill=LINE) + return y + 30 - def zeilen(paare, y): - for beschriftung, inhalt in paare: - c.create_text(links, y, anchor="nw", text=beschriftung.upper(), - fill=FG_DIM, font=FONT_DOK_KLEIN) - t = c.create_text(links + 150, y, anchor="nw", text=inhalt or "—", - fill=schrift if inhalt else FG_DIM, font=FONT_DOK, - width=rechts - links - 150) - y = c.bbox(t)[3] + 6 - return y + 10 - - def fliesstext(inhalt, y): - t = c.create_text(links, y, anchor="nw", text=inhalt or "—", + def zeilen(paare, y): + for beschriftung, inhalt in paare: + c.create_text(links, y, anchor="nw", text=beschriftung.upper(), + fill=FG_DIM, font=FONT_DOK_KLEIN) + t = c.create_text(links + 150, y, anchor="nw", text=inhalt or "—", fill=schrift if inhalt else FG_DIM, font=FONT_DOK, - width=rechts - links) - return c.bbox(t)[3] + 18 + width=rechts - links - 150) + y = c.bbox(t)[3] + 6 + return y + 10 - y = abschnitt("I. PERSONALIEN", y) - y = zeilen([(b, wert(a, p)) for p, b in PERSONALIEN], y) - y = abschnitt("II. DIENST", y) - einheit = " · ".join(wert(a, p) for p, _ in EINHEIT if wert(a, p)) - y = zeilen([(b, wert(a, p)) for p, b in DIENST] + [("Einheit", einheit)], y) - y = abschnitt("III. BESCHREIBUNG", y) - y = fliesstext(a.get("beschreibung", ""), y) + def fliesstext(inhalt, y): + t = c.create_text(links, y, anchor="nw", text=inhalt or "—", + fill=schrift if inhalt else FG_DIM, font=FONT_DOK, + width=rechts - links) + return c.bbox(t)[3] + 18 - y = abschnitt("IV. AUSZEICHNUNGEN", y) - auszeichnungen = a.get("auszeichnungen", []) - if not auszeichnungen: - y = fliesstext("", y) - for e in auszeichnungen: - kopf = e.get("bezeichnung", "") + (f" ({e['datum']})" if e.get("datum") else "") - t = c.create_text(links, y, anchor="nw", text="■ " + kopf, fill=schrift, - font=FONT_DOK_FETT, width=rechts - links) - y = c.bbox(t)[3] + 2 - if e.get("anlass"): - t = c.create_text(links + 18, y, anchor="nw", text=e["anlass"], fill=schrift, - font=FONT_DOK, width=rechts - links - 18) - y = c.bbox(t)[3] - y += 10 + y = abschnitt("I. PERSONALIEN", y) + y = zeilen([(b, wert(a, p)) for p, b in PERSONALIEN], y) + y = abschnitt("II. DIENST", y) + einheit = " · ".join(wert(a, p) for p, _ in EINHEIT if wert(a, p)) + y = zeilen([(b, wert(a, p)) for p, b in DIENST] + [("Einheit", einheit)], y) + y = abschnitt("III. BESCHREIBUNG", y) + y = fliesstext(a.get("beschreibung", ""), y) - y = abschnitt("V. EINSÄTZE", y + 4) - einsaetze = a.get("einsaetze", []) - if not einsaetze: - y = fliesstext("", y) - for e in einsaetze: - kopf = " · ".join(x for x in (e.get("datum", ""), e.get("ort", "")) if x) or "Einsatz" - t = c.create_text(links, y, anchor="nw", text=kopf, fill=akzent, - font=FONT_DOK_FETT, width=rechts - links) - y = c.bbox(t)[3] + 2 - if e.get("bericht"): - t = c.create_text(links, y, anchor="nw", text=e["bericht"], fill=schrift, - font=FONT_DOK, width=rechts - links) - y = c.bbox(t)[3] - y += 14 + y = abschnitt("IV. AUSZEICHNUNGEN", y) + auszeichnungen = a.get("auszeichnungen", []) + if not auszeichnungen: + y = fliesstext("", y) + for e in auszeichnungen: + kopf = e.get("bezeichnung", "") + (f" ({e['datum']})" if e.get("datum") else "") + t = c.create_text(links, y, anchor="nw", text="■ " + kopf, fill=schrift, + font=FONT_DOK_FETT, width=rechts - links) + y = c.bbox(t)[3] + 2 + if e.get("anlass"): + t = c.create_text(links + 18, y, anchor="nw", text=e["anlass"], fill=schrift, + font=FONT_DOK, width=rechts - links - 18) + y = c.bbox(t)[3] + y += 10 - y = abschnitt("VI. VERMERKE", y + 4) - y = fliesstext(a.get("vermerke", ""), y) + y = abschnitt("V. EINSÄTZE", y + 4) + einsaetze = a.get("einsaetze", []) + if not einsaetze: + y = fliesstext("", y) + for e in einsaetze: + kopf = " · ".join(x for x in (e.get("datum", ""), e.get("ort", "")) if x) or "Einsatz" + t = c.create_text(links, y, anchor="nw", text=kopf, fill=akzent, + font=FONT_DOK_FETT, width=rechts - links) + y = c.bbox(t)[3] + 2 + if e.get("bericht"): + t = c.create_text(links, y, anchor="nw", text=e["bericht"], fill=schrift, + font=FONT_DOK, width=rechts - links) + y = c.bbox(t)[3] + y += 14 - karte = c.create_rectangle(rand, rand, breite - rand, y + 6, fill=PANEL, outline=LINE) - c.tag_lower(karte) - c.configure(scrollregion=(0, 0, breite, y + rand + 10)) + y = abschnitt("VI. VERMERKE", y + 4) + y = fliesstext(a.get("vermerke", ""), y) - @staticmethod - def _stempel(c, mx, my, text, farbe, winkel=18): - """Schraeger Stempel ueber dem Portraet, mit gedrehtem Rahmen.""" - t = c.create_text(mx, my, text=text, fill=farbe, angle=winkel, - font=("Consolas", 18, "bold")) - breite = len(text) * 14 + 26 - hoehe = 38 - rad = math.radians(winkel) - ecken = [] - for dx, dy in ((-breite / 2, -hoehe / 2), (breite / 2, -hoehe / 2), - (breite / 2, hoehe / 2), (-breite / 2, hoehe / 2)): - ecken += [mx + dx * math.cos(rad) + dy * math.sin(rad), - my - dx * math.sin(rad) + dy * math.cos(rad)] - c.create_polygon(*ecken, outline=farbe, fill="", width=3) - c.tag_raise(t) + karte = c.create_rectangle(rand, rand, breite - rand, y + 6, fill=PANEL, outline=LINE) + c.tag_lower(karte) + c.configure(scrollregion=(0, 0, breite, y + rand + 10)) + + + +def _stempel(c, mx, my, text, farbe, winkel=18): + """Schraeger Stempel ueber dem Portraet, mit gedrehtem Rahmen.""" + t = c.create_text(mx, my, text=text, fill=farbe, angle=winkel, + font=("Consolas", 18, "bold")) + breite = len(text) * 14 + 26 + hoehe = 38 + rad = math.radians(winkel) + ecken = [] + for dx, dy in ((-breite / 2, -hoehe / 2), (breite / 2, -hoehe / 2), + (breite / 2, hoehe / 2), (-breite / 2, hoehe / 2)): + ecken += [mx + dx * math.cos(rad) + dy * math.sin(rad), + my - dx * math.sin(rad) + dy * math.cos(rad)] + c.create_polygon(*ecken, outline=farbe, fill="", width=3) + c.tag_raise(t) diff --git a/installer/DATENSCHUTZ-BAUSTEIN.md b/installer/DATENSCHUTZ-BAUSTEIN.md new file mode 100644 index 0000000..e136a5c --- /dev/null +++ b/installer/DATENSCHUTZ-BAUSTEIN.md @@ -0,0 +1,75 @@ +# Baustein für die Datenschutzerklärung auf tyrveil.com + +Vorlage für einen neuen Abschnitt in https://tyrveil.com/rechtliches. Sie +beschreibt, was der Squad Manager ab Version 1.6.0 auf sva.tyrveil.com +verarbeitet. **Keine Rechtsberatung** – vor dem Veröffentlichen selbst +prüfen oder prüfen lassen, und die Stellen in [eckigen Klammern] ergänzen. + +--- + +## Squad Manager (sva.tyrveil.com) + +Der Squad Manager ist ein kostenloses Programm für die Spielgemeinschaft +rund um das Spiel Squad. Wer möchte, kann ein Konto anlegen, Personalakten +seiner Rollenspiel-Charaktere auf dem Server speichern und mit anderen +registrierten Nutzern Squads bilden. Ohne Konto werden keine Daten an uns +übertragen; das Programm prüft dann lediglich beim Start, ob eine neue +Version vorliegt. + +**Verantwortlicher:** [wie im Impressum] + +### Welche Daten wir verarbeiten + +- **Kontodaten:** Benutzername, E-Mail-Adresse und das Passwort – dieses + nur als nicht umkehrbarer Hash. Dazu Zeitpunkt der Registrierung, der + E-Mail-Bestätigung und der letzten Anmeldung. +- **Anmeldung:** Beim Anmelden erzeugen wir ein zufälliges Sitzungs-Token. + Auf unserem Server liegt davon nur ein Prüfwert, zusammen mit dem + Rechnernamen, den das Programm übermittelt, damit sich Sitzungen + unterscheiden lassen. +- **Charakterdaten:** alle Angaben, die du in einer Personalakte einträgst + (etwa Namen, Callsign, Dienstgrad, Fraktion, Beschreibung, + Auszeichnungen, Einsätze, Vermerke) und ein hochgeladenes Porträt. +- **Squads und Einladungen:** Name und Beschreibung eines Squads, welche + Charaktere Mitglied sind und wer wen eingeladen hat. +- **Schutz vor Missbrauch:** Um das Durchprobieren von Passwörtern und + Massenregistrierungen zu verhindern, speichern wir fehlgeschlagene + Versuche für höchstens 24 Stunden – die IP-Adresse dabei nur als + Prüfwert, nicht im Klartext. +- **Server-Protokolle** unseres Hosters mit IP-Adresse, Zeitpunkt und + aufgerufener Adresse: [Speicherdauer beim Hoster eintragen]. + +### Wer die Daten sieht + +Charakterdaten, Porträts, Squads und dein **Benutzername** sind für alle +angemeldeten Nutzer des Squad Managers sichtbar – das ist der Zweck der +Funktion. Deine E-Mail-Adresse sehen andere Nutzer nicht. Der Betreiber +kann über eine Verwaltung Konten sperren oder löschen. + +Die Daten liegen auf einem Server bei [Hoster, Sitz]. Eine Weitergabe an +Dritte findet nicht statt. + +### Zweck und Rechtsgrundlage + +- Bereitstellung des Kontos und der Gemeinschaftsfunktionen, die du + ausdrücklich nutzt: Art. 6 Abs. 1 lit. b DSGVO. +- Schutz vor Missbrauch und Sicherheit des Dienstes: Art. 6 Abs. 1 lit. f + DSGVO; unser berechtigtes Interesse ist ein sicherer Betrieb. +- E-Mails verschicken wir nur, soweit sie für das Konto nötig sind: + Bestätigung der Adresse und Zurücksetzen des Passworts. + +### Speicherdauer und Löschung + +Deine Daten bleiben gespeichert, solange dein Konto besteht. Du kannst +dein Konto jederzeit im Programm löschen (Reiter SQUAD → Konto → Konto +löschen). Dabei werden das Konto, alle Charaktere, Porträts und +Sitzungen auf dem Server gelöscht. Führt einer deiner Charaktere ein +Squad, geht die Führung an ein anderes Mitglied über. Kopien deiner +Akten auf deinem eigenen PC bleiben davon unberührt. + +### Deine Rechte + +Du hast das Recht auf Auskunft, Berichtigung, Löschung, Einschränkung der +Verarbeitung, Datenübertragbarkeit und Widerspruch sowie auf Beschwerde +bei einer Datenschutz-Aufsichtsbehörde. Wende dich dazu an +[info@tyrveil.com]. diff --git a/installer/HOCHLADEN.txt b/installer/HOCHLADEN.txt index bbb1726..b52d70c 100644 --- a/installer/HOCHLADEN.txt +++ b/installer/HOCHLADEN.txt @@ -11,6 +11,10 @@ außer dieser Anleitung selbst: index.html die Downloadseite version.json als Letztes +Ändert sich auch der Server (dann liegt dist\sva-privat bei), zuerst im +Ordner sva-privat den Unterordner app durch dist\sva-privat\app ersetzen. +config.php und daten dabei nicht anfassen. + Die Reihenfolge ist wichtig: version.json zuletzt. Solange sie noch auf die alte Version zeigt, bekommt niemand einen Link auf eine Datei, die noch gar nicht oben liegt. diff --git a/installer/setup.iss b/installer/setup.iss index 4a9f4b3..7c02eb2 100644 --- a/installer/setup.iss +++ b/installer/setup.iss @@ -2,7 +2,7 @@ ; Uebersetzen mit: ISCC.exe setup.iss #define Name "Squad Manager" -#define Version "1.5.1" +#define Version "1.6.0" #define Herausgeber "tyrveil.com" #define Website "https://sva.tyrveil.com" diff --git a/squad.py b/squad.py new file mode 100644 index 0000000..c4274cf --- /dev/null +++ b/squad.py @@ -0,0 +1,945 @@ +""" +Hauptreiter SQUAD: Konto, alle Charaktere, Squads und Einladungen. + +Ohne Anmeldung zeigt der Reiter die Anmeldung und Registrierung; alles +andere im Programm funktioniert auch ohne Konto. Angemeldet gibt es drei +Unterreiter: + + Charaktere alle Charaktere aller Spieler mit Zustand (KIA, MIA ...) + Squads alle Squads, eigene verwalten, neues gruenden + Einladungen erhaltene annehmen oder ablehnen, verschickte zurueckziehen + +Dazu steuert AbgleichSteuerung, wann die eigenen Akten mit dem Server +abgeglichen werden. Alle Serveraufrufe laufen ueber hintergrund.py, damit +das Fenster nie einfriert. +""" + +import io +import time +import tkinter as tk +import webbrowser +from tkinter import messagebox, ttk + +from PIL import Image, ImageOps, ImageTk + +import abgleich +import akte +import akte_modell as modell +import akte_vorlagen as vorlagen +import konto +from hintergrund import Hintergrund +from theme import (AMBER, BG, FG, FG_DIM, FONT_BOLD, FONT_UI, OLIVE_HI, PANEL, RED, + dunkle_titelleiste) + +ALLE_FRAKTIONEN = "Alle Fraktionen" +ZUSTAND = { + "aktiv": ("", "aktiv"), + "verwundet": ("WIA", "verwundet"), + "vermisst": ("MIA", "vermisst"), + "gefallen": ("KIA", "gefallen"), + "außer Dienst": ("a. D.", "außer Dienst"), +} + + +def zustand_text(status): + kurz, lang = ZUSTAND.get(status, ("", status or "aktiv")) + return f"{kurz} · {lang}" if kurz else lang + + +def charakter_name(c): + name = " ".join(t for t in (c.get("vorname", ""), c.get("nachname", "")) if t) + if c.get("callsign"): + return f'{c["callsign"]} · {c.get("nachname") or name}' if name else c["callsign"] + return name or c.get("aktennummer") or "Ohne Namen" + + +def fehlertext(fehler): + if isinstance(fehler, konto.ServerFehler): + return fehler.meldung + return f"Unerwarteter Fehler: {fehler}" + + +def dialog_zentrieren(fenster, eltern): + dunkle_titelleiste(fenster) + fenster.update_idletasks() + oben = eltern.winfo_toplevel() + x = oben.winfo_rootx() + (oben.winfo_width() - fenster.winfo_width()) // 2 + y = oben.winfo_rooty() + (oben.winfo_height() - fenster.winfo_height()) // 3 + fenster.geometry(f"+{max(x, 0)}+{max(y, 0)}") + + +# -- Abgleich ---------------------------------------------------------------------- + +class AbgleichSteuerung: + """Stoesst den Abgleich an: nach dem Anmelden, kurz nach Aenderungen und regelmaessig.""" + + NACH_AENDERUNG_MS = 4000 + TAKT_MS = 5 * 60 * 1000 + + def __init__(self, widget, hintergrund, akte_seite, protokollieren, bei_abmeldung): + self.widget = widget + self.hintergrund = hintergrund + self.akte_seite = akte_seite + self.protokollieren = protokollieren + self.bei_abmeldung = bei_abmeldung + self.beobachter = [akte_seite.abgleich_zustand] + self._job = None + self._laeuft = False + self._erneut = False + akte_seite.bei_gespeichert = lambda: self.anstossen(self.NACH_AENDERUNG_MS) + self.melden() + widget.after(1500, self._takt) + + def melden(self, text=None, art="aus"): + if text is None: + text, art = ("Angemeldet – Abgleich folgt", "aus") if konto.angemeldet() \ + else ("Nicht angemeldet – Akten liegen nur auf diesem PC", "aus") + for beobachter in self.beobachter: + beobachter(text, art) + + def anstossen(self, verzoegerung_ms=0): + if not konto.angemeldet(): + self.melden() + return + if self._job is not None: + self.widget.after_cancel(self._job) + self._job = self.widget.after(verzoegerung_ms, self._starten) + + def _starten(self): + self._job = None + if self._laeuft: + self._erneut = True + return + self._laeuft = True + self.akte_seite.speichern_sofort() + self.melden("Abgleich läuft …", "laeuft") + self.hintergrund.starten(abgleich.abgleichen, self._fertig, self._fehler) + + def _nachlauf(self): + self._laeuft = False + if self._erneut: + self._erneut = False + self.anstossen(500) + + def _fertig(self, ergebnis): + if ergebnis is not None: + self.akte_seite.nach_abgleich(ergebnis["geaendert"]) + text = f"Mit dem Server abgeglichen · {time.strftime('%H:%M')}" + if ergebnis["konflikte"]: + text += (f" · {ergebnis['konflikte']} Konflikt(e): die Serverfassung liegt als " + "konflikt-Datei im Aktenordner") + self.melden(text, "offline" if ergebnis["konflikte"] else "ok") + self._nachlauf() + + def _fehler(self, fehler): + if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet": + self.melden("Die Anmeldung ist abgelaufen – bitte neu anmelden", "fehler") + self.bei_abmeldung() + elif isinstance(fehler, konto.ServerFehler) and fehler.code == "offline": + self.melden("Offline – Änderungen werden später hochgeladen", "offline") + else: + self.protokollieren(type(fehler), fehler, fehler.__traceback__) + self.melden(f"Abgleich gescheitert: {fehlertext(fehler)}", "fehler") + self._nachlauf() + + def _takt(self): + if konto.angemeldet(): + self.anstossen() + try: + self.widget.after(self.TAKT_MS, self._takt) + except tk.TclError: + pass + + +# -- Anmeldung und Registrierung ------------------------------------------------------ + +class AnmeldeFlaeche(ttk.Frame): + def __init__(self, master, hintergrund, bei_anmeldung): + super().__init__(master) + self.hintergrund = hintergrund + self.bei_anmeldung = bei_anmeldung + self._knoepfe = [] + + mitte = ttk.Frame(self) + mitte.place(relx=0.5, rely=0.42, anchor="center") + ttk.Label(mitte, text="SQUAD", font=("Segoe UI Semibold", 16)).pack(anchor="w") + ttk.Label(mitte, style="Dim.TLabel", justify="left", wraplength=420, text=( + "Mit einem Konto liegen deine Akten sicher auf dem Server, du siehst die " + "Charaktere der anderen Spieler und kannst Squads bilden. Ohne Konto " + "funktioniert alles andere wie bisher.")).pack(anchor="w", pady=(4, 14)) + + reiter = ttk.Notebook(mitte) + reiter.pack(fill="x") + self.reiter = reiter + self._anmelden_aufbauen(reiter) + self._registrieren_aufbauen(reiter) + + self.meldung_var = tk.StringVar() + self.meldung = ttk.Label(mitte, textvariable=self.meldung_var, wraplength=420, justify="left") + self.meldung.pack(anchor="w", pady=(12, 0)) + self.erneut_knopf = ttk.Button(mitte, text="Bestätigungsmail erneut senden", + command=self.bestaetigung_erneut) + + verweise = ttk.Frame(mitte) + verweise.pack(anchor="w", pady=(14, 0)) + for text, pfad in (("Passwort vergessen?", None), + ("Impressum und Datenschutz", "https://tyrveil.com/rechtliches#impressum")): + verweis = ttk.Label(verweise, text=text, style="Dim.TLabel", cursor="hand2") + verweis.pack(side="left", padx=(0, 18)) + ziel = pfad or konto.webseite("/konto/vergessen.php") + verweis.bind("", lambda e, z=ziel: webbrowser.open(z)) + + @staticmethod + def _feld(eltern, zeile, beschriftung, verdeckt=False): + ttk.Label(eltern, text=beschriftung).grid(row=zeile, column=0, sticky="w", pady=5, padx=(0, 12)) + var = tk.StringVar() + eingabe = ttk.Entry(eltern, textvariable=var, width=34, show="•" if verdeckt else "") + eingabe.grid(row=zeile, column=1, sticky="ew", pady=5) + return var, eingabe + + def _anmelden_aufbauen(self, reiter): + f = ttk.Frame(reiter, padding=16) + reiter.add(f, text="Anmelden") + self.login_var, erstes = self._feld(f, 0, "Benutzername oder E-Mail") + self.passwort_var, pw = self._feld(f, 1, "Passwort", verdeckt=True) + knopf = ttk.Button(f, text="Anmelden", style="Accent.TButton", command=self.anmelden) + knopf.grid(row=2, column=1, sticky="e", pady=(10, 0)) + self._knoepfe.append(knopf) + for eingabe in (erstes, pw): + eingabe.bind("", lambda e: self.anmelden()) + self.erstes_feld = erstes + + def _registrieren_aufbauen(self, reiter): + f = ttk.Frame(reiter, padding=16) + reiter.add(f, text="Registrieren") + self.neu_name_var, _ = self._feld(f, 0, "Benutzername") + self.neu_email_var, _ = self._feld(f, 1, "E-Mail") + self.neu_pw_var, _ = self._feld(f, 2, "Passwort (mind. 10 Zeichen)", verdeckt=True) + self.neu_pw2_var, letztes = self._feld(f, 3, "Passwort wiederholen", verdeckt=True) + letztes.bind("", lambda e: self.registrieren()) + knopf = ttk.Button(f, text="Konto anlegen", style="Accent.TButton", command=self.registrieren) + knopf.grid(row=4, column=1, sticky="e", pady=(10, 0)) + self._knoepfe.append(knopf) + + def _zeigen(self, text, art="info"): + farben = {"info": FG, "ok": OLIVE_HI, "fehler": RED, "warnung": AMBER} + self.meldung_var.set(text) + self.meldung.configure(foreground=farben.get(art, FG)) + + def _beschaeftigt(self, ja): + for knopf in self._knoepfe: + knopf.configure(state="disabled" if ja else "normal") + + def anmelden(self): + login, passwort = self.login_var.get().strip(), self.passwort_var.get() + if not login or not passwort: + self._zeigen("Bitte Benutzername oder E-Mail und Passwort eingeben.", "warnung") + return + self.erneut_knopf.pack_forget() + self._beschaeftigt(True) + self._zeigen("Melde an …") + + def fertig(nutzer): + self._beschaeftigt(False) + self.passwort_var.set("") + self._zeigen("") + self.bei_anmeldung(nutzer) + + def fehler(f): + self._beschaeftigt(False) + self._zeigen(fehlertext(f), "fehler") + if isinstance(f, konto.ServerFehler) and f.code == "nicht_bestaetigt": + self.erneut_knopf.pack(anchor="w", pady=(8, 0)) + + self.hintergrund.starten(lambda: konto.anmelden(login, passwort), fertig, fehler) + + def bestaetigung_erneut(self): + email = self.login_var.get().strip() + if "@" not in email: + self._zeigen("Trage oben deine E-Mail-Adresse ein, dann schicken wir die Mail erneut.", "warnung") + return + self.hintergrund.starten(lambda: konto.bestaetigung_erneut(email), + lambda antwort: self._zeigen(antwort.get("meldung", "Mail ist unterwegs."), "ok"), + lambda f: self._zeigen(fehlertext(f), "fehler")) + + def registrieren(self): + name, email = self.neu_name_var.get().strip(), self.neu_email_var.get().strip() + pw, pw2 = self.neu_pw_var.get(), self.neu_pw2_var.get() + if not name or not email or not pw: + self._zeigen("Bitte alle Felder ausfüllen.", "warnung") + return + if pw != pw2: + self._zeigen("Die beiden Passwörter stimmen nicht überein.", "warnung") + return + self._beschaeftigt(True) + self._zeigen("Lege Konto an …") + + def fertig(antwort): + self._beschaeftigt(False) + self.neu_pw_var.set("") + self.neu_pw2_var.set("") + self.login_var.set(email) + self.reiter.select(0) + self._zeigen("Konto angelegt. Bitte bestätige den Link in der Mail an " + f"{email} – danach kannst du dich hier anmelden.", "ok") + + def fehler(f): + self._beschaeftigt(False) + self._zeigen(fehlertext(f), "fehler") + + self.hintergrund.starten(lambda: konto.registrieren(name, email, pw), fertig, fehler) + + +# -- Fremde Akte ansehen ---------------------------------------------------------------- + +def akte_fenster(eltern, charakter, bild_bytes): + """Zeigt eine Akte vom Server als Dokument in einem eigenen Fenster.""" + fenster = tk.Toplevel(eltern) + fenster.title(f"Akte {charakter.get('aktennummer') or ''} – {charakter_name(charakter)}") + fenster.configure(bg=BG) + fenster.geometry("720x820") + fenster.transient(eltern.winfo_toplevel()) + leinwand = tk.Canvas(fenster, bg=BG, highlightthickness=0, bd=0) + leiste = ttk.Scrollbar(fenster, orient="vertical", command=leinwand.yview) + leinwand.configure(yscrollcommand=leiste.set) + leiste.pack(side="right", fill="y") + leinwand.pack(side="left", fill="both", expand=True) + + daten = modell.migrieren(dict(charakter.get("daten") or {})) + daten["aktennummer"] = charakter.get("aktennummer") or daten.get("aktennummer", "") + fotos = {} + + def foto_fuer(groesse): + if not bild_bytes: + return None + if groesse not in fotos: + with Image.open(io.BytesIO(bild_bytes)) as bild: + fotos[groesse] = ImageTk.PhotoImage(ImageOps.contain(bild.convert("RGBA"), groesse)) + return fotos[groesse] + + zeichnen = lambda e=None: akte.dokument_zeichnen(leinwand, daten, foto_fuer) # noqa: E731 + leinwand.bind("", zeichnen) + leinwand.bind("", lambda e: leinwand.yview_scroll(int(-e.delta / 120), "units")) + fenster.bind("", lambda e: fenster.destroy()) + dialog_zentrieren(fenster, eltern) + return fenster + + +# -- Hauptreiter ------------------------------------------------------------------------ + +def _tabelle(eltern, spalten, hoehe=12): + rahmen = ttk.Frame(eltern) + baum = ttk.Treeview(rahmen, columns=[s for s, _, _ in spalten], show="headings", + selectmode="browse", height=hoehe) + for schluessel, titel, breite in spalten: + baum.heading(schluessel, text=titel, anchor="w") + baum.column(schluessel, width=breite, anchor="w", stretch=True) + leiste = ttk.Scrollbar(rahmen, orient="vertical", command=baum.yview) + baum.configure(yscrollcommand=leiste.set) + baum.pack(side="left", fill="both", expand=True) + leiste.pack(side="right", fill="y") + baum.tag_configure("kia", foreground=RED) + baum.tag_configure("mia", foreground=AMBER) + baum.tag_configure("wia", foreground=AMBER) + baum.tag_configure("ad", foreground=FG_DIM) + baum.tag_configure("eigener", foreground=OLIVE_HI) + return rahmen, baum + + +def _zustand_tag(status): + return {"gefallen": "kia", "vermisst": "mia", "verwundet": "wia", "außer Dienst": "ad"}.get(status, "") + + +class SquadSeite(ttk.Frame): + def __init__(self, master, akte_seite, protokollieren): + super().__init__(master) + self.hintergrund = Hintergrund(self) + self.akte_seite = akte_seite + self.protokollieren = protokollieren + self.charaktere = [] + self.squads = [] + self.einladungen = {"eingang": [], "ausgang": []} + self._bilder = {} + self._zuletzt_geladen = 0.0 + self._laedt = False + + self.abgleich = AbgleichSteuerung(self, self.hintergrund, akte_seite, protokollieren, + bei_abmeldung=self._abgemeldet) + self.anmeldung = AnmeldeFlaeche(self, self.hintergrund, self._angemeldet) + self.inhalt = ttk.Frame(self) + self._inhalt_aufbauen() + self.abgleich.beobachter.append(self._abgleich_zustand) + self._ansicht() + if konto.angemeldet(): + # Pruefen, ob die gespeicherte Anmeldung noch gilt + self.hintergrund.starten(konto.pruefen, lambda nutzer: self._ansicht(), + self._pruefung_gescheitert) + + # -- Umschalten ----------------------------------------------------------------- + + def _ansicht(self): + if konto.angemeldet(): + self.anmeldung.pack_forget() + self.inhalt.pack(fill="both", expand=True) + nutzer = konto.nutzer() or {} + self.nutzer_var.set(f"Angemeldet als {nutzer.get('benutzername', '?')}") + else: + self.inhalt.pack_forget() + self.anmeldung.pack(fill="both", expand=True) + + def _pruefung_gescheitert(self, fehler): + if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet": + self._abgemeldet() + + def _angemeldet(self, nutzer): + self._ansicht() + self.abgleich.anstossen(0) + self.aktualisieren() + + def _abgemeldet(self): + self.charaktere, self.squads = [], [] + self.einladungen = {"eingang": [], "ausgang": []} + self._ansicht() + self.abgleich.melden() + + def abmelden(self): + if not messagebox.askyesno("Abmelden", + "Abmelden? Deine Akten bleiben auf diesem PC und werden " + "nach der nächsten Anmeldung wieder abgeglichen.", parent=self): + return + self.hintergrund.starten(konto.abmelden, lambda _: self._abgemeldet(), + lambda f: self._abgemeldet()) + + def konto_loeschen(self): + """Loescht das Konto samt Akten auf dem Server. Die lokalen Akten bleiben.""" + fenster = tk.Toplevel(self) + fenster.title("Konto löschen") + fenster.configure(bg=BG) + fenster.resizable(False, False) + fenster.transient(self.winfo_toplevel()) + f = ttk.Frame(fenster, padding=18) + f.pack(fill="both") + ttk.Label(f, wraplength=380, justify="left", text=( + "Das Konto wird mit allen Charakteren auf dem Server gelöscht. Führt einer " + "deiner Charaktere ein Squad, übernimmt das dienstälteste Mitglied.\n\n" + "Deine Akten auf diesem PC bleiben erhalten. Das lässt sich nicht rückgängig machen.") + ).grid(row=0, column=0, columnspan=2, sticky="w") + ttk.Label(f, text="Passwort zur Bestätigung").grid(row=1, column=0, sticky="w", pady=(14, 0), padx=(0, 12)) + passwort = tk.StringVar() + eingabe = ttk.Entry(f, textvariable=passwort, show="•", width=28) + eingabe.grid(row=1, column=1, sticky="ew", pady=(14, 0)) + + def loeschen(): + wert = passwort.get() + if wert: + fenster.destroy() + self.konto_loeschen_ausfuehren(wert) + + knoepfe = ttk.Frame(f) + knoepfe.grid(row=2, column=0, columnspan=2, sticky="e", pady=(16, 0)) + ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right") + ttk.Button(knoepfe, text="Endgültig löschen", command=loeschen).pack(side="right", padx=(0, 8)) + fenster.bind("", lambda e: fenster.destroy()) + dialog_zentrieren(fenster, self) + fenster.grab_set() + eingabe.focus_set() + + def konto_loeschen_ausfuehren(self, passwort, bestaetigen=True): + def arbeit(): + konto.aufrufen("konto_loeschen", passwort=passwort) + # Lokale Akten gelten danach als nie abgeglichen - bei einem neuen + # Konto werden sie wieder hochgeladen statt in den Papierkorb geraeumt + for eintrag in modell.alle_akten(): + (modell.ordner_von(eintrag["id"]) / abgleich.META).unlink(missing_ok=True) + konto.abmelden() + + def fertig(_): + self._abgemeldet() + if bestaetigen: + messagebox.showinfo("Konto gelöscht", "Dein Konto ist gelöscht.", parent=self) + + self.hintergrund.starten(arbeit, fertig, + lambda fehler: messagebox.showerror("Konto löschen", fehlertext(fehler), parent=self)) + + def sichtbar(self): + """Vom Hauptfenster aufgerufen, wenn der Reiter gewaehlt wird.""" + if konto.angemeldet() and time.time() - self._zuletzt_geladen > 20: + self.aktualisieren() + + # -- Aufbau ----------------------------------------------------------------------- + + def _inhalt_aufbauen(self): + kopf = ttk.Frame(self.inhalt) + kopf.pack(fill="x", pady=(8, 6)) + self.nutzer_var = tk.StringVar() + ttk.Label(kopf, textvariable=self.nutzer_var, font=FONT_BOLD).pack(side="left") + konto_menue = ttk.Menubutton(kopf, text="Konto") + menue = tk.Menu(konto_menue, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE_HI, + activeforeground="#12150f", font=FONT_UI) + menue.add_command(label="Abmelden", command=self.abmelden) + menue.add_separator() + menue.add_command(label="Konto löschen …", command=self.konto_loeschen) + konto_menue["menu"] = menue + konto_menue.pack(side="right") + ttk.Button(kopf, text="Aktualisieren", command=self.aktualisieren).pack(side="right", padx=(0, 6)) + self.status_var = tk.StringVar() + self.status = ttk.Label(kopf, textvariable=self.status_var, style="Dim.TLabel") + self.status.pack(side="left", padx=(16, 0)) + + nb = ttk.Notebook(self.inhalt) + nb.pack(fill="both", expand=True) + self.nb = nb + self._charaktere_aufbauen(nb) + self._squads_aufbauen(nb) + self._einladungen_aufbauen(nb) + + def _charaktere_aufbauen(self, nb): + seite = ttk.Frame(nb, padding=10) + nb.add(seite, text="Charaktere") + seite.columnconfigure(0, weight=1) + seite.rowconfigure(1, weight=1) + + filter_ = ttk.Frame(seite) + filter_.grid(row=0, column=0, columnspan=2, sticky="ew", pady=(0, 8)) + self.suche_var = tk.StringVar() + suche = ttk.Entry(filter_, textvariable=self.suche_var, width=24) + suche.pack(side="left") + suche.bind("", lambda e: self.aktualisieren()) + self.fraktion_var = tk.StringVar(value=ALLE_FRAKTIONEN) + fraktion = ttk.Combobox(filter_, textvariable=self.fraktion_var, state="readonly", width=28, + values=[ALLE_FRAKTIONEN] + vorlagen.fraktionsnamen()) + fraktion.pack(side="left", padx=8) + fraktion.bind("<>", lambda e: self.aktualisieren()) + fraktion.bind("", lambda e: "break") + ttk.Button(filter_, text="Suchen", command=self.aktualisieren).pack(side="left") + + rahmen, self.liste = _tabelle(seite, [("name", "Charakter", 170), ("rang", "Dienstgrad", 150), + ("zustand", "Zustand", 90), ("squad", "Squad", 110), + ("spieler", "Spieler", 90)]) + rahmen.grid(row=1, column=0, sticky="nsew") + self.liste.bind("<>", lambda e: self._charakter_gewaehlt()) + self.liste.bind("", lambda e: self.akte_ansehen()) + + detail = ttk.Frame(seite, width=240) + detail.grid(row=1, column=1, sticky="nsew", padx=(12, 0)) + detail.grid_propagate(False) + self.bild = tk.Label(detail, bg=PANEL, fg=FG_DIM, text="kein\nPorträt", font=FONT_UI, + width=20, height=10) + self.bild.pack(anchor="w") + self.detail_titel = ttk.Label(detail, text="", font=("Segoe UI Semibold", 13), wraplength=230) + self.detail_titel.pack(anchor="w", pady=(8, 2)) + self.detail_text = ttk.Label(detail, text="Wähle links einen Charakter.", style="Dim.TLabel", + wraplength=230, justify="left") + self.detail_text.pack(anchor="w") + self.knopf_ansehen = ttk.Button(detail, text="Akte ansehen", command=self.akte_ansehen) + self.knopf_ansehen.pack(anchor="w", fill="x", pady=(10, 4)) + self.knopf_einladen = ttk.Button(detail, text="In mein Squad einladen", style="Accent.TButton", + command=self.einladen) + self.knopf_einladen.pack(anchor="w", fill="x") + self.einladen_hinweis = ttk.Label(detail, text="", style="Dim.TLabel", wraplength=230) + self.einladen_hinweis.pack(anchor="w", pady=(4, 0)) + self._detail_leeren() + + def _squads_aufbauen(self, nb): + seite = ttk.Frame(nb, padding=10) + nb.add(seite, text="Squads") + seite.columnconfigure(0, weight=2) + seite.columnconfigure(1, weight=3) + seite.rowconfigure(1, weight=1) + ttk.Button(seite, text="Squad gründen …", style="Accent.TButton", + command=self.squad_gruenden).grid(row=0, column=0, sticky="w", pady=(0, 8)) + + rahmen, self.squad_liste = _tabelle(seite, [("name", "Squad", 150), ("fuehrer", "Führer", 120), + ("staerke", "Stärke", 55)]) + rahmen.grid(row=1, column=0, sticky="nsew") + self.squad_liste.bind("<>", lambda e: self._squad_gewaehlt()) + + rechts = ttk.Frame(seite) + rechts.grid(row=1, column=1, sticky="nsew", padx=(12, 0)) + rechts.rowconfigure(2, weight=1) + rechts.columnconfigure(0, weight=1) + self.squad_titel = ttk.Label(rechts, text="Wähle ein Squad.", font=("Segoe UI Semibold", 13)) + self.squad_titel.grid(row=0, column=0, sticky="w") + self.squad_beschreibung = ttk.Label(rechts, text="", style="Dim.TLabel", wraplength=420, justify="left") + self.squad_beschreibung.grid(row=1, column=0, sticky="w", pady=(2, 8)) + rahmen, self.mitglieder = _tabelle(rechts, [("name", "Mitglied", 150), ("rang", "Dienstgrad", 140), + ("zustand", "Zustand", 80), ("spieler", "Spieler", 80)], 8) + rahmen.grid(row=2, column=0, sticky="nsew") + self.mitglieder.bind("<>", lambda e: self._squad_knoepfe()) + knoepfe = ttk.Frame(rechts) + knoepfe.grid(row=3, column=0, sticky="w", pady=(8, 0)) + self.knopf_entfernen = ttk.Button(knoepfe, text="Entfernen", command=self.mitglied_entfernen) + self.knopf_uebergeben = ttk.Button(knoepfe, text="Führung übergeben", command=self.fuehrung_uebergeben) + self.knopf_verlassen = ttk.Button(knoepfe, text="Squad verlassen", command=self.squad_verlassen) + self.knopf_aufloesen = ttk.Button(knoepfe, text="Squad auflösen", command=self.squad_aufloesen) + for knopf in (self.knopf_entfernen, self.knopf_uebergeben, self.knopf_verlassen, self.knopf_aufloesen): + knopf.pack(side="left", padx=(0, 6)) + self._squad_knoepfe() + + def _einladungen_aufbauen(self, nb): + seite = ttk.Frame(nb, padding=10) + nb.add(seite, text="Einladungen") + self.einladungen_seite = seite + seite.columnconfigure(0, weight=1) + seite.rowconfigure(1, weight=1) + seite.rowconfigure(4, weight=1) + + ttk.Label(seite, text="ERHALTEN", style="Dim.TLabel").grid(row=0, column=0, sticky="w") + rahmen, self.eingang = _tabelle(seite, [("squad", "Squad", 170), ("fuer", "Für deinen Charakter", 190), + ("von", "Eingeladen von", 190)], 6) + rahmen.grid(row=1, column=0, sticky="nsew") + knoepfe = ttk.Frame(seite) + knoepfe.grid(row=2, column=0, sticky="w", pady=(6, 14)) + ttk.Button(knoepfe, text="Annehmen", style="Accent.TButton", + command=lambda: self.einladung_beantworten(True)).pack(side="left", padx=(0, 6)) + ttk.Button(knoepfe, text="Ablehnen", command=lambda: self.einladung_beantworten(False)).pack(side="left") + + ttk.Label(seite, text="VERSCHICKT", style="Dim.TLabel").grid(row=3, column=0, sticky="w") + rahmen, self.ausgang = _tabelle(seite, [("squad", "Squad", 170), ("charakter", "Eingeladen", 190), + ("spieler", "Spieler", 190)], 5) + rahmen.grid(row=4, column=0, sticky="nsew") + ttk.Button(seite, text="Zurückziehen", command=self.einladung_zurueckziehen).grid( + row=5, column=0, sticky="w", pady=(6, 0)) + + # -- Laden ------------------------------------------------------------------------ + + def _abgleich_zustand(self, text, art): + if not self._laedt: + self.status_var.set(text) + + def aktualisieren(self): + if not konto.angemeldet() or self._laedt: + return + self._laedt = True + self.status_var.set("Lädt …") + suche = self.suche_var.get().strip() + fraktion = "" if self.fraktion_var.get() == ALLE_FRAKTIONEN else self.fraktion_var.get() + + def arbeit(): + return (konto.aufrufen("charaktere_alle", suche=suche, fraktion=fraktion)["charaktere"], + konto.aufrufen("squads")["squads"], + konto.aufrufen("einladungen")) + + self.hintergrund.starten(arbeit, self._geladen, self._laden_gescheitert) + + def _laden_gescheitert(self, fehler): + self._laedt = False + if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet": + self._abgemeldet() + return + self.status_var.set(fehlertext(fehler)) + + def _geladen(self, ergebnis): + self._laedt = False + self._zuletzt_geladen = time.time() + self.charaktere, self.squads, einladungen = ergebnis + self.einladungen = {"eingang": einladungen.get("eingang", []), "ausgang": einladungen.get("ausgang", [])} + self.status_var.set(f"{len(self.charaktere)} Charaktere · {len(self.squads)} Squads · " + f"Stand {time.strftime('%H:%M')}") + self._liste_fuellen() + self._squads_fuellen() + self._einladungen_fuellen() + + def _ersetzen(self, baum, zeilen): + auswahl = baum.selection() + baum.delete(*baum.get_children()) + for iid, werte, tags in zeilen: + baum.insert("", "end", iid=iid, values=werte, tags=tags) + if auswahl and baum.exists(auswahl[0]): + baum.selection_set(auswahl[0]) + + def _liste_fuellen(self): + zeilen = [] + for c in self.charaktere: + tags = tuple(t for t in (_zustand_tag(c["status"]), "eigener" if c["eigener"] else "") if t) + zeilen.append((str(c["id"]), (charakter_name(c), c["rang"], zustand_text(c["status"]), + (c.get("squad") or {}).get("name", "—"), c["spieler"]), tags)) + self._ersetzen(self.liste, zeilen) + self._charakter_gewaehlt() + + def _squads_fuellen(self): + zeilen = [] + for s in self.squads: + fuehrer = next((m for m in s["mitglieder"] if m["id"] == s["fuehrer_id"]), None) + zeilen.append((str(s["id"]), (s["name"], charakter_name(fuehrer) if fuehrer else "—", + len(s["mitglieder"])), ())) + self._ersetzen(self.squad_liste, zeilen) + self._squad_gewaehlt() + + def _einladungen_fuellen(self): + self._ersetzen(self.eingang, [ + (str(e["id"]), ((e.get("squad") or {}).get("name", "?"), charakter_name(e.get("charakter") or {}), + charakter_name(e.get("von") or {}) + f" ({(e.get('von') or {}).get('spieler', '?')})"), ()) + for e in self.einladungen["eingang"]]) + self._ersetzen(self.ausgang, [ + (str(e["id"]), ((e.get("squad") or {}).get("name", "?"), charakter_name(e.get("charakter") or {}), + (e.get("charakter") or {}).get("spieler", "?")), ()) + for e in self.einladungen["ausgang"]]) + anzahl = len(self.einladungen["eingang"]) + self.nb.tab(self.einladungen_seite, text=f"Einladungen ({anzahl})" if anzahl else "Einladungen") + + # -- Charaktere ------------------------------------------------------------------- + + def _gewaehlter(self): + auswahl = self.liste.selection() + return next((c for c in self.charaktere if str(c["id"]) == auswahl[0]), None) if auswahl else None + + def _eigene_ids(self): + return {c["id"] for c in self.charaktere if c["eigener"]} + + def _meine_gefuehrten_squads(self): + eigene = self._eigene_ids() + return [s for s in self.squads if s["fuehrer_id"] in eigene] + + def _detail_leeren(self): + self.bild.configure(image="", text="kein\nPorträt", width=20, height=10) + self.detail_titel.configure(text="") + self.detail_text.configure(text="Wähle links einen Charakter.") + self.knopf_ansehen.configure(state="disabled") + self.knopf_einladen.configure(state="disabled") + self.einladen_hinweis.configure(text="") + + def _charakter_gewaehlt(self): + c = self._gewaehlter() + if c is None: + self._detail_leeren() + return + self.detail_titel.configure(text=c["callsign"] or charakter_name(c)) + zeilen = [ + " ".join(t for t in (c["rang"], c["vorname"], c["nachname"]) if t), + " · ".join(t for t in (c["fraktion"], c["teilstreitkraft"]) if t), + c["verwendung"], + f"Zustand: {zustand_text(c['status'])}", + f"Squad: {(c.get('squad') or {}).get('name', '—')}", + f"Spieler: {c['spieler']}" + (" (du)" if c["eigener"] else ""), + c.get("aktennummer") or "", + ] + self.detail_text.configure(text="\n".join(z for z in zeilen if z)) + self.knopf_ansehen.configure(state="normal") + + gefuehrt = self._meine_gefuehrten_squads() + hinweis = "" + if c.get("squad"): + hinweis = "Ist schon in einem Squad." + elif not gefuehrt: + hinweis = "Zum Einladen brauchst du ein Squad, das einer deiner Charaktere führt." + self.knopf_einladen.configure(state="disabled" if hinweis else "normal") + self.einladen_hinweis.configure(text=hinweis) + self._bild_zeigen(c) + + def _bild_zeigen(self, c): + if not c["portraet"]: + self.bild.configure(image="", text="kein\nPorträt", width=20, height=10) + return + schluessel = (c["id"], c.get("portraet_kennung")) + if schluessel in self._bilder: + foto = self._bilder[schluessel][1] + self.bild.configure(image=foto, text="", width=foto.width(), height=foto.height()) + return + self.bild.configure(image="", text="lädt …", width=20, height=10) + + def fertig(daten): + if not daten: + return + with Image.open(io.BytesIO(daten)) as bild: + foto = ImageTk.PhotoImage(ImageOps.contain(bild.convert("RGBA"), (150, 190))) + self._bilder[schluessel] = (daten, foto) + aktuell = self._gewaehlter() + if aktuell is not None and aktuell["id"] == c["id"]: + self.bild.configure(image=foto, text="", width=foto.width(), height=foto.height()) + + self.hintergrund.starten(lambda: konto.bild(c["id"]), fertig, lambda f: None) + + def akte_ansehen(self): + c = self._gewaehlter() + if c is None: + return + + def arbeit(): + voll = konto.aufrufen("charakter_ansehen", id=c["id"])["charakter"] + bild = konto.bild(c["id"]) if voll.get("portraet") else None + return voll, bild + + self.hintergrund.starten(arbeit, lambda erg: akte_fenster(self, erg[0], erg[1]), + lambda f: messagebox.showerror("Akte", fehlertext(f), parent=self)) + + def einladen(self): + c = self._gewaehlter() + gefuehrt = self._meine_gefuehrten_squads() + if c is None or not gefuehrt: + return + if len(gefuehrt) == 1: + self._einladen_in(gefuehrt[0], c) + return + menue = tk.Menu(self, tearoff=False) + for squad in gefuehrt: + menue.add_command(label=squad["name"], command=lambda s=squad: self._einladen_in(s, c)) + knopf = self.knopf_einladen + menue.tk_popup(knopf.winfo_rootx(), knopf.winfo_rooty() + knopf.winfo_height()) + + def _einladen_in(self, squad, c): + self._aktion(lambda: konto.aufrufen("squad_einladen", squad_id=squad["id"], charakter_id=c["id"]), + f"{charakter_name(c)} ist zu {squad['name']} eingeladen. Der Spieler muss annehmen.") + + # -- Squads ----------------------------------------------------------------------- + + def _gewaehltes_squad(self): + auswahl = self.squad_liste.selection() + return next((s for s in self.squads if str(s["id"]) == auswahl[0]), None) if auswahl else None + + def _squad_gewaehlt(self): + s = self._gewaehltes_squad() + if s is None: + self.squad_titel.configure(text="Wähle ein Squad." if self.squads else "Noch keine Squads.") + self.squad_beschreibung.configure(text="") + self._ersetzen(self.mitglieder, []) + else: + self.squad_titel.configure(text=s["name"]) + self.squad_beschreibung.configure(text=s.get("beschreibung") or "") + # Der Fuehrer steht immer oben, die anderen in Reihenfolge des Beitritts + mitglieder = sorted(s["mitglieder"], key=lambda m: m["id"] != s["fuehrer_id"]) + self._ersetzen(self.mitglieder, [ + (str(m["id"]), (("★ " if m["id"] == s["fuehrer_id"] else "") + charakter_name(m), m["rang"], + zustand_text(m["status"]), m["spieler"]), + tuple(t for t in (_zustand_tag(m["status"]), "eigener" if m["eigener"] else "") if t)) + for m in mitglieder]) + self._squad_knoepfe() + + def _gewaehltes_mitglied(self, squad): + auswahl = self.mitglieder.selection() + if squad is None or not auswahl: + return None + return next((m for m in squad["mitglieder"] if str(m["id"]) == auswahl[0]), None) + + def _squad_knoepfe(self): + s = self._gewaehltes_squad() + eigene = self._eigene_ids() + fuehre = s is not None and s["fuehrer_id"] in eigene + mitglied = self._gewaehltes_mitglied(s) + fremdes_mitglied = mitglied is not None and mitglied["id"] != s["fuehrer_id"] + mein_mitglied = s is not None and any(m["id"] in eigene and m["id"] != s["fuehrer_id"] + for m in s["mitglieder"]) + self.knopf_entfernen.configure(state="normal" if fuehre and fremdes_mitglied else "disabled") + self.knopf_uebergeben.configure(state="normal" if fuehre and fremdes_mitglied else "disabled") + self.knopf_aufloesen.configure(state="normal" if fuehre else "disabled") + self.knopf_verlassen.configure(state="normal" if mein_mitglied or (fuehre and len(s["mitglieder"]) == 1) + else "disabled") + + def squad_gruenden(self): + frei = [c for c in self.charaktere if c["eigener"] and not c.get("squad")] + if not frei: + messagebox.showinfo("Squad gründen", + "Du brauchst einen eigenen Charakter ohne Squad. Neue Akten erscheinen " + "hier, sobald sie mit dem Server abgeglichen sind.", parent=self) + return + fenster = tk.Toplevel(self) + fenster.title("Squad gründen") + fenster.configure(bg=BG) + fenster.resizable(False, False) + fenster.transient(self.winfo_toplevel()) + f = ttk.Frame(fenster, padding=18) + f.pack(fill="both") + ttk.Label(f, text="Name des Squads").grid(row=0, column=0, sticky="w", pady=5, padx=(0, 12)) + name_var = tk.StringVar() + name = ttk.Entry(f, textvariable=name_var, width=36) + name.grid(row=0, column=1, sticky="ew", pady=5) + ttk.Label(f, text="Geführt von").grid(row=1, column=0, sticky="w", pady=5, padx=(0, 12)) + namen = [charakter_name(c) for c in frei] + fuehrer_var = tk.StringVar(value=namen[0]) + ttk.Combobox(f, textvariable=fuehrer_var, values=namen, state="readonly", width=34).grid( + row=1, column=1, sticky="ew", pady=5) + ttk.Label(f, text="Beschreibung").grid(row=2, column=0, sticky="nw", pady=5, padx=(0, 12)) + beschreibung = tk.Text(f, width=36, height=4, **akte.TEXT_STIL) + beschreibung.grid(row=2, column=1, sticky="ew", pady=5) + + def gruenden(): + c = frei[namen.index(fuehrer_var.get())] + text = beschreibung.get("1.0", "end-1c").strip() + wert = name_var.get().strip() + fenster.destroy() + self._aktion(lambda: konto.aufrufen("squad_gruenden", charakter_id=c["id"], name=wert, + beschreibung=text), + f"Squad {wert} gegründet.") + + knoepfe = ttk.Frame(f) + knoepfe.grid(row=3, column=0, columnspan=2, sticky="e", pady=(12, 0)) + ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right") + ttk.Button(knoepfe, text="Gründen", style="Accent.TButton", command=gruenden).pack(side="right", padx=(0, 8)) + fenster.bind("", lambda e: fenster.destroy()) + dialog_zentrieren(fenster, self) + fenster.grab_set() + name.focus_set() + + def mitglied_entfernen(self): + s = self._gewaehltes_squad() + m = self._gewaehltes_mitglied(s) + if m and messagebox.askyesno("Entfernen", f"{charakter_name(m)} aus {s['name']} entfernen?", parent=self): + self._aktion(lambda: konto.aufrufen("squad_entfernen", squad_id=s["id"], charakter_id=m["id"]), + f"{charakter_name(m)} wurde entfernt.") + + def fuehrung_uebergeben(self): + s = self._gewaehltes_squad() + m = self._gewaehltes_mitglied(s) + if m and messagebox.askyesno("Führung übergeben", + f"Die Führung von {s['name']} an {charakter_name(m)} übergeben?", parent=self): + self._aktion(lambda: konto.aufrufen("squad_fuehrung_uebergeben", squad_id=s["id"], charakter_id=m["id"]), + f"{charakter_name(m)} führt jetzt {s['name']}.") + + def squad_verlassen(self): + s = self._gewaehltes_squad() + if s is None: + return + eigene = [m for m in s["mitglieder"] if m["eigener"]] + # Wer allein fuehrt, verlaesst das Squad damit auch - es wird aufgeloest + kandidaten = [m for m in eigene if m["id"] != s["fuehrer_id"]] or eigene + if not kandidaten: + return + m = kandidaten[0] + if messagebox.askyesno("Squad verlassen", f"{charakter_name(m)} verlässt {s['name']}?", parent=self): + self._aktion(lambda: konto.aufrufen("squad_verlassen", charakter_id=m["id"]), + f"{charakter_name(m)} hat {s['name']} verlassen.") + + def squad_aufloesen(self): + s = self._gewaehltes_squad() + if s and messagebox.askyesno("Squad auflösen", + f"{s['name']} auflösen? Alle Mitglieder sind danach ohne Squad.", parent=self): + self._aktion(lambda: konto.aufrufen("squad_aufloesen", squad_id=s["id"]), f"{s['name']} wurde aufgelöst.") + + # -- Einladungen ------------------------------------------------------------------ + + def einladung_beantworten(self, annehmen): + auswahl = self.eingang.selection() + if not auswahl: + return + e = next((x for x in self.einladungen["eingang"] if str(x["id"]) == auswahl[0]), None) + if e is None: + return + squad = (e.get("squad") or {}).get("name", "das Squad") + self._aktion(lambda: konto.aufrufen("einladung_beantworten", einladung_id=e["id"], annehmen=annehmen), + f"Willkommen in {squad}." if annehmen else "Einladung abgelehnt.") + + def einladung_zurueckziehen(self): + auswahl = self.ausgang.selection() + if auswahl: + self._aktion(lambda: konto.aufrufen("einladung_zurueckziehen", einladung_id=int(auswahl[0])), + "Einladung zurückgezogen.") + + # -- Gemeinsam -------------------------------------------------------------------- + + def _aktion(self, arbeit, erfolg): + self.status_var.set("Einen Moment …") + + def fertig(_): + self.status_var.set(erfolg) + self._laedt = False + self.aktualisieren() + + def fehler(f): + if isinstance(f, konto.ServerFehler) and f.code == "nicht_angemeldet": + self._abgemeldet() + return + self.status_var.set("") + messagebox.showerror("Squad", fehlertext(f), parent=self) + self.aktualisieren() + + self.hintergrund.starten(arbeit, fertig, fehler) diff --git a/squad_manager.py b/squad_manager.py index 26c3e39..58123d2 100644 --- a/squad_manager.py +++ b/squad_manager.py @@ -57,15 +57,16 @@ from theme import ( # noqa: E402 apply_tactical_theme, LevelMeter, ) import akte # noqa: E402 +import squad # noqa: E402 import update_helfer # noqa: E402 APP_NAME = "Squad Manager" -VERSION = "1.5.1" +VERSION = "1.6.0" # Zaehlnummer fuer den Update-Vergleich, bei jedem Release um eins erhoehen. # Seit 1.5.0 getrennt von der angezeigten Version: Die Anzeige sprang von # 4.0 auf 1.5.0 zurueck, ein Vergleich der Anzeige haette danach nie wieder # ein Update gefunden. -BUILD = 2 +BUILD = 3 # Letzte Version aus der Zeit vor den Zaehlnummern LETZTE_ALTE_VERSION = "4.0" CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "config.json" @@ -779,7 +780,7 @@ class VoiceActivationApp: ttk.Label(header, text="SQUAD MANAGER", style="Title.TLabel").pack(anchor="w") ttk.Label(header, style="Sub.TLabel", - text="Sprachaktivierung und Personalakte fuer Squad.").pack(anchor="w") + text="Sprachaktivierung, Personalakten und Squads.").pack(anchor="w") ttk.Separator(self.root, orient="horizontal").pack( fill="x", padx=18, pady=(10, 0)) @@ -797,8 +798,10 @@ class VoiceActivationApp: haupt.pack(fill="both", expand=True, padx=16, pady=(4, 8)) seite_funk = ttk.Frame(haupt) seite_akte = ttk.Frame(haupt) + seite_squad = ttk.Frame(haupt) haupt.add(seite_funk, text="FUNK") haupt.add(seite_akte, text="AKTE") + haupt.add(seite_squad, text="SQUAD") nb = ttk.Notebook(seite_funk) self.nb = nb @@ -813,6 +816,10 @@ class VoiceActivationApp: self.akte = akte.AkteSeite(seite_akte) self.akte.pack(fill="both", expand=True) + self.squad = squad.SquadSeite(seite_squad, self.akte, log_exception) + self.squad.pack(fill="both", expand=True) + haupt.bind("<>", lambda e: self.squad.sichtbar() + if haupt.index("current") == 2 else None, add="+") def _build_main_tab(self, parent): f = ttk.Frame(parent) diff --git a/start.pyw b/start.pyw index cbac97a..24653d6 100644 --- a/start.pyw +++ b/start.pyw @@ -27,7 +27,7 @@ ORDNER = Path(__file__).resolve().parent VENV_PYTHON = ORDNER / ".venv" / "Scripts" / "python.exe" ANFORDERUNGEN = ORDNER / "requirements.txt" EIGENE_MODULE = {"squad_manager", "theme", "akte", "akte_modell", "akte_vorlagen", - "akte_karte", "update_helfer"} + "akte_karte", "konto", "abgleich", "hintergrund", "squad", "update_helfer"} for pfad in (ORDNER / ".venv" / "Lib" / "site-packages", ORDNER): if pfad.is_dir(): diff --git a/werkzeuge/abgleich_test.py b/werkzeuge/abgleich_test.py index 5b8a546..e8dd3e3 100644 --- a/werkzeuge/abgleich_test.py +++ b/werkzeuge/abgleich_test.py @@ -18,13 +18,15 @@ import urllib.parse from pathlib import Path WURZEL = Path(__file__).resolve().parent.parent +# SM_PROGRAMM=dist\paket\Programm prueft das gebaute Paket statt der Quelle +PROGRAMM = Path(os.environ.get("SM_PROGRAMM") or WURZEL) sys.path.insert(0, str(Path(__file__).resolve().parent)) # -- Ein Rechner: wird als eigener Prozess mit "pc" aufgerufen ---------------- def rechner_befehl(aktion, parameter): - sys.path.insert(0, str(WURZEL)) + sys.path.insert(0, str(PROGRAMM)) import hashlib from PIL import Image @@ -230,7 +232,7 @@ def ablauf(server, pruefe): if __name__ == "__main__": if len(sys.argv) >= 2 and sys.argv[1] == "pc": - sys.path.insert(0, str(WURZEL)) + sys.path.insert(0, str(PROGRAMM)) import konto try: wert = rechner_befehl(sys.argv[2], json.loads(sys.argv[3])) diff --git a/werkzeuge/baue_release.py b/werkzeuge/baue_release.py index c238b14..8dad323 100644 --- a/werkzeuge/baue_release.py +++ b/werkzeuge/baue_release.py @@ -34,7 +34,8 @@ BASIS_URL = "https://sva.tyrveil.com" VERSION_FUER_ALTE_PROGRAMME = "4.1" PYTHON_DATEIEN = ("squad_manager.py", "theme.py", "akte.py", "akte_modell.py", - "akte_vorlagen.py", "akte_karte.py", "update_helfer.py", "start.pyw", + "akte_vorlagen.py", "akte_karte.py", "konto.py", "abgleich.py", + "hintergrund.py", "squad.py", "update_helfer.py", "start.pyw", "make_icon.py") MITKOPIEREN = ("requirements.txt", "icon.png", "icon.ico") @@ -108,6 +109,17 @@ def build_pruefen(build): print(f" Build {build} ist neuer als online ({online_build or online.get('version')})") +# Zeichenketten wie "charakter_loeschen" oder "server.json" sind Aktionsnamen, +# Schluessel und Dateinamen. Umlaute darin brechen die Verstaendigung mit dem +# Server - 1.6.0 schickte sonst "konto_löschen" an eine Schnittstelle, die +# "konto_loeschen" erwartet. +BEZEICHNER = re.compile(r"""^[rbuRBU]{0,2}(['"])[a-z0-9_.\-/]*\1$""") + + +def ist_bezeichner(zeichenkette): + return bool(BEZEICHNER.match(zeichenkette)) + + def aufbereiten(pfad: Path): """Kommentare entfernen und echte Umlaute setzen.""" quelle = pfad.read_text(encoding="utf-8") @@ -126,7 +138,7 @@ def aufbereiten(pfad: Path): tokens = [] for tok in tokenize.generate_tokens(io.StringIO(text).readline): - if tok.type == tokenize.STRING: + if tok.type == tokenize.STRING and not ist_bezeichner(tok.string): neu = tok.string for alt, ersatz in UMLAUTE: neu = neu.replace(alt, ersatz) diff --git a/werkzeuge/oberflaeche_test.py b/werkzeuge/oberflaeche_test.py new file mode 100644 index 0000000..e604d76 --- /dev/null +++ b/werkzeuge/oberflaeche_test.py @@ -0,0 +1,264 @@ +""" +Test des Squad-Reiters im laufenden Programm gegen den lokalen Testserver. + +Legt zwei Konten an, startet das Programm mit eigenem %APPDATA%, meldet +sich ueber die Eingabefelder an, wartet den Abgleich ab, nimmt eine +Einladung an und oeffnet eine fremde Akte. Bildschirmfotos landen im +Ordner, der als erstes Argument uebergeben wird (Standard: Temp). + +Aufruf: .venv\\Scripts\\python.exe werkzeuge\\oberflaeche_test.py [bildordner] +""" + +import ctypes +import ctypes.wintypes as wintypes +import os +import subprocess +import sys +import tempfile +import time +import urllib.parse +from pathlib import Path + +WURZEL = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import server_test as st # noqa: E402 + +BILDER = Path(sys.argv[1]) if len(sys.argv) > 1 else Path(tempfile.gettempdir()) +server = st.Server() +os.environ["SM_SERVER"] = server.basis +os.environ["APPDATA"] = tempfile.mkdtemp(prefix="sm_ui_") +# SM_PROGRAMM=dist\paket\Programm prueft das gebaute Paket statt der Quelle +sys.path.insert(0, os.environ.get("SM_PROGRAMM") or str(WURZEL)) + +import tkinter as tk # noqa: E402 + +from PIL import Image # noqa: E402 + +import akte_modell as modell # noqa: E402 +import konto # noqa: E402 +import squad_manager as sm # noqa: E402 + +pruefe = st.pruefe + + +def konto_anlegen(name, email, passwort): + server.api("registrieren", benutzername=name, email=email, passwort=passwort) + teile = urllib.parse.urlparse(server.link_aus_mail(email)) + server.roh(teile.path + "?" + teile.query) + return server.api("anmelden", login=name, passwort=passwort)[1]["token"] + + +# -- Vorbereitung auf dem Server und lokal --------------------------------------- +server.roh("/einrichten.php", {"schluessel": st.SCHLUESSEL}) +konto_anlegen("danny", "danny@example.org", "dannypasswort1") +kamerad = konto_anlegen("kamerad", "kamerad@example.org", "kameradpasswort1") +rook_akte = {"schema": 1, "id": "ab" * 16, "personalien": {"vorname": "Dale", "nachname": "Hutchins", "callsign": "Rook"}, + "dienst": {"fraktion": "US Marine Corps", "teilstreitkraft": "Marineinfanterie", + "rang": "Corporal (Cpl)", "verwendung": "Automatic Rifleman", "status": "gefallen"}, + "beschreibung": "Gefallen bei der Verteidigung von Point Alpha.", "auszeichnungen": [], + "einsaetze": [], "vermerke": ""} +rook = server.api("charakter_speichern", token=kamerad, lokale_id=rook_akte["id"], daten=rook_akte)[1]["charakter"] +hawk_akte = dict(rook_akte, id="cd" * 16, personalien={"vorname": "Mia", "nachname": "Lindqvist", "callsign": "Hawk"}, + dienst={"fraktion": "Schweden – Försvarsmakten", "teilstreitkraft": "Amphibienkorps (Amfibiekåren)", + "rang": "Sergeant", "verwendung": "Squad Leader", "status": "aktiv"}) +hawk = server.api("charakter_speichern", token=kamerad, lokale_id=hawk_akte["id"], daten=hawk_akte)[1]["charakter"] +squad = server.api("squad_gruenden", token=kamerad, charakter_id=hawk["id"], name="Nordwind", + beschreibung="Amphibische Aufklärung, Schären vor Stockholm.")[1]["squad"] +server.api("squad_einladen", token=kamerad, squad_id=squad["id"], charakter_id=rook["id"]) +server.api("einladung_beantworten", token=kamerad, + einladung_id=server.api("einladungen", token=kamerad)[1]["eingang"][0]["id"], annehmen=True) + +nordlicht = modell.neu_anlegen() +nordlicht["personalien"].update({"vorname": "Erik", "nachname": "Brandt", "callsign": "Nordlicht"}) +nordlicht["dienst"].update({"fraktion": "Bundeswehr", "teilstreitkraft": "Heer", "rang": "Oberfeldwebel", + "verwendung": "Squad Leader"}) +modell.speichern(nordlicht) +bild = Path(os.environ["APPDATA"]) / "portraet.jpg" +Image.new("RGB", (400, 500), (58, 70, 46)).save(bild, "JPEG") +modell.portraet_setzen(nordlicht["id"], bild) +lokale_nummer = nordlicht["aktennummer"] + + +# -- Programm --------------------------------------------------------------------- +class RECT(ctypes.Structure): + _fields_ = [("l", wintypes.LONG), ("t", wintypes.LONG), ("r", wintypes.LONG), ("b", wintypes.LONG)] + + +def foto(fenster, name): + fenster.update_idletasks() + fenster.update() + hwnd = ctypes.windll.user32.GetParent(fenster.winfo_id()) or fenster.winfo_id() + r = RECT() + ctypes.windll.user32.GetWindowRect(wintypes.HWND(hwnd), ctypes.byref(r)) + ziel = BILDER / name + ps = ("Add-Type -AssemblyName System.Drawing;" + f"$b = New-Object System.Drawing.Bitmap {r.r - r.l},{r.b - r.t};" + "$g = [System.Drawing.Graphics]::FromImage($b);" + f"$g.CopyFromScreen({r.l},{r.t},0,0,$b.Size);$b.Save('{ziel}')") + subprocess.run(["powershell", "-NoProfile", "-Command", ps], capture_output=True) + + +fehler = [] +root = tk.Tk() +sm.apply_tactical_theme(root) +app = sm.VoiceActivationApp(root) +root.report_callback_exception = lambda *a: fehler.append(a) +root.attributes("-topmost", True) +seite = app.squad + + +def warte(bedingung, dann, grenze=60.0, name=""): + start = time.time() + + def pruefen(): + if bedingung(): + dann() + elif time.time() - start > grenze: + pruefe(f"Zeitlimit: {name}", False) + ende() + else: + root.after(150, pruefen) + root.after(150, pruefen) + + +def schritt_anmeldung(): + app.haupt_nb.select(2) + root.update() + pruefe("ohne Anmeldung: Anmeldeseite", seite.anmeldung.winfo_ismapped()) + foto(root, "ui_1_anmeldung.png") + seite.anmeldung.login_var.set("danny") + seite.anmeldung.passwort_var.set("dannypasswort1") + seite.anmeldung.anmelden() + warte(lambda: konto.angemeldet() and seite.inhalt.winfo_ismapped(), schritt_abgleich, name="Anmeldung") + + +def schritt_abgleich(): + pruefe("angemeldet, Inhalt sichtbar", seite.nutzer_var.get() == "Angemeldet als danny", seite.nutzer_var.get()) + warte(lambda: "abgeglichen" in app.akte.abgleich_var.get(), schritt_liste, name="Abgleich") + + +def schritt_liste(): + geladen = modell.laden(nordlicht["id"]) + pruefe("Aktennummer vom Server übernommen", geladen["aktennummer"] != lokale_nummer + or geladen["aktennummer"].startswith("SM-"), (lokale_nummer, geladen["aktennummer"])) + pruefe("AKTE-Reiter zeigt Abgleich", "abgeglichen" in app.akte.abgleich_var.get(), app.akte.abgleich_var.get()) + seite._zuletzt_geladen = 0 + seite._laedt = False + seite.aktualisieren() + warte(lambda: len(seite.charaktere) == 3 and len(seite.einladungen["eingang"]) == 0, schritt_einladung, + name="Liste laden") + + +def schritt_einladung(): + namen = {c["callsign"]: c for c in seite.charaktere} + pruefe("drei Charaktere, eigener markiert", set(namen) == {"Nordlicht", "Rook", "Hawk"} and namen["Nordlicht"]["eigener"]) + pruefe("Zustand KIA in der Liste", seite.liste.item(str(namen["Rook"]["id"]))["values"][2] == "KIA · gefallen", + seite.liste.item(str(namen["Rook"]["id"]))["values"]) + seite.liste.selection_set(str(namen["Rook"]["id"])) + root.update() + pruefe("Einladen gesperrt ohne eigenes Squad", str(seite.knopf_einladen["state"]) == "disabled", + seite.einladen_hinweis.cget("text")) + # Das Portraet hat nur Nordlicht - hochgeladen vom Abgleich + seite.liste.selection_set(str(namen["Nordlicht"]["id"])) + root.update() + + def konto_menue_foto(): + foto(root, "ui_2_charaktere.png") + knopf = next(w for w in seite.inhalt.winfo_children()[0].winfo_children() if isinstance(w, tk.Menubutton) + or w.winfo_class() == "TMenubutton") + pruefe("Konto-Knopf vorhanden", knopf.cget("text") == "Konto") + schritt_einladen() + + warte(lambda: seite.bild.cget("text") == "", konto_menue_foto, grenze=15, name="Porträt laden") + + +def schritt_einladen(): + server.api("squad_einladen", token=kamerad, squad_id=squad["id"], + charakter_id=next(c["id"] for c in seite.charaktere if c["callsign"] == "Nordlicht")) + seite.aktualisieren() + warte(lambda: len(seite.einladungen["eingang"]) == 1, schritt_annehmen, name="Einladung laden") + + +def schritt_annehmen(): + seite.nb.select(2) + pruefe("Reiter zeigt Anzahl", seite.nb.tab(seite.einladungen_seite, "text") == "Einladungen (1)") + seite.eingang.selection_set(seite.eingang.get_children()[0]) + root.update() + foto(root, "ui_3_einladungen.png") + seite.einladung_beantworten(True) + warte(lambda: any(c["callsign"] == "Nordlicht" and c.get("squad") for c in seite.charaktere) + and not seite.einladungen["eingang"], schritt_squad, name="Annehmen") + + +def schritt_squad(): + pruefe("Nordlicht ist jetzt in Nordwind", next(c for c in seite.charaktere + if c["callsign"] == "Nordlicht")["squad"]["name"] == "Nordwind") + seite.nb.select(1) + seite.squad_liste.selection_set(seite.squad_liste.get_children()[0]) + root.update() + pruefe("drei Mitglieder, Führer mit Stern", len(seite.mitglieder.get_children()) == 3 + and str(seite.mitglieder.item(seite.mitglieder.get_children()[0])["values"][0]).startswith("★")) + pruefe("Nicht-Führer: Auflösen gesperrt, Verlassen möglich", + str(seite.knopf_aufloesen["state"]) == "disabled" and str(seite.knopf_verlassen["state"]) == "normal") + foto(root, "ui_4_squads.png") + seite.nb.select(0) + seite.liste.selection_set(str(next(c["id"] for c in seite.charaktere if c["callsign"] == "Rook"))) + root.update() + vorher = set(fenster_alle(root)) + seite.akte_ansehen() + warte(lambda: set(fenster_alle(root)) - vorher, lambda: schritt_fenster(vorher), name="Akte ansehen") + + +def fenster_alle(widget): + """Alle Toplevel-Fenster im Baum - das Aktenfenster haengt am Squad-Reiter, nicht an root.""" + for kind in widget.winfo_children(): + if isinstance(kind, tk.Toplevel): + yield kind + yield from fenster_alle(kind) + + +def schritt_fenster(vorher): + fenster = next(iter(set(fenster_alle(root)) - vorher)) + fenster.attributes("-topmost", True) + root.after(600, lambda: (foto(fenster, "ui_5_fremde_akte.png"), fenster.destroy(), schritt_akte())) + + +def schritt_akte(): + app.haupt_nb.select(1) + root.after(500, lambda: (foto(root, "ui_6_akte_status.png"), schritt_konto_loeschen())) + + +def schritt_konto_loeschen(): + app.haupt_nb.select(2) + seite.nb.select(0) + root.update() + seite.konto_loeschen_ausfuehren("dannypasswort1", bestaetigen=False) + warte(lambda: not konto.angemeldet() and seite.anmeldung.winfo_ismapped(), schritt_nach_loeschen, + name="Konto löschen") + + +def schritt_nach_loeschen(): + code, antwort = server.api("anmelden", login="danny", passwort="dannypasswort1") + pruefe("Konto auf dem Server gelöscht", antwort.get("fehler") == "anmeldung_falsch", antwort) + pruefe("lokale Akte bleibt erhalten", modell.laden(nordlicht["id"])["personalien"]["callsign"] == "Nordlicht") + pruefe("Abgleichstand der Akte entfernt", not (modell.ordner_von(nordlicht["id"]) / "server.json").exists()) + squad_nachher = server.api("squad_ansehen", token=kamerad, squad_id=squad["id"])[1]["squad"] + pruefe("Nordlicht aus dem Squad verschwunden", + [m["callsign"] for m in squad_nachher["mitglieder"]] == ["Rook", "Hawk"] + or sorted(m["callsign"] for m in squad_nachher["mitglieder"]) == ["Hawk", "Rook"], squad_nachher) + ende() + + +def ende(): + pruefe("keine Fehler in Tk-Rückrufen", not fehler, [str(f[1]) for f in fehler][:3]) + app.stop() + root.destroy() + + +root.after(1500, schritt_anmeldung) +root.mainloop() +log = server.daten / "fehler.log" +inhalt = log.read_text(encoding="utf-8") if log.exists() else "" +pruefe("fehler.log des Servers leer", not inhalt.strip(), inhalt[-500:]) +server.beenden() +print(f"\nERGEBNIS: {st.ergebnisse['ok']} bestanden, {st.ergebnisse['fehl']} fehlgeschlagen")