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:
parent
0c7aae5b93
commit
4d9e30bc90
12 changed files with 1590 additions and 146 deletions
|
|
@ -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-<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()`
|
||||
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
|
||||
|
|
|
|||
|
|
@ -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` |
|
||||
|
|
|
|||
333
akte.py
333
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("<MouseWheel>", 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)
|
||||
|
|
|
|||
75
installer/DATENSCHUTZ-BAUSTEIN.md
Normal file
75
installer/DATENSCHUTZ-BAUSTEIN.md
Normal 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].
|
||||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
|
||||
|
|
|
|||
945
squad.py
Normal file
945
squad.py
Normal 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)
|
||||
|
|
@ -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("<<NotebookTabChanged>>", lambda e: self.squad.sichtbar()
|
||||
if haupt.index("current") == 2 else None, add="+")
|
||||
|
||||
def _build_main_tab(self, parent):
|
||||
f = ttk.Frame(parent)
|
||||
|
|
|
|||
|
|
@ -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():
|
||||
|
|
|
|||
|
|
@ -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]))
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
264
werkzeuge/oberflaeche_test.py
Normal file
264
werkzeuge/oberflaeche_test.py
Normal 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")
|
||||
Loading…
Add table
Add a link
Reference in a new issue