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 <noreply@anthropic.com>
This commit is contained in:
danny 2026-09-13 20:09:31 +02:00
parent 0c7aae5b93
commit 4d9e30bc90
12 changed files with 1590 additions and 146 deletions

View file

@ -1,6 +1,6 @@
# Projektübergabe: Squad Manager # 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 Seit 3.2 wird über einen Inno-Setup-Installer und einen eingebauten
Auto-Updater verteilt (Server: https://sva.tyrveil.com), siehe Abschnitt 4. 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_modell.py Akte: Datenmodell und Speicherung, ohne tkinter
akte_vorlagen.py Akte: Fraktionen, Dienstgrade, Verwendungen akte_vorlagen.py Akte: Fraktionen, Dienstgrade, Verwendungen
akte_karte.py Akte: PNG-Karte zum Teilen, Zwischenablage 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 update_helfer.py spielt Updates ein, bei Bedarf mit Adminrechten
server/ PHP-Server für Konten und Squads, siehe Abschnitt 4 server/ PHP-Server für Konten und Squads, siehe Abschnitt 4
start.pyw Startskript ohne Konsolenfenster start.pyw Startskript ohne Konsolenfenster
@ -150,8 +154,8 @@ gerade nicht gesendet werden darf, oder einen leeren String. Reihenfolge:
| `set_dark_titlebar()` | Fenstertitelleiste dunkel | | `set_dark_titlebar()` | Fenstertitelleiste dunkel |
| `arm_autosave()` | speichert Einstellungen 600 ms nach jeder Änderung | | `arm_autosave()` | speichert Einstellungen 600 ms nach jeder Änderung |
**Oberfläche:** Zwei Hauptreiter, *FUNK* (mit den Unterreitern „Mikrofon" **Oberfläche:** Drei Hauptreiter, *FUNK* (mit den Unterreitern „Mikrofon"
und „Tasten und Verhalten") und *AKTE*. Darunter für alle Module die 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 / Statusleiste mit den Knöpfen und der Zustandsanzeige (BEREITSCHAFT /
HORCHT / SENDET / GESPERRT) — die Sprachaktivierung läuft weiter, während HORCHT / SENDET / GESPERRT) — die Sprachaktivierung läuft weiter, während
man in einem anderen Modul arbeitet. Der zuletzt gewählte Hauptreiter 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 Bereiche der Küstenwache, die Bundeswehr Heer, Luftwaffe und Marine mit
eigenen Marine-Dienstgraden. 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-<Zeit>.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()` **Teilen:** Knopf „Teilen …" in der Leiste der Akte. `akte_karte.karte()`
zeichnet mit Pillow eine Karte 1200 × 675 (Discord zeigt das groß) — zeichnet mit Pillow eine Karte 1200 × 675 (Discord zeigt das groß) —
bewusst kein Bildschirmfoto, damit sie überall gleich aussieht. Inhalt: 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 `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. 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 ## 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` ob bei den Freunden die Nachinstallation von Pillow über `start.pyw`
geklappt hat (erstes Update mit neuem Paket). 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 **Installationen unter „Programme" (Erkenntnis 19).** Wer 3.x für alle
Benutzer installiert hat, kommt per Updater nicht weiter und muss 4.0 einmal Benutzer installiert hat, kommt per Updater nicht weiter und muss 4.0 einmal
mit dem Installer einspielen. Der entfernt die alte Installation dabei mit dem Installer einspielen. Der entfernt die alte Installation dabei

View file

@ -17,6 +17,11 @@ Technische Dokumentation und alle bekannten Fallstricke:
| `akte_modell.py` | Modul Akte: Datenmodell und Speicherung | | `akte_modell.py` | Modul Akte: Datenmodell und Speicherung |
| `akte_vorlagen.py` | Modul Akte: Fraktionen, Dienstgrade, Verwendungen | | `akte_vorlagen.py` | Modul Akte: Fraktionen, Dienstgrade, Verwendungen |
| `akte_karte.py` | Modul Akte: PNG-Karte zum Teilen | | `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 | | `update_helfer.py` | spielt Updates ein, bei Bedarf mit Adminrechten |
| `start.pyw` | Startskript ohne Konsolenfenster | | `start.pyw` | Startskript ohne Konsolenfenster |
| `make_icon.py` | erzeugt `icon.ico` aus `icon.png` | | `make_icon.py` | erzeugt `icon.ico` aus `icon.png` |

333
akte.py
View file

@ -12,6 +12,7 @@ from tkinter import ttk, filedialog, messagebox
from PIL import Image, ImageOps, ImageTk from PIL import Image, ImageOps, ImageTk
import abgleich
import akte_karte import akte_karte
import akte_modell as modell import akte_modell as modell
import akte_vorlagen as vorlagen import akte_vorlagen as vorlagen
@ -169,6 +170,8 @@ class AkteSeite(ttk.Frame):
self._laedt = False self._laedt = False
self._fotos = {} self._fotos = {}
self.modus = "ansicht" self.modus = "ansicht"
# Setzt der Squad-Reiter: Nach jeder Aenderung wird der Abgleich angestossen
self.bei_gespeichert = None
self._aufbau() self._aufbau()
self.bind_all("<MouseWheel>", self._mausrad, add="+") self.bind_all("<MouseWheel>", self._mausrad, add="+")
@ -197,6 +200,10 @@ class AkteSeite(ttk.Frame):
pady=(8, 0), padx=(0, 4)) pady=(8, 0), padx=(0, 4))
ttk.Button(links, text="Papierkorb", command=self.in_papierkorb).grid( ttk.Button(links, text="Papierkorb", command=self.in_papierkorb).grid(
row=2, column=1, sticky="ew", pady=(8, 0)) 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 = ttk.Frame(self)
rechts.grid(row=0, column=1, sticky="nsew", pady=(8, 0)) rechts.grid(row=0, column=1, sticky="nsew", pady=(8, 0))
@ -412,6 +419,7 @@ class AkteSeite(ttk.Frame):
return return
self.modus = "bearbeiten" self.modus = "bearbeiten"
self.akten_laden(akte["id"]) self.akten_laden(akte["id"])
self._gespeichert()
def in_papierkorb(self): def in_papierkorb(self):
if self.aktuell is None: if self.aktuell is None:
@ -424,9 +432,12 @@ class AkteSeite(ttk.Frame):
"_papierkorb verschoben und lässt sich von dort zurückholen."): "_papierkorb verschoben und lässt sich von dort zurückholen."):
return return
self.speichern_sofort() self.speichern_sofort()
# Vor dem Verschieben: server.json liegt im Aktenordner
abgleich.loeschen_vormerken(self.aktuell["id"])
modell.in_papierkorb(self.aktuell["id"]) modell.in_papierkorb(self.aktuell["id"])
self.aktuell = None self.aktuell = None
self.akten_laden() self.akten_laden()
self._gespeichert()
# -- Teilen -------------------------------------------------------------- # -- Teilen --------------------------------------------------------------
def teilen_menue(self): def teilen_menue(self):
@ -643,6 +654,7 @@ class AkteSeite(ttk.Frame):
messagebox.showerror("Porträt", str(fehler)) messagebox.showerror("Porträt", str(fehler))
return return
self._vorschau_aktualisieren() self._vorschau_aktualisieren()
self._gespeichert()
def portraet_entfernen(self): def portraet_entfernen(self):
if self.aktuell is None or modell.portraet_pfad(self.aktuell["id"]) is None: 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"]) modell.portraet_entfernen(self.aktuell["id"])
self._fotos = {k: v for k, v in self._fotos.items() if k[0] != self.aktuell["id"]} self._fotos = {k: v for k, v in self._fotos.items() if k[0] != self.aktuell["id"]}
self._vorschau_aktualisieren() self._vorschau_aktualisieren()
self._gespeichert()
# -- Speichern ----------------------------------------------------------- # -- Speichern -----------------------------------------------------------
def _speichern_planen(self): def _speichern_planen(self):
@ -669,6 +682,44 @@ class AkteSeite(ttk.Frame):
self._geaendert_flag = False self._geaendert_flag = False
except OSError as fehler: except OSError as fehler:
messagebox.showerror("Akte", f"Die Akte konnte nicht gespeichert werden:\n{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 ------------------------------------------------------------- # -- Mausrad -------------------------------------------------------------
def _mausrad(self, ereignis): def _mausrad(self, ereignis):
@ -697,153 +748,167 @@ class AkteSeite(ttk.Frame):
def ansicht_zeichnen(self): def ansicht_zeichnen(self):
self._zeichen_job = None self._zeichen_job = None
c = self.dok if self.aktuell is None:
c.delete("all") self.dok.delete("all")
a = self.aktuell
if a is None:
return return
breite = max(c.winfo_width(), 540) akte_id = self.aktuell["id"]
rand = 14 dokument_zeichnen(self.dok, self.aktuell, lambda groesse: self._foto(akte_id, groesse))
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 def dokument_zeichnen(c, a, foto_fuer):
pb, ph = 150, 190 """
px1, px0 = rechts, rechts - pb Zeichnet eine Akte als Dokument auf die Zeichenflaeche c.
py0, py1 = y, y + ph
c.create_rectangle(px0 - 5, py0 - 5, px1 + 5, py1 + 5, outline=LINE) foto_fuer((breite, hoehe)) liefert das Portraet als PhotoImage oder
foto = self._foto(a["id"], (pb, ph)) None. Genutzt von der eigenen Akte und im Squad-Reiter fuer fremde
if foto: Akten, deren Portraet vom Server kommt.
c.create_image((px0 + px1) // 2, (py0 + py1) // 2, image=foto) """
else: c.delete("all")
c.create_rectangle(px0, py0, px1, py1, fill=BG, outline="") 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", c.create_text((px0 + px1) // 2, (py0 + py1) // 2, text="KEIN\nPORTRÄT",
fill=FG_DIM, font=FONT_DOK_KLEIN, justify="center") fill=FG_DIM, font=FONT_DOK_KLEIN, justify="center")
# Kopfdaten links neben dem Portraet # Kopfdaten links neben dem Portraet
textbreite = px0 - links - 30 textbreite = px0 - links - 30
name = " ".join(t for t in (pers.get("vorname", ""), pers.get("nachname", "")) if t) name = " ".join(t for t in (pers.get("vorname", ""), pers.get("nachname", "")) if t)
callsign = pers.get("callsign", "") callsign = pers.get("callsign", "")
titel = callsign.upper() if callsign else (name or "OHNE NAMEN") titel = callsign.upper() if callsign else (name or "OHNE NAMEN")
oben = y oben = y
t = c.create_text(links, oben, anchor="nw", text=titel, fill=akzent, t = c.create_text(links, oben, anchor="nw", text=titel, fill=akzent,
font=FONT_CALLSIGN, width=textbreite) font=FONT_CALLSIGN, width=textbreite)
oben = c.bbox(t)[3] + 4 oben = c.bbox(t)[3] + 4
zweite = " ".join(x for x in (dienst.get("rang", ""), name if callsign else "") if x) zweite = " ".join(x for x in (dienst.get("rang", ""), name if callsign else "") if x)
if zweite: if zweite:
t = c.create_text(links, oben, anchor="nw", text=zweite, fill=schrift, t = c.create_text(links, oben, anchor="nw", text=zweite, fill=schrift,
font=FONT_NAME, width=textbreite) font=FONT_NAME, width=textbreite)
oben = c.bbox(t)[3] + 14 oben = c.bbox(t)[3] + 14
else: else:
oben += 10 oben += 10
for zeile in (" · ".join(x for x in (dienst.get("fraktion", ""), for zeile in (" · ".join(x for x in (dienst.get("fraktion", ""),
dienst.get("teilstreitkraft", "")) if x), dienst.get("teilstreitkraft", "")) if x),
dienst.get("verwendung", ""), dienst.get("verwendung", ""),
f"STATUS: {status.upper()}"): f"STATUS: {status.upper()}"):
if zeile: if zeile:
t = c.create_text(links, oben, anchor="nw", text=zeile, fill=schrift, t = c.create_text(links, oben, anchor="nw", text=zeile, fill=schrift,
font=FONT_DOK, width=textbreite) font=FONT_DOK, width=textbreite)
oben = c.bbox(t)[3] + 4 oben = c.bbox(t)[3] + 4
if status in ("gefallen", "vermisst"): if status in ("gefallen", "vermisst"):
self._stempel(c, (px0 + px1) / 2, (py0 + py1) / 2, status.upper(), _stempel(c, (px0 + px1) / 2, (py0 + py1) / 2, status.upper(),
RED if gefallen else AMBER) RED if gefallen else AMBER)
y = max(oben, py1) + 30 y = max(oben, py1) + 30
def abschnitt(titel, y): def abschnitt(titel, y):
c.create_text(links, y, anchor="nw", text=titel, fill=akzent, font=FONT_DOK_FETT) 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) c.create_line(links, y + 20, rechts, y + 20, fill=LINE)
return y + 30 return y + 30
def zeilen(paare, y): def zeilen(paare, y):
for beschriftung, inhalt in paare: for beschriftung, inhalt in paare:
c.create_text(links, y, anchor="nw", text=beschriftung.upper(), c.create_text(links, y, anchor="nw", text=beschriftung.upper(),
fill=FG_DIM, font=FONT_DOK_KLEIN) fill=FG_DIM, font=FONT_DOK_KLEIN)
t = c.create_text(links + 150, y, anchor="nw", text=inhalt or "—", 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 "—",
fill=schrift if inhalt else FG_DIM, font=FONT_DOK, fill=schrift if inhalt else FG_DIM, font=FONT_DOK,
width=rechts - links) width=rechts - links - 150)
return c.bbox(t)[3] + 18 y = c.bbox(t)[3] + 6
return y + 10
y = abschnitt("I. PERSONALIEN", y) def fliesstext(inhalt, y):
y = zeilen([(b, wert(a, p)) for p, b in PERSONALIEN], y) t = c.create_text(links, y, anchor="nw", text=inhalt or "—",
y = abschnitt("II. DIENST", y) fill=schrift if inhalt else FG_DIM, font=FONT_DOK,
einheit = " · ".join(wert(a, p) for p, _ in EINHEIT if wert(a, p)) width=rechts - links)
y = zeilen([(b, wert(a, p)) for p, b in DIENST] + [("Einheit", einheit)], y) return c.bbox(t)[3] + 18
y = abschnitt("III. BESCHREIBUNG", y)
y = fliesstext(a.get("beschreibung", ""), y)
y = abschnitt("IV. AUSZEICHNUNGEN", y) y = abschnitt("I. PERSONALIEN", y)
auszeichnungen = a.get("auszeichnungen", []) y = zeilen([(b, wert(a, p)) for p, b in PERSONALIEN], y)
if not auszeichnungen: y = abschnitt("II. DIENST", y)
y = fliesstext("", y) einheit = " · ".join(wert(a, p) for p, _ in EINHEIT if wert(a, p))
for e in auszeichnungen: y = zeilen([(b, wert(a, p)) for p, b in DIENST] + [("Einheit", einheit)], y)
kopf = e.get("bezeichnung", "") + (f" ({e['datum']})" if e.get("datum") else "") y = abschnitt("III. BESCHREIBUNG", y)
t = c.create_text(links, y, anchor="nw", text="■ " + kopf, fill=schrift, y = fliesstext(a.get("beschreibung", ""), y)
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("V. EINSÄTZE", y + 4) y = abschnitt("IV. AUSZEICHNUNGEN", y)
einsaetze = a.get("einsaetze", []) auszeichnungen = a.get("auszeichnungen", [])
if not einsaetze: if not auszeichnungen:
y = fliesstext("", y) y = fliesstext("", y)
for e in einsaetze: for e in auszeichnungen:
kopf = " · ".join(x for x in (e.get("datum", ""), e.get("ort", "")) if x) or "Einsatz" kopf = e.get("bezeichnung", "") + (f" ({e['datum']})" if e.get("datum") else "")
t = c.create_text(links, y, anchor="nw", text=kopf, fill=akzent, t = c.create_text(links, y, anchor="nw", text="■ " + kopf, fill=schrift,
font=FONT_DOK_FETT, width=rechts - links) font=FONT_DOK_FETT, width=rechts - links)
y = c.bbox(t)[3] + 2 y = c.bbox(t)[3] + 2
if e.get("bericht"): if e.get("anlass"):
t = c.create_text(links, y, anchor="nw", text=e["bericht"], fill=schrift, t = c.create_text(links + 18, y, anchor="nw", text=e["anlass"], fill=schrift,
font=FONT_DOK, width=rechts - links) font=FONT_DOK, width=rechts - links - 18)
y = c.bbox(t)[3] y = c.bbox(t)[3]
y += 14 y += 10
y = abschnitt("VI. VERMERKE", y + 4) y = abschnitt("V. EINSÄTZE", y + 4)
y = fliesstext(a.get("vermerke", ""), y) 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) y = abschnitt("VI. VERMERKE", y + 4)
c.tag_lower(karte) y = fliesstext(a.get("vermerke", ""), y)
c.configure(scrollregion=(0, 0, breite, y + rand + 10))
@staticmethod karte = c.create_rectangle(rand, rand, breite - rand, y + 6, fill=PANEL, outline=LINE)
def _stempel(c, mx, my, text, farbe, winkel=18): c.tag_lower(karte)
"""Schraeger Stempel ueber dem Portraet, mit gedrehtem Rahmen.""" c.configure(scrollregion=(0, 0, breite, y + rand + 10))
t = c.create_text(mx, my, text=text, fill=farbe, angle=winkel,
font=("Consolas", 18, "bold"))
breite = len(text) * 14 + 26
hoehe = 38 def _stempel(c, mx, my, text, farbe, winkel=18):
rad = math.radians(winkel) """Schraeger Stempel ueber dem Portraet, mit gedrehtem Rahmen."""
ecken = [] t = c.create_text(mx, my, text=text, fill=farbe, angle=winkel,
for dx, dy in ((-breite / 2, -hoehe / 2), (breite / 2, -hoehe / 2), font=("Consolas", 18, "bold"))
(breite / 2, hoehe / 2), (-breite / 2, hoehe / 2)): breite = len(text) * 14 + 26
ecken += [mx + dx * math.cos(rad) + dy * math.sin(rad), hoehe = 38
my - dx * math.sin(rad) + dy * math.cos(rad)] rad = math.radians(winkel)
c.create_polygon(*ecken, outline=farbe, fill="", width=3) ecken = []
c.tag_raise(t) 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)

View file

@ -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].

View file

@ -11,6 +11,10 @@ außer dieser Anleitung selbst:
index.html die Downloadseite index.html die Downloadseite
version.json als Letztes 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 Reihenfolge ist wichtig: version.json zuletzt. Solange sie noch auf
die alte Version zeigt, bekommt niemand einen Link auf eine Datei, die die alte Version zeigt, bekommt niemand einen Link auf eine Datei, die
noch gar nicht oben liegt. noch gar nicht oben liegt.

View file

@ -2,7 +2,7 @@
; Uebersetzen mit: ISCC.exe setup.iss ; Uebersetzen mit: ISCC.exe setup.iss
#define Name "Squad Manager" #define Name "Squad Manager"
#define Version "1.5.1" #define Version "1.6.0"
#define Herausgeber "tyrveil.com" #define Herausgeber "tyrveil.com"
#define Website "https://sva.tyrveil.com" #define Website "https://sva.tyrveil.com"

945
squad.py Normal file
View file

@ -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("<Button-1>", 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("<Return>", 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("<Return>", 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("<Configure>", zeichnen)
leinwand.bind("<MouseWheel>", lambda e: leinwand.yview_scroll(int(-e.delta / 120), "units"))
fenster.bind("<Escape>", 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("<Escape>", 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("<Return>", 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("<<ComboboxSelected>>", lambda e: self.aktualisieren())
fraktion.bind("<MouseWheel>", 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("<<TreeviewSelect>>", lambda e: self._charakter_gewaehlt())
self.liste.bind("<Double-1>", 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("<<TreeviewSelect>>", 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("<<TreeviewSelect>>", 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("<Escape>", 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)

View file

@ -57,15 +57,16 @@ from theme import ( # noqa: E402
apply_tactical_theme, LevelMeter, apply_tactical_theme, LevelMeter,
) )
import akte # noqa: E402 import akte # noqa: E402
import squad # noqa: E402
import update_helfer # noqa: E402 import update_helfer # noqa: E402
APP_NAME = "Squad Manager" APP_NAME = "Squad Manager"
VERSION = "1.5.1" VERSION = "1.6.0"
# Zaehlnummer fuer den Update-Vergleich, bei jedem Release um eins erhoehen. # Zaehlnummer fuer den Update-Vergleich, bei jedem Release um eins erhoehen.
# Seit 1.5.0 getrennt von der angezeigten Version: Die Anzeige sprang von # 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 # 4.0 auf 1.5.0 zurueck, ein Vergleich der Anzeige haette danach nie wieder
# ein Update gefunden. # ein Update gefunden.
BUILD = 2 BUILD = 3
# Letzte Version aus der Zeit vor den Zaehlnummern # Letzte Version aus der Zeit vor den Zaehlnummern
LETZTE_ALTE_VERSION = "4.0" LETZTE_ALTE_VERSION = "4.0"
CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "config.json" CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "config.json"
@ -779,7 +780,7 @@ class VoiceActivationApp:
ttk.Label(header, text="SQUAD MANAGER", ttk.Label(header, text="SQUAD MANAGER",
style="Title.TLabel").pack(anchor="w") style="Title.TLabel").pack(anchor="w")
ttk.Label(header, style="Sub.TLabel", 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( ttk.Separator(self.root, orient="horizontal").pack(
fill="x", padx=18, pady=(10, 0)) fill="x", padx=18, pady=(10, 0))
@ -797,8 +798,10 @@ class VoiceActivationApp:
haupt.pack(fill="both", expand=True, padx=16, pady=(4, 8)) haupt.pack(fill="both", expand=True, padx=16, pady=(4, 8))
seite_funk = ttk.Frame(haupt) seite_funk = ttk.Frame(haupt)
seite_akte = ttk.Frame(haupt) seite_akte = ttk.Frame(haupt)
seite_squad = ttk.Frame(haupt)
haupt.add(seite_funk, text="FUNK") haupt.add(seite_funk, text="FUNK")
haupt.add(seite_akte, text="AKTE") haupt.add(seite_akte, text="AKTE")
haupt.add(seite_squad, text="SQUAD")
nb = ttk.Notebook(seite_funk) nb = ttk.Notebook(seite_funk)
self.nb = nb self.nb = nb
@ -813,6 +816,10 @@ class VoiceActivationApp:
self.akte = akte.AkteSeite(seite_akte) self.akte = akte.AkteSeite(seite_akte)
self.akte.pack(fill="both", expand=True) 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("<<NotebookTabChanged>>", lambda e: self.squad.sichtbar()
if haupt.index("current") == 2 else None, add="+")
def _build_main_tab(self, parent): def _build_main_tab(self, parent):
f = ttk.Frame(parent) f = ttk.Frame(parent)

View file

@ -27,7 +27,7 @@ ORDNER = Path(__file__).resolve().parent
VENV_PYTHON = ORDNER / ".venv" / "Scripts" / "python.exe" VENV_PYTHON = ORDNER / ".venv" / "Scripts" / "python.exe"
ANFORDERUNGEN = ORDNER / "requirements.txt" ANFORDERUNGEN = ORDNER / "requirements.txt"
EIGENE_MODULE = {"squad_manager", "theme", "akte", "akte_modell", "akte_vorlagen", 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): for pfad in (ORDNER / ".venv" / "Lib" / "site-packages", ORDNER):
if pfad.is_dir(): if pfad.is_dir():

View file

@ -18,13 +18,15 @@ import urllib.parse
from pathlib import Path from pathlib import Path
WURZEL = Path(__file__).resolve().parent.parent 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)) sys.path.insert(0, str(Path(__file__).resolve().parent))
# -- Ein Rechner: wird als eigener Prozess mit "pc" aufgerufen ---------------- # -- Ein Rechner: wird als eigener Prozess mit "pc" aufgerufen ----------------
def rechner_befehl(aktion, parameter): def rechner_befehl(aktion, parameter):
sys.path.insert(0, str(WURZEL)) sys.path.insert(0, str(PROGRAMM))
import hashlib import hashlib
from PIL import Image from PIL import Image
@ -230,7 +232,7 @@ def ablauf(server, pruefe):
if __name__ == "__main__": if __name__ == "__main__":
if len(sys.argv) >= 2 and sys.argv[1] == "pc": if len(sys.argv) >= 2 and sys.argv[1] == "pc":
sys.path.insert(0, str(WURZEL)) sys.path.insert(0, str(PROGRAMM))
import konto import konto
try: try:
wert = rechner_befehl(sys.argv[2], json.loads(sys.argv[3])) wert = rechner_befehl(sys.argv[2], json.loads(sys.argv[3]))

View file

@ -34,7 +34,8 @@ BASIS_URL = "https://sva.tyrveil.com"
VERSION_FUER_ALTE_PROGRAMME = "4.1" VERSION_FUER_ALTE_PROGRAMME = "4.1"
PYTHON_DATEIEN = ("squad_manager.py", "theme.py", "akte.py", "akte_modell.py", 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") "make_icon.py")
MITKOPIEREN = ("requirements.txt", "icon.png", "icon.ico") 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')})") 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): def aufbereiten(pfad: Path):
"""Kommentare entfernen und echte Umlaute setzen.""" """Kommentare entfernen und echte Umlaute setzen."""
quelle = pfad.read_text(encoding="utf-8") quelle = pfad.read_text(encoding="utf-8")
@ -126,7 +138,7 @@ def aufbereiten(pfad: Path):
tokens = [] tokens = []
for tok in tokenize.generate_tokens(io.StringIO(text).readline): 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 neu = tok.string
for alt, ersatz in UMLAUTE: for alt, ersatz in UMLAUTE:
neu = neu.replace(alt, ersatz) neu = neu.replace(alt, ersatz)

View file

@ -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")