diff --git a/.claude/launch.json b/.claude/launch.json
new file mode 100644
index 0000000..706e4b3
--- /dev/null
+++ b/.claude/launch.json
@@ -0,0 +1,12 @@
+{
+ "version": "0.0.1",
+ "configurations": [
+ {
+ "name": "downloadseite",
+ "runtimeExecutable": "C:\\Users\\danie\\Desktop\\squad-manager\\.venv\\Scripts\\python.exe",
+ "runtimeArgs": ["-m", "http.server", "8765", "--bind", "127.0.0.1",
+ "--directory", "C:\\Users\\danie\\Desktop\\squad-manager\\dist\\server"],
+ "port": 8765
+ }
+ ]
+}
diff --git a/.gitattributes b/.gitattributes
index 27c7e11..a8c8f12 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -11,3 +11,6 @@
*.png binary
*.ico binary
+
+# Server-Dateien laufen unter Linux
+*.php text eol=lf
diff --git a/.gitignore b/.gitignore
index b90922b..b9827d0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,7 @@ __pycache__/
# Editor
.idea/
.vscode/
+
+# Server: Zugangsdaten und Nutzerdaten nie ins Repository
+server/sva-privat/config.php
+server/sva-privat/daten/
diff --git a/PLAN-AKTE.md b/PLAN-AKTE.md
index c614229..cdd5674 100644
--- a/PLAN-AKTE.md
+++ b/PLAN-AKTE.md
@@ -1,6 +1,6 @@
# Plan: Modul „Akte"
-Stand: 10. September 2026 · Entwurf, noch nicht umgesetzt
+Stand: 11. September 2026 · Stufe 0 bis 3 umgesetzt · Stufe 2 online als 4.0, Stufe 3 folgt als 1.5.0 (neue Zählung, siehe Übergabe, Erkenntnis 20)
Eine Personalakte für den eigenen Squad-Charakter: Name, Callsign, Rang,
Porträt, Nation, Teilstreitkraft, Einheit, Werdegang. Reines Rollenspiel —
@@ -81,7 +81,10 @@ riskant.
```
squad_manager.py Hauptfenster, Navigation, Funk-Modul (wie bisher)
theme.py Farben, Schriften, apply_tactical_theme(), LevelMeter
-akte.py Datenmodell, Speicherung, Oberfläche der Akte
+akte.py Oberfläche der Akte
+akte_modell.py Datenmodell und Speicherung, ohne tkinter
+akte_vorlagen.py Fraktionen, Dienstgrade, Verwendungen
+akte_karte.py Akte als PNG-Karte zum Teilen
```
Flach bleibt es, weil Installer, Update-Paket und `start.pyw` heute flache
@@ -147,9 +150,9 @@ Eine Akte ist ein Ordner mit JSON-Datei und Porträt:
| Stufe | Inhalt | Umfang |
|---|---|---|
| **0** | Fehlende Pakete werden beim Start nachinstalliert — **erledigt in 3.3** | klein |
-| **1** | `theme.py` auslagern, Hauptreiter *Funk* / *Akte*, Akte noch leer — Version 3.4 | mittel |
-| **2** | Akte vollständig: Liste, Formular, Dokumentansicht, Porträt, Vorbelegungen — Version 4.0 | groß |
-| **3** | Teilen: Akte als PNG-Karte für Discord, Export/Import als `.akte`-Datei | mittel |
+| **1** | `theme.py` auslagern, Hauptreiter *Funk* / *Akte*, Akte noch leer — **erledigt in 3.4** | mittel |
+| **2** | Akte vollständig: Liste, Formular, Dokumentansicht, Porträt, Vorbelegungen — **umgesetzt**, online als 4.0 | groß |
+| **3** | Teilen: Akte als PNG-Karte für Discord — **umgesetzt**, kommt mit 1.5.0 (Export/Import als `.akte`-Datei entfällt, siehe Abschnitt 7) | mittel |
Jede Stufe endet mit einem Release über den Updater. Stufe 1 ist bewusst
ohne neue Funktion: Wenn dabei etwas bricht, liegt es am Umbau und nicht an
@@ -181,17 +184,19 @@ erweitern, falls du dafür wieder Claude Design einsetzen willst.
---
-## 7. Zu entscheiden
+## 7. Entscheidungen (10. September 2026)
-Mit meiner Empfehlung, damit Stufe 2 ohne Rückfragen durchlaufen kann:
-
-1. **Mehrere Akten pro Person?** — Ja.
-2. **Vorbelegungen für welche Nationen zuerst?** — Die Squad-Fraktionen.
- Wenn eure Gruppe eine bestimmte Armee spielt, etwa die Bundeswehr, die
- zusätzlich.
-3. **Teilen mit Freunden wichtig?** — Stufe 3 als PNG-Karte ist der
- einfachste Weg mit dem meisten Effekt, weil sie direkt in Discord landet.
-4. **Online-Akten?** — Erst einmal nicht, siehe oben.
+1. **Mehrere Akten pro Person** — ja.
+2. **Vorbelegungen für Fraktion und Rang:** alle Squad-Fraktionen, dazu
+ Bundeswehr, Frankreich, Spanien, Italien und Island. Freitext bleibt
+ überall möglich.
+ *Island hat keine Armee*, nur Küstenwache (Landhelgisgæslan) und die
+ Krisenreaktionseinheit. Vorbelegt werden die Dienstgrade der
+ Küstenwache, sofern die Gruppe kein fiktives Island spielt.
+3. **Teilen:** PNG-Karte für Discord (Stufe 3). Keine Import-Datei.
+4. **Gestaltung:** im bestehenden Stil, ohne vorherigen Entwurf in Claude
+ Design.
+5. **Online-Akten:** vorerst nicht.
---
diff --git a/PROJEKT-UEBERGABE.md b/PROJEKT-UEBERGABE.md
index a7593c5..6f76ddc 100644
--- a/PROJEKT-UEBERGABE.md
+++ b/PROJEKT-UEBERGABE.md
@@ -1,6 +1,6 @@
# Projektübergabe: Squad Manager
-Stand: 10. September 2026 · Version 3.2 · Git-Repository im Quellordner
+Stand: 15. September 2026 · Version 1.7.0 (Build 5) · 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.
@@ -38,13 +38,24 @@ und aller Dokumente ist Deutsch.
Es gibt drei getrennte Orte. Das zu verwechseln war bereits mehrfach die
Fehlerquelle.
-### `C:\Users\danie\Downloads\squad-manager\` — Quelle
+### `C:\Users\danie\Desktop\squad-manager\` — Quelle
Arbeitsverzeichnis. Hier wird entwickelt. Der Code enthält hier
**Kommentare**, und Texte stehen teils in Ersatzschreibung („Haelt").
```
-squad_manager.py Hauptprogramm, rund 1600 Zeilen, eine Datei
+squad_manager.py Hauptfenster, Funk-Modul, Updater (~1500 Zeilen)
+theme.py Farben, Schriften, ttk-Stil, Pegelanzeige
+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
make_icon.py erzeugt icon.ico aus icon.png
icon.png / icon.ico Programmsymbol (vom Nutzer geliefert)
@@ -90,6 +101,10 @@ Dazu `Downloads\SquadVoiceActivation-3.1.zip` als Versandfassung.
### `%LOCALAPPDATA%\Programs\SquadManager\` — Installation
Standardziel des Installers, frei wählbar. Enthält zusätzlich `.venv\`.
+Seit 4.0 installiert der Installer immer nur für den aktuellen Benutzer;
+die Wahl „für alle Benutzer" ist entfernt (Erkenntnis 19). Findet er eine
+alte Installation für alle Benutzer, entfernt er sie vorher mit
+Adminrechten.
Konfiguration und Fehlerlog liegen getrennt davon in
`%APPDATA%\SquadManager\`. Beim ersten Start werden Einstellungen aus
`%APPDATA%\SquadVoiceActivation\` übernommen — kopiert, nicht verschoben
@@ -101,8 +116,16 @@ frisch.
## 3. Aufbau des Programms
-Eine einzelne Datei, `tkinter`/`ttk`, keine Klassenhierarchie außer der
-Hauptklasse `VoiceActivationApp`.
+`tkinter`/`ttk`, fünf flache Dateien: `squad_manager.py` mit Hauptfenster,
+Funk-Modul und Updater (Hauptklasse `VoiceActivationApp`), `theme.py` mit
+dem Stil, und das Modul Akte in drei Teilen — `akte.py` (Oberfläche),
+`akte_modell.py` (Datenmodell und Speicherung, bewusst ohne tkinter und
+damit ohne Fenster testbar), `akte_vorlagen.py` (Vorschlagslisten) und
+`akte_karte.py` (Karte zum Teilen). `theme.py` gibt es, damit
+`akte.py` die Farben nicht aus `squad_manager.py` holen muss — das wäre
+ein zirkulärer Import, weil `squad_manager.py` die Akte einbindet.
+Weitere Module gehören ebenfalls flach daneben: Installer, Update-Paket
+und `start.pyw` erwarten flache Dateien.
**Ablauf:** `sounddevice.InputStream` liefert Audioblöcke an einen
Callback, der den RMS-Pegel berechnet und in eine Queue legt. Ein
@@ -126,14 +149,93 @@ gerade nicht gesendet werden darf, oder einen leeren String. Reihenfolge:
| `enumerate_inputs()` | Geräteliste, siehe Erkenntnis 5 |
| `squad_focused()` | Prozessname des Vordergrundfensters prüfen |
| `send_binding()` | Taste plus Zusatztaste drücken/lösen |
-| `apply_tactical_theme()` | dunkles Farbschema |
-| `LevelMeter` | segmentierte Pegelanzeige mit Schwellenmarke |
+| `apply_tactical_theme()` | dunkles Farbschema (`theme.py`) |
+| `LevelMeter` | segmentierte Pegelanzeige mit Schwellenmarke (`theme.py`) |
| `set_dark_titlebar()` | Fenstertitelleiste dunkel |
| `arm_autosave()` | speichert Einstellungen 600 ms nach jeder Änderung |
-**Oberfläche:** Zwei Reiter („Mikrofon", „Tasten und Verhalten") plus eine
+**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).
+HORCHT / SENDET / GESPERRT) — die Sprachaktivierung läuft weiter, während
+man in einem anderen Modul arbeitet. Der zuletzt gewählte Hauptreiter
+steht als `modul` in der `config.json`.
+
+**Akte:** Ablage je Akte unter `%APPDATA%\SquadManager\akten\\` als
+`akte.json`, dazu `portraet.png` (auf höchstens 512 px verkleinerte
+Kopie). Geschrieben wird atomar über eine `.tmp`-Datei, die vorige Fassung
+bleibt als `.bak`; ist `akte.json` beim Lesen defekt, wird die Sicherung
+genommen. Löschen heißt Verschieben nach `akten\_papierkorb\`.
+Aktennummern `SM--`, der Papierkorb zählt mit, damit keine Nummer
+doppelt vergeben wird. Das Feld `schema` erlaubt spätere Formatänderungen;
+`migrieren()` ergänzt fehlende Felder und lässt unbekannte stehen. Offene
+Änderungen werden 800 ms nach der letzten Eingabe gespeichert, außerdem beim
+Schließen und vor einem Update.
+
+**Auswahllisten (seit 1.5.1):** `akte_vorlagen.FRAKTIONEN` ist
+verschachtelt: Fraktion → `teilstreitkraefte` → Dienstgrade je
+Teilstreitkraft; die erste Teilstreitkraft ist die Vorbelegung. Fraktion,
+Teilstreitkraft, Dienstgrad und Verwendung sind reine Auswahllisten
+(Combobox `readonly`). `_auswahl_anpassen()` ersetzt nach einem Wechsel,
+was nicht mehr passt; beim Laden ändert es nichts. Alte Akten aus der
+Freitext-Zeit meldet `vorlagen.pruefen()` als gelben Hinweis unter dem
+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):** Solange ein PC nicht
+mitmacht, zeigt *SQUAD* den Einstieg; alles andere läuft ohne wie vorher.
+Seit 1.7.0 braucht Mitmachen **kein Konto**: Spielername eingeben, der
+Server legt einen Nutzer ohne E-Mail an (`aktion mitmachen`), das
+Sitzungstoken ist der Schlüssel des PCs und läuft nicht ab. Solange das
+Konto nicht gesichert ist, zeigt der Reiter einen gelben Hinweis, und das
+Konto-Menü bietet „Konto sichern" statt „Abmelden" – Abmelden würde den
+Schlüssel löschen und die Charaktere verwaisen lassen. „Konto sichern"
+hängt E-Mail und Passwort an (`konto_sichern`, mit Bestätigungsmail);
+danach geht die Anmeldung auch auf anderen PCs. Verwaiste Charaktere
+bleiben stehen, bis der Admin sie löscht (Wunsch des Nutzers). Die
+Datenbank bekam dafür Stand 2 (`sm_nutzer.email` darf NULL sein);
+`DB::migrieren()` spielt das bei der ersten Anfrage ein und merkt sich den
+Stand als `daten/schema-2.ok`.
+Angemeldet: Unterreiter *Charaktere* (alle Spieler, Zustand KIA/MIA/WIA,
+Suche, Fraktionsfilter, fremde Akte als Dokument), *Squads* (gründen,
+Mitglieder, Führung übergeben, verlassen, auflösen) und *Einladungen*.
+Konto → Abmelden oder Konto löschen. Alle Serveraufrufe über
+`hintergrund.Hintergrund`, nie im Tk-Hauptthread.
+
+Die lokalen Akten bleiben Arbeitskopie. `squad.AbgleichSteuerung` stößt
+`abgleich.abgleichen()` an: nach dem Anmelden, 4 s nach jeder Änderung
+(`AkteSeite.bei_gespeichert`) und alle 5 min. Neben jeder Akte liegt
+`server.json` mit Server-ID, Version, Prüfwert des Inhalts und
+Porträt-Kennung des letzten Abgleichs. Nur lokal geändert → hochladen, nur
+Server → herunterladen, beides → Konflikt: Serverfassung als
+`konflikt-.json` neben die Akte, lokale Fassung gewinnt. Auf dem
+Server gelöschte Akten wandern lokal in den Papierkorb. Der Papierkorb im
+Programm merkt Akten in `akten/_abgleich_loeschen.json` zum Löschen auf dem
+Server vor. Die Aktennummer vergibt der Server; der Abgleich schreibt sie
+lokal zurück (`modell.speichern(zeit_setzen=False)`). Danach lädt
+`AkteSeite.nach_abgleich()` geänderte Akten neu, die offene nur, wenn sie
+selbst betroffen ist.
+
+Tests: `werkzeuge/abgleich_test.py` (zwei Rechner als eigene Prozesse mit
+eigenem `%APPDATA%`, 34 Fälle) und `werkzeuge/oberflaeche_test.py`
+(Programm gegen den Testserver, Anmeldung, Einladung annehmen, fremde
+Akte, Konto löschen, mit Bildschirmfotos). Beide nutzen den Testserver aus
+`server_test.py`; `konto.py` liest die Serveradresse aus `SM_SERVER`
+(nur `http://127.0.0.1` ist neben HTTPS erlaubt).
+
+**Teilen:** Knopf „Teilen …" in der Leiste der Akte. `akte_karte.karte()`
+zeichnet mit Pillow eine Karte 1200 × 675 (Discord zeigt das groß) —
+bewusst kein Bildschirmfoto, damit sie überall gleich aussieht. Inhalt:
+Porträt (bei *gefallen* grau), Callsign in der größten passenden Schrift,
+Dienstzeilen bis der Platz endet, unten Auszeichnungen als ganze Einträge
+mit „+ n weitere", sonst eine Zeile Beschreibung; Fußzeile wirbt mit
+`sva.tyrveil.com`. „Kopieren" legt die Karte zweimal in die
+Zwischenablage, als `CF_DIB` und als registriertes Format `PNG` — Discord
+nimmt dann das verlustfreie PNG. Schriften kommen aus `C:\Windows\Fonts`
+(Segoe UI, Consolas), mit Pillows Standardschrift als Ausweg. Prüfen:
+Karten für Grenzfälle erzeugen und ansehen — volle Akte, leere, gefallen,
+überlange Namen ohne Porträt; der Test überschreibt die Zwischenablage.
---
@@ -145,7 +247,8 @@ Ein Befehl erzeugt alles:
.venv\Scripts\python.exe werkzeuge\baue_release.py
```
-Die Version kommt aus `VERSION` in `squad_manager.py`. Ergebnis in
+Die angezeigte Version kommt aus `VERSION`, die Zählnummer für den
+Update-Vergleich aus `BUILD` in `squad_manager.py` (Erkenntnis 20). Ergebnis in
`dist/` (nicht im Repository): aufbereitete Programmdateien, das
Update-Paket `SquadManager-.zip`, der Installer
`SquadManager-Setup-.exe` und `dist/server/` mit genau den
@@ -163,19 +266,50 @@ nicht angelegt.
**Updater:** `pruefe_update()` holt beim Start
`https://sva.tyrveil.com/version.json`. Neuere Version → Hinweisbalken
unten. `lade_update()` prüft SHA-256, `spiele_update_ein()` entpackt und
-startet einen Hilfsprozess, der nach Programmende die Dateien ersetzt und
-neu startet. Nur `https://` wird akzeptiert. Getestet: manipulierte Datei
-wird abgelehnt, Dateiersatz funktioniert, `3.9 < 3.10` korrekt.
+startet `update_helfer.py` als eigenen Prozess. Nur `https://` wird
+akzeptiert. Getestet: manipulierte Datei wird abgelehnt, Dateiersatz
+funktioniert, `3.9 < 3.10` korrekt.
+
+**Update-Helfer (seit 4.0):** `update_helfer.py`, nur Standardbibliothek.
+Wartet auf das Ende des Programms (per Prozess-ID, keine geratene
+Wartezeit), prüft per Schreibprobe, ob der Programmordner beschreibbar ist,
+und kopiert. Ist er es nicht, startet er sich ein zweites Mal mit
+Adminrechten (`ShellExecuteEx` mit `runas`), aber **nur zum Kopieren** —
+das Programm startet danach wieder mit normalen Rechten. Scheitert es,
+erscheint eine Meldung mit Link zum Installer (`installer` in
+`version.json`), der Fehler steht im Log, und das Programm startet in der
+alten Fassung. Das Programm prüft den Ordner schon vor dem Download und
+kündigt die Windows-Abfrage an. Genommen wird der Helfer **aus dem neuen
+Paket**, sonst der mitgelieferte; seine Aufrufparameter
+` []` sind damit eine Schnittstelle
+und müssen gleich bleiben. Bis 3.4 war der Helfer eine Batchdatei, deren
+`xcopy`-Fehler in `>nul` verschwanden. Test: Die Prüfskripte legen alles in
+einem Testordner an; den Adminweg dort mit `verb="open"` statt `runas`
+prüfen, sonst wartet ein UAC-Fenster auf einen Klick.
**Nachinstallation:** `start.pyw` installiert fehlende Pakete aus
`requirements.txt` beim Start nach, mit Hinweisfenster. Das liegt bewusst
-dort und nicht im Update-Helfer: Der Helfer stammt aus der *alten*
+dort und nicht im Update-Helfer: Bis 3.4 stammt der Helfer aus der *alten*
Fassung, `start.pyw` aus der neuen. So bekommt auch ein 3.2-Client, dessen
Helfer nichts von neuen Paketen weiß, später etwa Pillow für die Akte.
-`installer/HOCHLADEN.txt` ist die Server-Anleitung für den Nutzer und wird
-beim Bau nach `dist/server/` kopiert. `dist/server/` wird bei jedem Bau
-gelöscht — nichts von Hand dort ablegen.
+`installer/HOCHLADEN.txt` ist die Server-Anleitung für den Nutzer; der Bau
+setzt die Version ein und legt sie nach `dist/server/`. `dist/server/` wird
+bei jedem Bau gelöscht — nichts von Hand dort ablegen.
+
+**Downloadseite:** Der Bau erzeugt aus `installer/downloadseite.html` die
+Seite `index.html` samt `icon.png` für das Wurzelverzeichnis. Die Seite
+liest beim Aufruf `version.json` und baut den Download-Knopf daraus
+(Feld `installer`, sonst aus `datei` abgeleitet); die beim Bau eingesetzte
+Version, Größe und das Datum sind nur Rückfallebene. Der Link für Freunde
+ist damit dauerhaft `https://sva.tyrveil.com`, auch wenn beim Hochladen
+nur `version.json` und die neuen Dateien erneuert werden. Mit Vorschau
+für Discord (`og:`-Angaben) und Hinweis auf dem Handy, dass der Installer
+nur unter Windows läuft. Lokal ansehen: `.claude/launch.json`,
+Konfiguration „downloadseite" (Port 8765, liefert `dist/server/` aus).
+Den Zweig „Server hat neuere Version" prüft man, indem man im Browser
+`fetch` durch eine Attrappe ersetzt und das Seitenskript erneut ausführt —
+lokal steht in `version.json` ja dieselbe Version wie in der Seite.
**Einzelschritte**, falls nötig: `werkzeuge/strip.py` entfernt
Kommentare, `werkzeuge/umlaute.py` setzt echte Umlaute. Danach
@@ -193,6 +327,56 @@ auf.
---
+### Server für Konten und Squads (ab 1.6.0)
+
+PHP 8 ohne Framework in `server/`, getrennt nach Sichtbarkeit:
+
+```
+server/sva.tyrveil.com/ → /sva.tyrveil.com (Dokumentenstamm, öffentlich)
+ api/index.php Schnittstelle fürs Programm (POST, JSON)
+ api/bild.php Porträts, nur mit Token
+ konto/ Links aus Mails: bestätigen, Passwort, vergessen
+ verwaltung/ Admin-Oberfläche
+ einrichten.php Ersteinrichtung, nur mit Schlüssel aus config.php
+server/sva-privat/ → /sva-privat, NEBEN dem Dokumentenstamm
+ app/ gesamte Logik
+ config.beispiel.php Vorlage; config.php liegt nur auf dem Server
+ daten/ Porträts, Fehlerlog (nicht im Repository)
+```
+
+Plesk: PHP 8.5, Dokumentenstamm `/sva.tyrveil.com`, Datenbank und Benutzer
+`214729_sva` (MySQL/MariaDB). Das Datenbank-Passwort steht nur in
+`sva-privat/config.php` auf dem Server — nie ins Repository, nie in den
+Chat. Mails verschickt `mail()` über den Plesk-Mailserver mit Absender
+`info@tyrveil.com`, ohne Postfach-Passwort. Verwaltungszugang:
+`info@tyrveil.com`, Passwort über den Link aus `einrichten.php`.
+
+**Schnittstelle:** `POST /api/` mit `{"aktion": …}`, Token im Kopf
+`X-SM-Token` (nicht `Authorization`, das verschlucken Plesk-Setups gern).
+Antwort `{"ok": true, …}` oder `{"ok": false, "fehler": code, "meldung":
+Text}`. Die Aktionen stehen gesammelt in `app/api.php`.
+
+**Regeln, die der Server durchsetzt:** Aktennummern vergibt der Server
+(`SM--`), weil lokale Nummern bei allen Spielern mit 0001
+beginnen. Speichern mit `basis_version`: Weicht sie ab, kommt `konflikt`
+(409) mit dem Serverstand zurück. Ein Charakter ist in höchstens einem
+Squad; Einladungen muss der Besitzer annehmen; nimmt er an, verfallen seine
+anderen offenen Einladungen. Der Führer kann nur gehen, wenn er allein ist
+oder die Führung übergeben hat; wird er gelöscht, übernimmt das
+dienstälteste Mitglied. Porträts werden mit GD neu als PNG (≤ 512 px)
+gespeichert, das Original verworfen. Token liegen nur als SHA-256 in der
+Datenbank. Bremsen: Anmelden 10 je 15 min pro IP und Name, Registrieren 5
+je Stunde pro IP, Verwaltung 8 je 15 min.
+
+**Testen:** `werkzeuge/server_test.py` kopiert `server/` in einen
+Testordner, nutzt SQLite und Mails als Dateien und spielt über 90 Fälle
+durch — Einrichtung, Konten, Akten, Porträts, Squads, Verwaltung, Sperren,
+Bremsen. Braucht `php` im Suchpfad (auf dem Entwicklungsrechner PHP 8.4 aus
+winget). MySQL selbst ist lokal nicht testbar; `DB::sperre()` und
+`DB::schemaAnlegen()` enthalten die Unterschiede.
+
+---
+
## 5. Hart erkaufte Erkenntnisse
Diese Punkte wurden durch Fehlschläge gefunden. Wer sie „aufräumt", baut
@@ -299,6 +483,65 @@ Für Tests eine Kopie von `setup.iss` mit eigener `AppId` übersetzen
Auch stille Deinstallationen können Dialoge öffnen, wenn `[Code]` ein
normales `MsgBox` verwendet — dort immer `SuppressibleMsgBox`.
+**17 — Neue Module an zwei Stellen eintragen.**
+In `werkzeuge/baue_release.py` unter `PYTHON_DATEIEN`, sonst fehlen sie im
+Paket, und in `start.pyw` unter `EIGENE_MODULE`. Fehlt der zweite Eintrag,
+hält `start.pyw` einen Importfehler in einem eigenen Modul für ein
+fehlendes Paket und versucht es per pip nachzuinstallieren.
+
+**18 — ttk-Stile erben die Zustandsregeln des Themas.**
+Ein eigener Stil wie `Haupt.TNotebook.Tab` übernimmt die `map`-Regeln von
+`TNotebook.Tab`, bei *clam* auch einen eigenen Innenabstand für den
+gewählten Reiter. Die Schrift sprang dadurch beim Umschalten um 4 Pixel.
+Jede Zustandsregel, die man nicht will, im eigenen Stil ausdrücklich
+überschreiben — und die Wirkung nachmessen, nicht nur ansehen.
+
+**19 — Unter „Programme" scheitert der Updater still.**
+Mit der Installer-Wahl „für alle Benutzer" landete das Programm unter
+`C:\Program Files`. Es läuft ohne Adminrechte, `xcopy` bekam „Zugriff
+verweigert", die Meldung ging in `>nul` unter, und der Helfer startete
+danach die unveränderte alte Fassung. Ein Kollege des Nutzers sah so nach
+„Jetzt aktualisieren" wieder 3.2. Nachgestellt und bestätigt. Behoben in
+4.0 an drei Stellen: Installer nur noch pro Benutzer, Helfer holt sich bei
+Bedarf Adminrechte fürs Kopieren, jeder Fehler wird gemeldet. Gilt nur für
+Updates **ab** 4.0 — beim Update läuft immer der Helfer der alten Fassung.
+
+**20 — Die angezeigte Version darf sinken, die Zählnummer nie.**
+Nach 4.0 wollte der Nutzer zurück auf 1.x. Programme vergleichen aber die
+Nummer vom Server mit ihrer eigenen; „1.5.0" wäre für 4.0 älter, das
+Update käme nie an. Lösung seit 1.5.0: `VERSION` ist nur Anzeige, `BUILD`
+eine Zählnummer ab 1, die jedes Release um eins erhöht. `version.json`
+trägt `"anzeige"`, `"build"` und dauerhaft `"version": "4.1"` — Letzteres
+ausschließlich für Programme bis 4.0, die nur dieses Feld kennen
+(`VERSION_FUER_ALTE_PROGRAMME` im Bauskript, **nie senken**). Neue
+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
@@ -327,8 +570,31 @@ dem alten Namen `SquadVoiceActivation-3.2.*`. Der Nutzer hat seine
3.2-Installation gelöscht und installiert 3.3 frisch; der Weg 3.2 → 3.3
(alter Updater, Umbenennung) ist deshalb nie gegen den Server gelaufen.
Nach dem Upload von 3.3 die alten Dateien vom Server nehmen, damit niemand
-mehr mit 3.2 anfängt. Den ersten echten Updater-Durchlauf liefert dann
-3.3 → 3.4.
+mehr mit 3.2 anfängt. Den ersten echten Updater-Durchlauf lieferte dann
+3.3 → 4.0.
+
+**Stand auf dem Server (11. September):** 4.0 ist online, und zwar der
+Bau mit neuem Updater, aber ohne Karte (Prüfsumme `79a10486…`). 3.4 kam
+nie auf den Server, `dist/server-3.4/` ist hinfällig. Das nächste Release
+ist 1.5.0 (Build 1) mit der Karte, siehe Erkenntnis 20. Noch online und
+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
+selbst. Dieser Weg ist **ungetestet**: Er braucht eine echte Installation
+für alle Benutzer und eine Bestätigung im UAC-Fenster. Beim nächsten
+Betroffenen, etwa dem Kollegen des Nutzers, auf die Rückmeldung achten.
**Vorfall 10. September:** Ein Installer-Test mit der *echten* App-ID
hatte den Eintrag der Nutzerinstallation unter *Apps und Features*
diff --git a/README.md b/README.md
index 42f1056..1421018 100644
--- a/README.md
+++ b/README.md
@@ -11,11 +11,22 @@ Technische Dokumentation und alle bekannten Fallstricke:
| Pfad | Zweck |
|---|---|
-| `squad_manager.py` | Hauptprogramm |
+| `squad_manager.py` | Hauptfenster, Funk-Modul, Updater |
+| `theme.py` | Farben, Schriften, Stil, Pegelanzeige |
+| `akte.py` | Modul Akte: Oberfläche |
+| `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` |
| `icon.png`, `icon.ico` | Programmsymbol |
-| `requirements.txt` | numpy, sounddevice |
+| `requirements.txt` | numpy, sounddevice, Pillow |
| `installer/` | Inno-Setup-Skript, Einrichtung nach der Installation, Server-Anleitung |
| `werkzeuge/` | Release-Bau und Testhilfen |
| `Design-Briefing.md` | Auftrag für die Gestaltung |
diff --git a/abgleich.py b/abgleich.py
new file mode 100644
index 0000000..cb228f9
--- /dev/null
+++ b/abgleich.py
@@ -0,0 +1,285 @@
+"""
+Abgleich der lokalen Akten mit dem Server.
+
+Die lokalen Akten bleiben Arbeitskopie und Zwischenspeicher: Das Programm
+startet und speichert auch ohne Internet. Wer angemeldet ist, bekommt sie
+auf den Server gespiegelt - und auf einem zweiten Rechner wieder herunter.
+
+Neben jeder Akte liegt server.json mit dem Stand des letzten Abgleichs:
+Server-ID, Version, Pruefwert des Inhalts und Kennung des Portraets. Ein
+Pruefwert statt der Aenderungszeit: Die ist nur sekundengenau, eine
+Aenderung in derselben Sekunde wie der Abgleich ginge sonst verloren.
+Daran laesst sich ablesen, wo sich seitdem etwas geaendert hat:
+
+ nur lokal -> hochladen
+ nur Server -> herunterladen
+ beides -> Konflikt: die Serverfassung wird als
+ konflikt-.json neben die Akte gelegt, dann gilt
+ die lokale Fassung
+ auf dem Server geloescht (etwa von der Verwaltung)
+ -> lokal in den Papierkorb, nicht endgueltig weg
+
+Ohne tkinter; laeuft im Hintergrund-Thread. Aendert der Abgleich lokale
+Dateien, meldet er die betroffenen Akten zurueck - die Oberflaeche laedt
+sie dann neu.
+"""
+
+import base64
+import datetime
+import hashlib
+import json
+import os
+import threading
+
+import akte_modell as modell
+import konto
+
+META = "server.json"
+LOESCHLISTE = "_abgleich_loeschen.json"
+INHALT = ("personalien", "dienst", "beschreibung", "auszeichnungen", "einsaetze", "vermerke")
+
+# Nie zwei Abgleiche gleichzeitig - etwa Zeitgeber und Knopf
+_laeuft = threading.Lock()
+
+
+def _schreiben(pfad, daten):
+ pfad.parent.mkdir(parents=True, exist_ok=True)
+ zwischen = pfad.with_name(pfad.name + ".tmp")
+ zwischen.write_text(json.dumps(daten, ensure_ascii=False, indent=2), encoding="utf-8")
+ os.replace(zwischen, pfad)
+
+
+def meta_laden(akte_id, nutzer_id=None):
+ """Stand des letzten Abgleichs; None, wenn nie oder fuer ein anderes Konto abgeglichen."""
+ try:
+ meta = json.loads((modell.ordner_von(akte_id) / META).read_text(encoding="utf-8"))
+ except (OSError, ValueError, modell.AktenFehler):
+ return None
+ if not isinstance(meta, dict) or (nutzer_id is not None and meta.get("nutzer_id") != nutzer_id):
+ return None
+ return meta
+
+
+def _meta_speichern(akte_id, meta):
+ _schreiben(modell.ordner_von(akte_id) / META, meta)
+
+
+def _portraet_hash(akte_id):
+ pfad = modell.portraet_pfad(akte_id)
+ return hashlib.sha256(pfad.read_bytes()).hexdigest() if pfad else ""
+
+
+def _loeschliste_pfad():
+ return modell.AKTEN_ORDNER / LOESCHLISTE
+
+
+def _loeschliste():
+ try:
+ daten = json.loads(_loeschliste_pfad().read_text(encoding="utf-8"))
+ return [e for e in daten if isinstance(e, dict) and "lokale_id" in e]
+ except (OSError, ValueError):
+ return []
+
+
+def loeschen_vormerken(akte_id):
+ """
+ Vor dem Verschieben in den Papierkorb aufrufen: War die Akte schon auf
+ dem Server, wird sie dort beim naechsten Abgleich geloescht.
+ """
+ meta = meta_laden(akte_id)
+ if not meta:
+ return
+ liste = [e for e in _loeschliste() if e["lokale_id"] != akte_id]
+ liste.append({"lokale_id": akte_id, "nutzer_id": meta.get("nutzer_id")})
+ _schreiben(_loeschliste_pfad(), liste)
+
+
+def ausstehend():
+ """Grob: gibt es lokale Aenderungen, die noch nicht auf dem Server sind?"""
+ stand = konto.sitzung()
+ if not stand:
+ return False
+ nutzer_id = stand["nutzer"].get("id")
+ if any(e.get("nutzer_id") == nutzer_id for e in _loeschliste()):
+ return True
+ for akte in modell.alle_akten():
+ meta = meta_laden(akte["id"], nutzer_id)
+ if meta is None or meta.get("inhalt") != inhalt_hash(akte) \
+ or meta.get("portraet_hash", "") != _portraet_hash(akte["id"]):
+ return True
+ return False
+
+
+def inhalt_hash(akte):
+ """Pruefwert ueber die Felder, die der Nutzer bearbeitet."""
+ inhalt = {feld: (akte or {}).get(feld) for feld in INHALT}
+ text = json.dumps(inhalt, ensure_ascii=False, sort_keys=True)
+ return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def _gleicher_inhalt(akte, daten):
+ return inhalt_hash(akte) == inhalt_hash(daten)
+
+
+class _Lauf:
+ def __init__(self, nutzer_id):
+ self.nutzer_id = nutzer_id
+ self.ergebnis = {"hochgeladen": 0, "heruntergeladen": 0, "entfernt": 0,
+ "konflikte": 0, "geaendert": set()}
+
+ # -- Akten --------------------------------------------------------------
+
+ def hochladen(self, akte, basis_version, erzwingen=False):
+ try:
+ charakter = konto.aufrufen("charakter_speichern", lokale_id=akte["id"], daten=akte,
+ basis_version=basis_version, erzwingen=erzwingen)["charakter"]
+ except konto.ServerFehler as fehler:
+ if fehler.code != "konflikt" or erzwingen:
+ raise
+ # Zwischen Liste und Hochladen hat ein anderer Rechner gespeichert
+ self.sichern(akte["id"], fehler.extra.get("charakter", {}).get("daten"))
+ return self.hochladen(akte, None, erzwingen=True)
+ self.ergebnis["hochgeladen"] += 1
+ if charakter["aktennummer"] and charakter["aktennummer"] != akte.get("aktennummer"):
+ # Die Nummer vergibt der Server, damit sie ueber alle Spieler eindeutig ist
+ akte["aktennummer"] = charakter["aktennummer"]
+ modell.speichern(akte, zeit_setzen=False)
+ self.ergebnis["geaendert"].add(akte["id"])
+ return charakter
+
+ def herunterladen(self, charakter):
+ akte = modell.migrieren(dict(charakter["daten"] or {}))
+ akte["id"] = charakter["lokale_id"]
+ akte["aktennummer"] = charakter["aktennummer"] or akte.get("aktennummer", "")
+ akte["geaendert"] = akte.get("geaendert") or modell.zeitstempel()
+ akte["erstellt"] = akte.get("erstellt") or akte["geaendert"]
+ modell.speichern(akte, zeit_setzen=False)
+ self.ergebnis["heruntergeladen"] += 1
+ self.ergebnis["geaendert"].add(akte["id"])
+ return akte
+
+ def sichern(self, akte_id, daten):
+ """Serverfassung neben die Akte legen, bevor die lokale sie ueberschreibt."""
+ if not daten:
+ return
+ zeit = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
+ _schreiben(modell.ordner_von(akte_id) / f"konflikt-{zeit}.json", daten)
+ self.ergebnis["konflikte"] += 1
+
+ # -- Portraets ------------------------------------------------------------
+
+ def portraet(self, akte_id, charakter, meta):
+ lokal = _portraet_hash(akte_id)
+ kennung = charakter.get("portraet_kennung")
+ if lokal != meta.get("portraet_hash", ""):
+ if lokal:
+ bild = base64.b64encode(modell.portraet_pfad(akte_id).read_bytes()).decode("ascii")
+ kennung = konto.aufrufen("portraet_hochladen", lokale_id=akte_id,
+ bild=bild)["charakter"].get("portraet_kennung")
+ elif charakter.get("portraet"):
+ konto.aufrufen("portraet_entfernen", lokale_id=akte_id)
+ kennung = None
+ elif kennung != meta.get("portraet_kennung"):
+ daten = konto.bild(charakter["id"]) if kennung else None
+ if daten:
+ ordner = modell.ordner_von(akte_id)
+ zwischen = ordner / (modell.PORTRAET + ".tmp")
+ zwischen.write_bytes(daten)
+ os.replace(zwischen, ordner / modell.PORTRAET)
+ else:
+ modell.portraet_entfernen(akte_id)
+ lokal = _portraet_hash(akte_id)
+ self.ergebnis["geaendert"].add(akte_id)
+ meta["portraet_hash"] = lokal
+ meta["portraet_kennung"] = kennung
+
+ def meta_nach(self, akte, charakter, alt=None):
+ meta = dict(alt or {"portraet_hash": "", "portraet_kennung": None})
+ meta.update({"nutzer_id": self.nutzer_id, "server_id": charakter["id"],
+ "version": charakter["version"], "inhalt": inhalt_hash(akte)})
+ return meta
+
+ # -- Ablauf ---------------------------------------------------------------
+
+ def loeschungen(self):
+ rest = []
+ fehler_ = None
+ for eintrag in _loeschliste():
+ if eintrag.get("nutzer_id") != self.nutzer_id or fehler_ is not None:
+ rest.append(eintrag)
+ continue
+ try:
+ konto.aufrufen("charakter_loeschen", lokale_id=eintrag["lokale_id"])
+ except konto.ServerFehler as fehler:
+ if fehler.code != "charakter_nicht_gefunden":
+ rest.append(eintrag)
+ fehler_ = fehler
+ if rest:
+ _schreiben(_loeschliste_pfad(), rest)
+ else:
+ _loeschliste_pfad().unlink(missing_ok=True)
+ if fehler_ is not None:
+ raise fehler_
+ return {e["lokale_id"] for e in rest}
+
+ def ausfuehren(self):
+ noch_zu_loeschen = self.loeschungen()
+ server = {c["lokale_id"]: c for c in konto.aufrufen("charaktere_eigene")["charaktere"]}
+
+ for akte in modell.alle_akten():
+ akte_id = akte["id"]
+ meta = meta_laden(akte_id, self.nutzer_id)
+ charakter = server.pop(akte_id, None)
+
+ if charakter is None:
+ if meta is not None:
+ modell.in_papierkorb(akte_id)
+ self.ergebnis["entfernt"] += 1
+ self.ergebnis["geaendert"].add(akte_id)
+ continue
+ charakter = self.hochladen(akte, None)
+ elif meta is None:
+ # Auf dem Server vorhanden, von hier aus aber nie abgeglichen
+ if not _gleicher_inhalt(akte, charakter["daten"]):
+ self.sichern(akte_id, charakter["daten"])
+ charakter = self.hochladen(akte, charakter["version"], erzwingen=True)
+ else:
+ lokal_neu = inhalt_hash(akte) != meta.get("inhalt")
+ server_neu = charakter["version"] != meta.get("version")
+ if lokal_neu and server_neu:
+ self.sichern(akte_id, charakter["daten"])
+ charakter = self.hochladen(akte, charakter["version"], erzwingen=True)
+ elif lokal_neu:
+ charakter = self.hochladen(akte, charakter["version"])
+ elif server_neu:
+ akte = self.herunterladen(charakter)
+
+ meta = self.meta_nach(akte, charakter, meta)
+ self.portraet(akte_id, charakter, meta)
+ _meta_speichern(akte_id, meta)
+
+ for akte_id, charakter in server.items():
+ if akte_id in noch_zu_loeschen:
+ continue
+ akte = self.herunterladen(charakter)
+ meta = self.meta_nach(akte, charakter)
+ self.portraet(akte_id, charakter, meta)
+ _meta_speichern(akte_id, meta)
+ return self.ergebnis
+
+
+def abgleichen():
+ """
+ Ein vollstaendiger Abgleich. Gibt ein Ergebnis mit Zaehlern und der Menge
+ "geaendert" (lokal veraenderte Akten) zurueck, wirft ServerFehler.
+ Laeuft schon ein Abgleich, wird nichts getan und None zurueckgegeben.
+ """
+ stand = konto.sitzung()
+ if not stand:
+ raise konto.ServerFehler("nicht_angemeldet", "Bitte melde dich an.")
+ if not _laeuft.acquire(blocking=False):
+ return None
+ try:
+ return _Lauf(stand["nutzer"]["id"]).ausfuehren()
+ finally:
+ _laeuft.release()
diff --git a/akte.py b/akte.py
new file mode 100644
index 0000000..faa006e
--- /dev/null
+++ b/akte.py
@@ -0,0 +1,914 @@
+"""
+Modul Akte: Personalakten fuer Rollenspiel-Charaktere.
+
+Links die Liste der eigenen Akten, rechts die gewaehlte Akte - wahlweise
+als Dokument (Ansicht) oder als Formular (Bearbeiten). Die Datenhaltung
+liegt in akte_modell.py, die Vorschlagslisten in akte_vorlagen.py.
+"""
+
+import math
+import tkinter as tk
+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
+from theme import (BG, PANEL, LINE, FG, FG_DIM, OLIVE, OLIVE_HI, AMBER, RED,
+ FONT_UI, FONT_BOLD, FONT_MONO, dunkle_titelleiste)
+
+SPEICHERN_NACH_MS = 800
+
+FONT_DOK = ("Consolas", 10)
+FONT_DOK_FETT = ("Consolas", 10, "bold")
+FONT_DOK_KLEIN = ("Consolas", 9)
+FONT_STEMPEL = ("Consolas", 15, "bold")
+FONT_CALLSIGN = ("Segoe UI Semibold", 22)
+FONT_NAME = ("Segoe UI", 12)
+
+TEXT_STIL = dict(bg=PANEL, fg=FG, insertbackground=FG, relief="flat",
+ highlightthickness=1, highlightbackground=LINE,
+ highlightcolor=OLIVE, font=FONT_UI, padx=6, pady=4,
+ wrap="word", selectbackground=OLIVE,
+ selectforeground="#12150f", undo=True)
+
+PERSONALIEN = [
+ (("personalien", "vorname"), "Vorname"),
+ (("personalien", "nachname"), "Nachname"),
+ (("personalien", "callsign"), "Callsign"),
+ (("personalien", "geburtsdatum"), "Geburtsdatum"),
+ (("personalien", "herkunft"), "Herkunft"),
+]
+DIENST = [
+ (("dienst", "fraktion"), "Fraktion"),
+ (("dienst", "teilstreitkraft"), "Teilstreitkraft"),
+ (("dienst", "rang"), "Dienstgrad"),
+ (("dienst", "verwendung"), "Verwendung"),
+ (("dienst", "dienstbeginn"), "Dienstbeginn"),
+ (("dienst", "status"), "Status"),
+]
+EINHEIT = [
+ (("dienst", "einheit", "verband"), "Verband"),
+ (("dienst", "einheit", "bataillon"), "Bataillon"),
+ (("dienst", "einheit", "kompanie"), "Kompanie"),
+ (("dienst", "einheit", "zug"), "Zug"),
+ (("dienst", "einheit", "gruppe"), "Gruppe"),
+]
+LISTEN = {
+ "auszeichnungen": ("Auszeichnung",
+ [("bezeichnung", "Bezeichnung", False),
+ ("datum", "Datum", False),
+ ("anlass", "Anlass", True)]),
+ "einsaetze": ("Einsatz",
+ [("datum", "Datum", False),
+ ("ort", "Ort", False),
+ ("bericht", "Bericht", True)]),
+}
+NAMENSFELDER = {("personalien", "vorname"), ("personalien", "nachname"),
+ ("personalien", "callsign"), ("dienst", "rang")}
+
+
+def wert(akte, pfad):
+ ziel = akte
+ for teil in pfad:
+ ziel = ziel.get(teil, "") if isinstance(ziel, dict) else ""
+ return ziel if isinstance(ziel, str) else ""
+
+
+def setzen(akte, pfad, inhalt):
+ ziel = akte
+ for teil in pfad[:-1]:
+ ziel = ziel.setdefault(teil, {})
+ ziel[pfad[-1]] = inhalt
+
+
+def eintrag_dialog(eltern, titel, felder, werte=None):
+ """Kleines Eingabefenster fuer einen Listeneintrag. None bei Abbruch."""
+ werte = werte or {}
+ fenster = tk.Toplevel(eltern)
+ fenster.title(titel)
+ fenster.configure(bg=BG)
+ fenster.resizable(False, False)
+ fenster.transient(eltern.winfo_toplevel())
+
+ rahmen = ttk.Frame(fenster)
+ rahmen.pack(padx=18, pady=16, fill="both")
+ eingaben = {}
+ erstes = None
+ for zeile, (schluessel, beschriftung, lang) in enumerate(felder):
+ ttk.Label(rahmen, text=beschriftung).grid(
+ row=zeile, column=0, sticky="nw", padx=(0, 12), pady=5)
+ if lang:
+ feld = tk.Text(rahmen, width=46, height=6, **TEXT_STIL)
+ feld.insert("1.0", werte.get(schluessel, ""))
+ else:
+ feld = ttk.Entry(rahmen, width=48)
+ feld.insert(0, werte.get(schluessel, ""))
+ feld.grid(row=zeile, column=1, sticky="ew", pady=5)
+ eingaben[schluessel] = feld
+ erstes = erstes or feld
+
+ ergebnis = {}
+
+ def uebernehmen(*_):
+ for schluessel, feld in eingaben.items():
+ inhalt = feld.get("1.0", "end-1c") if isinstance(feld, tk.Text) else feld.get()
+ ergebnis[schluessel] = inhalt.strip()
+ fenster.destroy()
+
+ knoepfe = ttk.Frame(rahmen)
+ knoepfe.grid(row=len(felder), column=0, columnspan=2, sticky="e", pady=(12, 0))
+ ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right")
+ ttk.Button(knoepfe, text="Übernehmen", style="Accent.TButton",
+ command=uebernehmen).pack(side="right", padx=(0, 8))
+ fenster.bind("", lambda e: fenster.destroy())
+
+ 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)}")
+ fenster.grab_set()
+ if erstes is not None:
+ erstes.focus_set()
+ eltern.wait_window(fenster)
+ return ergebnis or None
+
+
+class ScrollFlaeche(ttk.Frame):
+ """Senkrecht scrollbarer Bereich; der Inhalt gehoert in self.innen."""
+
+ def __init__(self, master):
+ super().__init__(master)
+ self.canvas = tk.Canvas(self, bg=BG, highlightthickness=0, bd=0)
+ leiste = ttk.Scrollbar(self, orient="vertical", command=self.canvas.yview)
+ self.canvas.configure(yscrollcommand=leiste.set)
+ leiste.pack(side="right", fill="y")
+ self.canvas.pack(side="left", fill="both", expand=True)
+ self.innen = ttk.Frame(self.canvas)
+ self._fenster = self.canvas.create_window(0, 0, window=self.innen, anchor="nw")
+ self.innen.bind("", lambda e: self.canvas.configure(
+ scrollregion=self.canvas.bbox("all")))
+ self.canvas.bind("", lambda e: self.canvas.itemconfigure(
+ self._fenster, width=e.width))
+ self._rollziel = self.canvas
+
+
+class AkteSeite(ttk.Frame):
+ """Inhalt des Hauptreiters AKTE."""
+
+ def __init__(self, master):
+ super().__init__(master)
+ self.akten = []
+ self.aktuell = None
+ self._geaendert_flag = False
+ self._speicher_job = None
+ self._zeichen_job = None
+ self._laedt = False
+ self._fotos = {}
+ self.modus = "ansicht"
+ # Setzt der Squad-Reiter: Nach jeder Aenderung wird der Abgleich angestossen
+ self.bei_gespeichert = None
+
+ self._aufbau()
+ self.bind_all("", self._mausrad, add="+")
+ self.akten_laden()
+
+ # -- Aufbau ------------------------------------------------------------
+ def _aufbau(self):
+ self.columnconfigure(1, weight=1)
+ self.rowconfigure(0, weight=1)
+
+ links = ttk.Frame(self, width=240)
+ links.grid(row=0, column=0, sticky="nsw", padx=(0, 12), pady=(8, 0))
+ links.rowconfigure(1, weight=1)
+ ttk.Label(links, text="AKTEN", style="Dim.TLabel").grid(
+ row=0, column=0, columnspan=2, sticky="w", pady=(0, 4))
+ self.liste = ttk.Treeview(links, columns=("name", "nr"), show="headings",
+ selectmode="browse", height=12)
+ self.liste.heading("name", text="Name", anchor="w")
+ self.liste.heading("nr", text="Nr.", anchor="w")
+ self.liste.column("name", width=150, anchor="w")
+ self.liste.column("nr", width=86, anchor="w", stretch=False)
+ self.liste.grid(row=1, column=0, columnspan=2, sticky="nsew")
+ self.liste.bind("<>", self._auswahl)
+ ttk.Button(links, text="Neue Akte", style="Accent.TButton",
+ command=self.neue_akte).grid(row=2, column=0, sticky="ew",
+ 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))
+ rechts.columnconfigure(0, weight=1)
+ rechts.rowconfigure(1, weight=1)
+ self.rechts = rechts
+
+ leiste = ttk.Frame(rechts)
+ leiste.grid(row=0, column=0, sticky="ew", pady=(0, 6))
+ self.nummer_var = tk.StringVar()
+ ttk.Label(leiste, textvariable=self.nummer_var, style="Mono.TLabel").pack(side="left")
+ self.knopf_bearbeiten = ttk.Button(leiste, text="Bearbeiten",
+ command=lambda: self.modus_setzen("bearbeiten"))
+ self.knopf_bearbeiten.pack(side="right")
+ self.knopf_ansicht = ttk.Button(leiste, text="Ansicht",
+ command=lambda: self.modus_setzen("ansicht"))
+ self.knopf_ansicht.pack(side="right", padx=(0, 6))
+ self.knopf_teilen = ttk.Button(leiste, text="Teilen …", command=self.teilen_menue)
+ self.knopf_teilen.pack(side="right", padx=(0, 18))
+ self.rueckmeldung_var = tk.StringVar()
+ ttk.Label(leiste, textvariable=self.rueckmeldung_var, style="Dim.TLabel").pack(
+ side="left", padx=(16, 0))
+ self._rueckmeldung_job = None
+ self.leiste = leiste
+
+ # Dokumentansicht
+ self.ansicht = ttk.Frame(rechts)
+ self.dok = tk.Canvas(self.ansicht, bg=BG, highlightthickness=0, bd=0)
+ dok_leiste = ttk.Scrollbar(self.ansicht, orient="vertical", command=self.dok.yview)
+ self.dok.configure(yscrollcommand=dok_leiste.set)
+ dok_leiste.pack(side="right", fill="y")
+ self.dok.pack(side="left", fill="both", expand=True)
+ self.dok._rollziel = self.dok
+ self.dok.bind("", lambda e: self._neu_zeichnen_planen())
+
+ # Formular
+ self.formular = ScrollFlaeche(rechts)
+ self._formular_aufbauen(self.formular.innen)
+
+ # Leerzustand
+ self.leer = ttk.Frame(rechts)
+ mitte = ttk.Frame(self.leer)
+ mitte.place(relx=0.5, rely=0.4, anchor="center")
+ stempel = tk.Canvas(mitte, width=300, height=86, bg=BG, highlightthickness=0)
+ stempel.pack(pady=(0, 18))
+ stempel.create_rectangle(8, 8, 292, 78, outline=AMBER, width=3)
+ stempel.create_rectangle(15, 15, 285, 71, outline=AMBER, width=1)
+ stempel.create_text(150, 43, text="PERSONALAKTE", fill=AMBER,
+ font=("Consolas", 20, "bold"))
+ ttk.Label(mitte, text="Noch keine Akte angelegt",
+ font=("Segoe UI Semibold", 12)).pack()
+ ttk.Label(mitte, style="Dim.TLabel", justify="center",
+ text="Lege eine Akte für deinen Charakter an: Porträt,\n"
+ "Dienstgrad, Einheit, Auszeichnungen und Werdegang.").pack(pady=(6, 14))
+ ttk.Button(mitte, text="Erste Akte anlegen", style="Accent.TButton",
+ command=self.neue_akte).pack()
+
+ def _abschnitt(self, eltern, titel):
+ rahmen = ttk.LabelFrame(eltern, text=titel)
+ rahmen.pack(fill="x", padx=(2, 14), pady=(0, 12))
+ innen = ttk.Frame(rahmen)
+ innen.pack(fill="x", padx=12, pady=10)
+ return innen
+
+ def _formular_aufbauen(self, f):
+ self.vars = {}
+
+ def feld(eltern, zeile, spalte, pfad, beschriftung, art="eingabe", werte=()):
+ ttk.Label(eltern, text=beschriftung).grid(
+ row=zeile, column=spalte, sticky="w", padx=(0, 10), pady=4)
+ var = tk.StringVar()
+ if art == "eingabe":
+ widget = ttk.Entry(eltern, textvariable=var)
+ else:
+ widget = ttk.Combobox(eltern, textvariable=var, values=list(werte),
+ state="readonly" if art == "fest" else "normal")
+ # Mausrad soll die Seite rollen, nicht den Eintrag wechseln
+ widget.bind("", lambda e: (self._mausrad(e), "break")[1])
+ widget.grid(row=zeile, column=spalte + 1, sticky="ew", pady=4, padx=(0, 16))
+ var.trace_add("write", lambda *_, p=pfad, v=var: self._feld_geaendert(p, v.get()))
+ self.vars[pfad] = var
+ return widget
+
+ # I. Personalien, mit Portraet rechts
+ p = self._abschnitt(f, "I. Personalien")
+ p.columnconfigure(1, weight=1)
+ for zeile, (pfad, beschriftung) in enumerate(PERSONALIEN):
+ feld(p, zeile, 0, pfad, beschriftung)
+ bildrahmen = ttk.Frame(p)
+ bildrahmen.grid(row=0, column=2, rowspan=len(PERSONALIEN), sticky="ne", padx=(8, 0))
+ self.bild_vorschau = tk.Label(bildrahmen, bg=PANEL, fg=FG_DIM, width=12, height=7,
+ text="kein\nPorträt", font=FONT_UI,
+ highlightthickness=1, highlightbackground=LINE)
+ self.bild_vorschau.pack()
+ ttk.Button(bildrahmen, text="Bild wählen …",
+ command=self.portraet_waehlen).pack(fill="x", pady=(6, 2))
+ ttk.Button(bildrahmen, text="Entfernen",
+ command=self.portraet_entfernen).pack(fill="x")
+
+ # II. Dienst
+ d = self._abschnitt(f, "II. Dienst")
+ d.columnconfigure(1, weight=1)
+ d.columnconfigure(3, weight=1)
+ # Nur Auswahllisten: Teilstreitkraft und Dienstgrad haengen von der
+ # Fraktion ab, siehe _auswahl_anpassen
+ self.fraktion_box = feld(d, 0, 0, ("dienst", "fraktion"), "Fraktion", "fest",
+ vorlagen.fraktionsnamen())
+ self.tsk_box = feld(d, 0, 2, ("dienst", "teilstreitkraft"), "Teilstreitkraft", "fest")
+ self.rang_box = feld(d, 1, 0, ("dienst", "rang"), "Dienstgrad", "fest")
+ feld(d, 1, 2, ("dienst", "verwendung"), "Verwendung", "fest", vorlagen.VERWENDUNGEN)
+ feld(d, 2, 0, ("dienst", "dienstbeginn"), "Dienstbeginn")
+ feld(d, 2, 2, ("dienst", "status"), "Status", "fest", modell.STATUS)
+ self.pruef_var = tk.StringVar()
+ self.pruef_hinweis = ttk.Label(d, textvariable=self.pruef_var, foreground=AMBER,
+ wraplength=520, justify="left")
+ self.pruef_hinweis.grid(row=3, column=0, columnspan=4, sticky="w", pady=(6, 0))
+ self.pruef_hinweis.grid_remove()
+ ttk.Label(d, text="Einheit", style="Dim.TLabel").grid(
+ row=4, column=0, columnspan=4, sticky="w", pady=(10, 2))
+ for i, (pfad, beschriftung) in enumerate(EINHEIT):
+ feld(d, 5 + i // 2, (i % 2) * 2, pfad, beschriftung)
+
+ # III. Beschreibung
+ b = self._abschnitt(f, "III. Beschreibung")
+ self.text_beschreibung = self._textfeld(b, "beschreibung", 7)
+
+ # IV. und V. Listen
+ self.listen = {}
+ for schluessel, titel in (("auszeichnungen", "IV. Auszeichnungen"),
+ ("einsaetze", "V. Einsätze")):
+ self.listen[schluessel] = self._listenfeld(self._abschnitt(f, titel), schluessel)
+
+ # VI. Vermerke
+ v = self._abschnitt(f, "VI. Vermerke")
+ self.text_vermerke = self._textfeld(v, "vermerke", 4)
+
+ def _textfeld(self, eltern, schluessel, hoehe):
+ text = tk.Text(eltern, height=hoehe, **TEXT_STIL)
+ text.pack(fill="x")
+
+ def geaendert(_):
+ if text.edit_modified():
+ text.edit_modified(False)
+ if not self._laedt and self.aktuell is not None:
+ self.aktuell[schluessel] = text.get("1.0", "end-1c")
+ self._speichern_planen()
+ text.bind("<>", geaendert)
+ return text
+
+ def _listenfeld(self, eltern, schluessel):
+ einzahl, felder = LISTEN[schluessel]
+ spalten = [f[0] for f in felder]
+ tabelle = ttk.Treeview(eltern, columns=spalten, show="headings", height=4,
+ selectmode="browse")
+ for s, beschriftung, lang in felder:
+ tabelle.heading(s, text=beschriftung, anchor="w")
+ breite = 260 if lang else 80 if s == "datum" else 180
+ tabelle.column(s, width=breite, anchor="w", stretch=lang)
+ tabelle.pack(fill="x")
+ tabelle.bind("", lambda e: self._eintrag_bearbeiten(schluessel))
+ knoepfe = ttk.Frame(eltern)
+ knoepfe.pack(fill="x", pady=(6, 0))
+ ttk.Button(knoepfe, text=f"{einzahl} hinzufügen",
+ command=lambda: self._eintrag_neu(schluessel)).pack(side="left")
+ ttk.Button(knoepfe, text="Bearbeiten",
+ command=lambda: self._eintrag_bearbeiten(schluessel)).pack(side="left", padx=6)
+ ttk.Button(knoepfe, text="Entfernen",
+ command=lambda: self._eintrag_entfernen(schluessel)).pack(side="left")
+ return tabelle
+
+ # -- Liste der Akten -----------------------------------------------------
+ def akten_laden(self, auswahl=None):
+ self.akten = 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 not self.akten:
+ self.aktuell = None
+ self._zeigen(self.leer)
+ self.nummer_var.set("")
+ return
+ ziel = auswahl if auswahl in {a["id"] for a in self.akten} else self.akten[0]["id"]
+ self.liste.selection_set(ziel)
+ self.liste.see(ziel)
+ self._oeffnen(ziel)
+
+ def _auswahl(self, _=None):
+ auswahl = self.liste.selection()
+ if auswahl and (self.aktuell is None or auswahl[0] != self.aktuell["id"]):
+ self._oeffnen(auswahl[0])
+
+ def _oeffnen(self, akte_id):
+ self.speichern_sofort()
+ vorher = self.aktuell["id"] if self.aktuell else None
+ self.aktuell = next((a for a in self.akten if a["id"] == akte_id), None)
+ if self.aktuell is None:
+ return
+ self.nummer_var.set(f"AKTE {self.aktuell['aktennummer']}")
+ self._formular_fuellen()
+ if akte_id != vorher:
+ # Eine andere Akte beginnt oben, nicht an der Stelle der vorigen
+ self.dok.yview_moveto(0)
+ self.formular.canvas.yview_moveto(0)
+ self.modus_setzen(self.modus)
+
+ def neue_akte(self):
+ self.speichern_sofort()
+ try:
+ akte = modell.neu_anlegen()
+ except OSError as fehler:
+ messagebox.showerror("Akte", f"Die Akte konnte nicht angelegt werden:\n{fehler}")
+ return
+ self.modus = "bearbeiten"
+ self.akten_laden(akte["id"])
+ self._gespeichert()
+
+ def in_papierkorb(self):
+ if self.aktuell is None:
+ return
+ name = modell.anzeigename(self.aktuell)
+ if not messagebox.askyesno(
+ "Akte in den Papierkorb",
+ f"„{name}“ in den Papierkorb verschieben?\n\n"
+ "Die Akte wird nicht gelöscht, sondern in den Ordner "
+ "_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):
+ if self.aktuell is None:
+ return
+ menue = tk.Menu(self, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE,
+ activeforeground="#12150f", font=FONT_UI)
+ menue.add_command(label="Karte kopieren – in Discord mit Strg+V einfügen",
+ command=self.karte_kopieren)
+ menue.add_command(label="Karte als PNG speichern …", command=self.karte_speichern)
+ knopf = self.knopf_teilen
+ menue.tk_popup(knopf.winfo_rootx(), knopf.winfo_rooty() + knopf.winfo_height())
+
+ def _karte(self):
+ self.speichern_sofort()
+ return akte_karte.karte(self.aktuell)
+
+ def karte_kopieren(self):
+ try:
+ akte_karte.in_zwischenablage(self._karte())
+ except Exception as fehler:
+ messagebox.showerror("Akte teilen",
+ f"Die Karte konnte nicht kopiert werden:\n{fehler}")
+ return
+ # Kurz: Neben Nummer und drei Knoepfen bleiben in der Leiste nur
+ # rund 150 Pixel. Den Tipp mit Strg+V nennt schon der Menueeintrag.
+ self._rueckmeldung("✓ Kopiert")
+
+ def karte_speichern(self):
+ ziel = filedialog.asksaveasfilename(
+ parent=self, title="Karte speichern", defaultextension=".png",
+ filetypes=[("PNG-Bild", "*.png")],
+ initialfile=akte_karte.dateiname(self.aktuell))
+ if not ziel:
+ return
+ try:
+ self._karte().save(ziel, "PNG", optimize=True)
+ except Exception as fehler:
+ messagebox.showerror("Akte teilen",
+ f"Die Karte konnte nicht gespeichert werden:\n{fehler}")
+ return
+ self._rueckmeldung("✓ Gespeichert")
+
+ def _rueckmeldung(self, text):
+ self.rueckmeldung_var.set(text)
+ if self._rueckmeldung_job is not None:
+ self.after_cancel(self._rueckmeldung_job)
+ self._rueckmeldung_job = self.after(
+ 5000, lambda: self.rueckmeldung_var.set(""))
+
+ # -- Umschalten ----------------------------------------------------------
+ def _zeigen(self, rahmen):
+ for r in (self.ansicht, self.formular, self.leer):
+ if r is not rahmen:
+ r.grid_remove()
+ rahmen.grid(row=1, column=0, sticky="nsew")
+ if rahmen is self.leer:
+ self.leiste.grid_remove()
+ else:
+ self.leiste.grid()
+
+ def modus_setzen(self, modus):
+ self.modus = modus
+ if self.aktuell is None:
+ self._zeigen(self.leer)
+ return
+ if modus == "ansicht":
+ self.speichern_sofort()
+ self._zeigen(self.ansicht)
+ self.ansicht_zeichnen()
+ else:
+ self._zeigen(self.formular)
+ self.knopf_ansicht.configure(style="Accent.TButton" if modus == "ansicht" else "TButton")
+ self.knopf_bearbeiten.configure(style="Accent.TButton" if modus != "ansicht" else "TButton")
+
+ # -- Formular ------------------------------------------------------------
+ def _formular_fuellen(self):
+ a = self.aktuell
+ self._laedt = True
+ try:
+ for pfad, var in self.vars.items():
+ var.set(wert(a, pfad))
+ self._auswahl_anpassen(beim_laden=True)
+ for text, schluessel in ((self.text_beschreibung, "beschreibung"),
+ (self.text_vermerke, "vermerke")):
+ text.delete("1.0", "end")
+ text.insert("1.0", a.get(schluessel, ""))
+ text.edit_reset()
+ text.edit_modified(False)
+ for schluessel in self.listen:
+ self._liste_fuellen(schluessel)
+ self._vorschau_aktualisieren()
+ finally:
+ self._laedt = False
+
+ def _feld_geaendert(self, pfad, inhalt):
+ if self._laedt or self.aktuell is None:
+ return
+ setzen(self.aktuell, pfad, inhalt)
+ if pfad in (("dienst", "fraktion"), ("dienst", "teilstreitkraft")):
+ self._auswahl_anpassen()
+ if pfad[0] == "dienst":
+ self._pruefhinweis_zeigen()
+ if pfad in NAMENSFELDER:
+ self.liste.item(self.aktuell["id"],
+ values=(modell.listenname(self.aktuell),
+ self.aktuell["aktennummer"]))
+ self._speichern_planen()
+
+ def _auswahl_anpassen(self, beim_laden=False):
+ """
+ Stellt die Listen fuer Teilstreitkraft und Dienstgrad auf die Fraktion ein.
+
+ Nach einem Wechsel wird ersetzt, was nicht mehr passt: die
+ Teilstreitkraft durch die erste der Fraktion, der Dienstgrad durch
+ nichts. Beim Laden bleibt die Akte unveraendert, unpassende Werte
+ meldet dann der Pruefhinweis.
+ """
+ fraktion = self.vars[("dienst", "fraktion")].get()
+ tsk_var = self.vars[("dienst", "teilstreitkraft")]
+ rang_var = self.vars[("dienst", "rang")]
+ teilstreitkraefte = vorlagen.teilstreitkraefte_fuer(fraktion)
+ self.tsk_box["values"] = teilstreitkraefte
+ if not beim_laden and teilstreitkraefte and tsk_var.get() not in teilstreitkraefte:
+ tsk_var.set(teilstreitkraefte[0]) # loest diese Methode erneut aus
+ raenge = vorlagen.raenge_fuer(fraktion, tsk_var.get())
+ self.rang_box["values"] = raenge
+ if not beim_laden and rang_var.get() and rang_var.get() not in raenge:
+ rang_var.set("")
+ if beim_laden:
+ self._pruefhinweis_zeigen()
+
+ def _pruefhinweis_zeigen(self):
+ hinweise = vorlagen.pruefen(self.aktuell.get("dienst", {})) if self.aktuell else []
+ self.pruef_var.set("\n".join("⚠ " + h + " Bitte neu wählen." for h in hinweise))
+ if hinweise:
+ self.pruef_hinweis.grid()
+ else:
+ self.pruef_hinweis.grid_remove()
+
+ def _liste_fuellen(self, schluessel):
+ tabelle = self.listen[schluessel]
+ tabelle.delete(*tabelle.get_children())
+ _, felder = LISTEN[schluessel]
+ for i, eintrag in enumerate(self.aktuell.get(schluessel, [])):
+ tabelle.insert("", "end", iid=str(i),
+ values=[eintrag.get(f[0], "").replace("\n", " ") for f in felder])
+
+ def _eintrag_neu(self, schluessel):
+ if self.aktuell is None:
+ return
+ einzahl, felder = LISTEN[schluessel]
+ eintrag = eintrag_dialog(self, f"{einzahl} hinzufügen", felder)
+ if eintrag and any(eintrag.values()):
+ self.aktuell.setdefault(schluessel, []).append(eintrag)
+ self._liste_fuellen(schluessel)
+ self._speichern_planen()
+
+ def _eintrag_bearbeiten(self, schluessel):
+ auswahl = self.listen[schluessel].selection()
+ if self.aktuell is None or not auswahl:
+ return
+ i = int(auswahl[0])
+ einzahl, felder = LISTEN[schluessel]
+ eintrag = eintrag_dialog(self, f"{einzahl} bearbeiten", felder,
+ self.aktuell[schluessel][i])
+ if eintrag is not None:
+ self.aktuell[schluessel][i] = eintrag
+ self._liste_fuellen(schluessel)
+ self._speichern_planen()
+
+ def _eintrag_entfernen(self, schluessel):
+ auswahl = self.listen[schluessel].selection()
+ if self.aktuell is None or not auswahl:
+ return
+ del self.aktuell[schluessel][int(auswahl[0])]
+ self._liste_fuellen(schluessel)
+ self._speichern_planen()
+
+ # -- Portraet ------------------------------------------------------------
+ def _foto(self, akte_id, groesse):
+ pfad = modell.portraet_pfad(akte_id)
+ if pfad is None:
+ return None
+ schluessel = (akte_id, groesse)
+ stand = pfad.stat().st_mtime
+ vorhanden = self._fotos.get(schluessel)
+ if vorhanden and vorhanden[0] == stand:
+ return vorhanden[1]
+ with Image.open(pfad) as bild:
+ foto = ImageTk.PhotoImage(ImageOps.contain(bild.convert("RGBA"), groesse))
+ self._fotos[schluessel] = (stand, foto)
+ return foto
+
+ def _vorschau_aktualisieren(self):
+ foto = self._foto(self.aktuell["id"], (96, 120)) if self.aktuell else None
+ if foto:
+ self.bild_vorschau.configure(image=foto, text="", width=96, height=120)
+ else:
+ self.bild_vorschau.configure(image="", text="kein\nPorträt", width=12, height=7)
+
+ def portraet_waehlen(self):
+ if self.aktuell is None:
+ return
+ quelle = filedialog.askopenfilename(
+ title="Porträt wählen",
+ filetypes=[("Bilder", "*.png *.jpg *.jpeg *.webp *.bmp *.gif"),
+ ("Alle Dateien", "*.*")])
+ if not quelle:
+ return
+ try:
+ modell.portraet_setzen(self.aktuell["id"], quelle)
+ except modell.AktenFehler as fehler:
+ 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:
+ return
+ 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):
+ self._geaendert_flag = True
+ if self._speicher_job is not None:
+ self.after_cancel(self._speicher_job)
+ self._speicher_job = self.after(SPEICHERN_NACH_MS, self.speichern_sofort)
+
+ def speichern_sofort(self):
+ if self._speicher_job is not None:
+ self.after_cancel(self._speicher_job)
+ self._speicher_job = None
+ if not self._geaendert_flag or self.aktuell is None:
+ return
+ try:
+ modell.speichern(self.aktuell)
+ 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):
+ try:
+ widget = self.winfo_containing(ereignis.x_root, ereignis.y_root)
+ except (KeyError, tk.TclError):
+ return
+ while widget is not None:
+ if isinstance(widget, (tk.Text, ttk.Treeview)):
+ return
+ ziel = getattr(widget, "_rollziel", None)
+ if ziel is not None:
+ ziel.yview_scroll(int(-ereignis.delta / 120), "units")
+ return
+ if widget is self:
+ return
+ widget = widget.master
+
+ # -- Dokumentansicht -----------------------------------------------------
+ def _neu_zeichnen_planen(self):
+ if self.modus != "ansicht" or self.aktuell is None:
+ return
+ if self._zeichen_job is not None:
+ self.after_cancel(self._zeichen_job)
+ self._zeichen_job = self.after(60, self.ansicht_zeichnen)
+
+ def ansicht_zeichnen(self):
+ self._zeichen_job = None
+ if self.aktuell is None:
+ self.dok.delete("all")
+ return
+ akte_id = self.aktuell["id"]
+ dokument_zeichnen(self.dok, self.aktuell, lambda groesse: self._foto(akte_id, groesse))
+
+
+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
+
+ 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 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 "—",
+ fill=schrift if inhalt else FG_DIM, font=FONT_DOK,
+ width=rechts - links)
+ return c.bbox(t)[3] + 18
+
+ 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("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("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("VI. VERMERKE", y + 4)
+ y = fliesstext(a.get("vermerke", ""), y)
+
+ karte = c.create_rectangle(rand, rand, breite - rand, y + 6, fill=PANEL, outline=LINE)
+ c.tag_lower(karte)
+ c.configure(scrollregion=(0, 0, breite, y + rand + 10))
+
+
+
+def _stempel(c, mx, my, text, farbe, winkel=18):
+ """Schraeger Stempel ueber dem Portraet, mit gedrehtem Rahmen."""
+ t = c.create_text(mx, my, text=text, fill=farbe, angle=winkel,
+ font=("Consolas", 18, "bold"))
+ breite = len(text) * 14 + 26
+ hoehe = 38
+ rad = math.radians(winkel)
+ ecken = []
+ for dx, dy in ((-breite / 2, -hoehe / 2), (breite / 2, -hoehe / 2),
+ (breite / 2, hoehe / 2), (-breite / 2, hoehe / 2)):
+ ecken += [mx + dx * math.cos(rad) + dy * math.sin(rad),
+ my - dx * math.sin(rad) + dy * math.cos(rad)]
+ c.create_polygon(*ecken, outline=farbe, fill="", width=3)
+ c.tag_raise(t)
diff --git a/akte_karte.py b/akte_karte.py
new file mode 100644
index 0000000..4efba11
--- /dev/null
+++ b/akte_karte.py
@@ -0,0 +1,291 @@
+"""
+Akte als Bild zum Teilen, etwa in Discord.
+
+Gezeichnet mit Pillow statt vom Bildschirm abfotografiert: Die Karte sieht
+so auf jedem Rechner gleich aus, unabhaengig von Fenstergroesse und
+Bildschirmskalierung, und laesst sich ohne Fenster erzeugen und pruefen.
+Das Format 1200 x 675 zeigt Discord gross und scharf an.
+"""
+
+import io
+import re
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont, ImageOps
+
+import akte_modell as modell
+from theme import BG, PANEL, LINE, FG, FG_DIM, OLIVE_HI, AMBER, RED
+
+BREITE, HOEHE = 1200, 675
+FUSSZEILE = "ERSTELLT MIT SQUAD MANAGER · SVA.TYRVEIL.COM"
+
+MONO, MONO_FETT = "consola.ttf", "consolab.ttf"
+UI, UI_HALBFETT = "segoeui.ttf", "seguisb.ttf"
+
+
+def _schrift(datei, groesse):
+ try:
+ return ImageFont.truetype(datei, groesse)
+ except OSError:
+ return ImageFont.load_default(groesse)
+
+
+def _kuerzen(zeichnen, text, schrift, breite):
+ """Schneidet mit Auslassungszeichen ab, bis der Text in die Breite passt."""
+ if zeichnen.textlength(text, font=schrift) <= breite:
+ return text
+ while text and zeichnen.textlength(text + " …", font=schrift) > breite:
+ text = text[:-1]
+ return text.rstrip() + " …"
+
+
+def _umbrechen(zeichnen, text, schrift, breite, zeilen_max):
+ zeilen, aktuell = [], ""
+ for wort in text.split():
+ probe = f"{aktuell} {wort}".strip()
+ if zeichnen.textlength(probe, font=schrift) <= breite or not aktuell:
+ aktuell = probe
+ else:
+ zeilen.append(aktuell)
+ aktuell = wort
+ if aktuell:
+ zeilen.append(aktuell)
+ if len(zeilen) > zeilen_max:
+ zeilen = zeilen[:zeilen_max]
+ zeilen[-1] += " …"
+ return [_kuerzen(zeichnen, z, schrift, breite) for z in zeilen]
+
+
+def _groesste_schrift(zeichnen, text, datei, breite, groessen):
+ for groesse in groessen:
+ schrift = _schrift(datei, groesse)
+ if zeichnen.textlength(text, font=schrift) <= breite:
+ return schrift
+ return _schrift(datei, groessen[-1])
+
+
+def _portraet(akte, groesse, gedaempft):
+ pfad = modell.portraet_pfad(akte.get("id", ""))
+ if not pfad or not Path(pfad).is_file():
+ return None
+ try:
+ with Image.open(pfad) as quelle:
+ bild = ImageOps.fit(ImageOps.exif_transpose(quelle).convert("RGB"), groesse,
+ Image.LANCZOS)
+ except OSError:
+ return None
+ if gedaempft:
+ grau = ImageOps.grayscale(bild).convert("RGB")
+ bild = Image.blend(grau, Image.new("RGB", groesse, BG), 0.35)
+ return bild
+
+
+def _stempel(bild, mitte, text, farbe, winkel=18):
+ """Schraeger Stempel wie in der Dokumentansicht, hier als gedrehte Ebene."""
+ schrift = _schrift(MONO_FETT, 42)
+ probe = ImageDraw.Draw(bild)
+ links, oben, rechts, unten = probe.textbbox((0, 0), text, font=schrift)
+ breite, hoehe = rechts - links + 60, unten - oben + 40
+ ebene = Image.new("RGBA", (breite, hoehe), (0, 0, 0, 0))
+ zeichnen = ImageDraw.Draw(ebene)
+ zeichnen.rectangle((3, 3, breite - 4, hoehe - 4), outline=farbe, width=6)
+ zeichnen.text((breite / 2, hoehe / 2), text, font=schrift, fill=farbe, anchor="mm")
+ ebene = ebene.rotate(winkel, expand=True, resample=Image.BICUBIC)
+ ebene.putalpha(ebene.getchannel("A").point(lambda wert: int(wert * 0.92)))
+ x, y = int(mitte[0] - ebene.width / 2), int(mitte[1] - ebene.height / 2)
+ bild.paste(ebene, (x, y), ebene)
+
+
+def _datum(iso):
+ teile = str(iso)[:10].split("-")
+ return ".".join(reversed(teile)) if len(teile) == 3 else ""
+
+
+def karte(akte):
+ """Gibt die Karte als Pillow-Bild zurueck."""
+ pers, dienst = akte.get("personalien", {}), akte.get("dienst", {})
+ status = dienst.get("status", "aktiv") or "aktiv"
+ gefallen = status == "gefallen"
+ schrift_farbe = FG_DIM if gefallen else FG
+ akzent = FG_DIM if gefallen else OLIVE_HI
+
+ bild = Image.new("RGB", (BREITE, HOEHE), BG)
+ z = ImageDraw.Draw(bild)
+ z.rectangle((24, 24, BREITE - 25, HOEHE - 25), fill=PANEL, outline=LINE, width=2)
+
+ klein = _schrift(MONO, 17)
+ z.text((60, 46), f"AKTE NR. {akte.get('aktennummer', '')}", font=klein, fill=FG_DIM)
+ z.text((BREITE - 60, 46), "SQUAD MANAGER · PERSONALWESEN", font=klein, fill=FG_DIM,
+ anchor="ra")
+ z.line((60, 80, BREITE - 60, 80), fill=LINE, width=2)
+
+ # Portraet links
+ px0, py0, pb, ph = 60, 108, 312, 390
+ z.rectangle((px0 - 7, py0 - 7, px0 + pb + 6, py0 + ph + 6), outline=LINE, width=2)
+ foto = _portraet(akte, (pb, ph), gefallen)
+ if foto:
+ bild.paste(foto, (px0, py0))
+ else:
+ z.rectangle((px0, py0, px0 + pb - 1, py0 + ph - 1), fill=BG)
+ # Unter einem Stempel wuerde der Text nur durchscheinen
+ if status not in ("gefallen", "vermisst"):
+ z.multiline_text((px0 + pb / 2, py0 + ph / 2), "KEIN\nPORTRÄT",
+ font=_schrift(MONO, 22), fill=FG_DIM, anchor="mm",
+ align="center", spacing=8)
+
+ # Kopfdaten rechts
+ x, rechts = 420, BREITE - 60
+ breite = rechts - x
+ stempel_schrift = _schrift(MONO_FETT, 24)
+ links, oben, r, unten = z.textbbox((x + 16, 112), "PERSONALAKTE", font=stempel_schrift)
+ z.rectangle((links - 16, oben - 10, r + 16, unten + 10), outline=AMBER, width=3)
+ z.text((x + 16, 112), "PERSONALAKTE", font=stempel_schrift, fill=AMBER)
+
+ 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 "NEUE AKTE")
+ titel_schrift = _groesste_schrift(z, titel, UI_HALBFETT, breite, range(72, 38, -4))
+ y = 160
+ z.text((x, y), _kuerzen(z, titel, titel_schrift, breite), font=titel_schrift, fill=akzent)
+ y += titel_schrift.size + 10
+ zweite = " ".join(t for t in (dienst.get("rang", ""), name if callsign else "") if t)
+ if zweite:
+ name_schrift = _schrift(UI, 30)
+ z.text((x, y), _kuerzen(z, zweite, name_schrift, breite), font=name_schrift,
+ fill=schrift_farbe)
+ y += 44
+ y += 8
+
+ einheit = " · ".join(v for v in (dienst.get("einheit", {}).get(k, "") for k in
+ ("verband", "bataillon", "kompanie", "zug", "gruppe")) if v)
+ einsaetze = akte.get("einsaetze", [])
+ letzter = next((e.get("ort", "") for e in reversed(einsaetze) if e.get("ort")), "")
+ zeilen = [
+ ("FRAKTION", " · ".join(v for v in (dienst.get("fraktion", ""),
+ dienst.get("teilstreitkraft", "")) if v)),
+ ("VERWENDUNG", dienst.get("verwendung", "")),
+ ("EINHEIT", einheit),
+ ("STATUS", status.upper()),
+ ("DIENSTBEGINN", dienst.get("dienstbeginn", "")),
+ ("EINSÄTZE", f"{len(einsaetze)}" + (f" · zuletzt {letzter}" if letzter else "")
+ if einsaetze else ""),
+ ]
+ beschriftung, inhalt = _schrift(MONO, 17), _schrift(MONO, 21)
+ wert_x = x + 190
+ for titel_zeile, wert in zeilen:
+ if not wert:
+ continue
+ umbruch = _umbrechen(z, wert, inhalt, rechts - wert_x, 2)
+ if y + 31 * len(umbruch) > 512:
+ break
+ z.text((x, y + 3), titel_zeile, font=beschriftung, fill=FG_DIM)
+ farbe = (RED if gefallen else AMBER) if titel_zeile == "STATUS" and \
+ status in ("gefallen", "vermisst") else schrift_farbe
+ for teil in umbruch:
+ z.text((wert_x, y), teil, font=inhalt, fill=farbe)
+ y += 31
+
+ if status in ("gefallen", "vermisst"):
+ _stempel(bild, (px0 + pb / 2, py0 + ph / 2), status.upper(), RED if gefallen else AMBER)
+
+ # Leiste unten: Auszeichnungen, sonst ein Stueck Beschreibung
+ z.line((60, 526, BREITE - 60, 526), fill=LINE, width=2)
+ auszeichnungen = [e.get("bezeichnung", "") for e in akte.get("auszeichnungen", [])
+ if e.get("bezeichnung")]
+ unten_schrift = _schrift(UI, 21)
+ unten_breite = BREITE - 120
+ abstand = " "
+ if auszeichnungen:
+ z.text((60, 542), "AUSZEICHNUNGEN", font=_schrift(MONO_FETT, 17), fill=akzent)
+ # Nur ganze Eintraege, der Rest als Zahl - ein halber Orden liest sich schlecht
+ gezeigt, rest = [], len(auszeichnungen)
+ for name_a in auszeichnungen:
+ probe = gezeigt + ["■ " + name_a]
+ anhang = f"{abstand}+ {rest - 1} weitere" if rest > 1 else ""
+ if gezeigt and z.textlength(abstand.join(probe) + anhang,
+ font=unten_schrift) > unten_breite:
+ break
+ gezeigt, rest = probe, rest - 1
+ text = abstand.join(gezeigt) + (f"{abstand}+ {rest} weitere" if rest else "")
+ z.text((60, 568), _kuerzen(z, text, unten_schrift, unten_breite), font=unten_schrift,
+ fill=schrift_farbe)
+ elif akte.get("beschreibung", "").strip():
+ z.text((60, 542), "BESCHREIBUNG", font=_schrift(MONO_FETT, 17), fill=akzent)
+ zeile = _umbrechen(z, akte["beschreibung"].replace("\n", " "), unten_schrift,
+ unten_breite, 1)[0]
+ z.text((60, 568), zeile, font=unten_schrift, fill=schrift_farbe)
+
+ fuss = _schrift(MONO, 14)
+ z.text((60, HOEHE - 52), FUSSZEILE, font=fuss, fill=FG_DIM)
+ stand = _datum(akte.get("geaendert", ""))
+ if stand:
+ z.text((BREITE - 60, HOEHE - 52), f"STAND {stand}", font=fuss, fill=FG_DIM, anchor="ra")
+ return bild
+
+
+def dateiname(akte):
+ pers = akte.get("personalien", {})
+ name = pers.get("callsign") or pers.get("nachname") or "Akte"
+ name = re.sub(r"[^\w\-]+", "_", f"{name}_{akte.get('aktennummer', '')}").strip("_")
+ return f"{name}.png"
+
+
+def in_zwischenablage(bild):
+ """
+ Legt die Karte in die Windows-Zwischenablage.
+
+ Zweimal: als DIB, das jedes Programm versteht, und als PNG, das Discord
+ und Browser bevorzugen und das verlustfrei ankommt.
+ """
+ import ctypes
+ import ctypes.wintypes as wintypes
+ import time
+
+ user32 = ctypes.WinDLL("user32", use_last_error=True)
+ kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+ user32.OpenClipboard.argtypes = (wintypes.HWND,)
+ user32.OpenClipboard.restype = wintypes.BOOL
+ user32.EmptyClipboard.restype = wintypes.BOOL
+ user32.CloseClipboard.restype = wintypes.BOOL
+ user32.SetClipboardData.argtypes = (wintypes.UINT, wintypes.HANDLE)
+ user32.SetClipboardData.restype = wintypes.HANDLE
+ user32.RegisterClipboardFormatW.argtypes = (wintypes.LPCWSTR,)
+ user32.RegisterClipboardFormatW.restype = wintypes.UINT
+ kernel32.GlobalAlloc.argtypes = (wintypes.UINT, ctypes.c_size_t)
+ kernel32.GlobalAlloc.restype = wintypes.HGLOBAL
+ kernel32.GlobalLock.argtypes = (wintypes.HGLOBAL,)
+ kernel32.GlobalLock.restype = wintypes.LPVOID
+ kernel32.GlobalUnlock.argtypes = (wintypes.HGLOBAL,)
+ kernel32.GlobalFree.argtypes = (wintypes.HGLOBAL,)
+
+ bmp = io.BytesIO()
+ bild.convert("RGB").save(bmp, "BMP")
+ dib = bmp.getvalue()[14:] # ohne BITMAPFILEHEADER
+ png = io.BytesIO()
+ bild.save(png, "PNG")
+
+ def speicherblock(daten):
+ block = kernel32.GlobalAlloc(0x0002, len(daten)) # GMEM_MOVEABLE
+ if not block:
+ raise MemoryError("Kein Speicher für die Zwischenablage")
+ ctypes.memmove(kernel32.GlobalLock(block), daten, len(daten))
+ kernel32.GlobalUnlock(block)
+ return block
+
+ # Ein anderes Programm kann die Zwischenablage kurz belegt halten
+ for _ in range(20):
+ if user32.OpenClipboard(None):
+ break
+ time.sleep(0.05)
+ else:
+ raise OSError("Die Zwischenablage ist gerade von einem anderen Programm belegt.")
+ try:
+ user32.EmptyClipboard()
+ for format_nr, daten in ((8, dib), # CF_DIB
+ (user32.RegisterClipboardFormatW("PNG"), png.getvalue())):
+ block = speicherblock(daten)
+ if not user32.SetClipboardData(format_nr, block):
+ kernel32.GlobalFree(block)
+ raise OSError("Die Karte konnte nicht in die Zwischenablage gelegt werden.")
+ finally:
+ user32.CloseClipboard()
diff --git a/akte_modell.py b/akte_modell.py
new file mode 100644
index 0000000..33c3992
--- /dev/null
+++ b/akte_modell.py
@@ -0,0 +1,241 @@
+"""
+Datenmodell und Speicherung der Personalakten.
+
+Bewusst ohne tkinter: Laden, Speichern und spaetere Umbauten des Formats
+lassen sich so ohne Oberflaeche pruefen.
+
+Ablage je Akte:
+
+ %APPDATA%\\SquadManager\\akten\\\\akte.json
+ %APPDATA%\\SquadManager\\akten\\\\portraet.png
+
+Geschrieben wird atomar - erst in eine Zwischendatei, dann umbenennen -
+und die vorherige Fassung bleibt als akte.json.bak liegen. Ein Absturz
+mitten im Speichern kann eine Akte damit nicht zerstoeren.
+"""
+
+import copy
+import datetime
+import json
+import os
+import re
+import shutil
+import uuid
+from pathlib import Path
+
+SCHEMA = 1
+AKTEN_ORDNER = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "akten"
+PAPIERKORB = AKTEN_ORDNER / "_papierkorb"
+DATEI = "akte.json"
+PORTRAET = "portraet.png"
+PORTRAET_MAX = 512
+
+STATUS = ("aktiv", "verwundet", "vermisst", "gefallen", "außer Dienst")
+
+_VORLAGE = {
+ "schema": SCHEMA,
+ "id": "",
+ "aktennummer": "",
+ "erstellt": "",
+ "geaendert": "",
+ "personalien": {
+ "vorname": "", "nachname": "", "callsign": "",
+ "geburtsdatum": "", "herkunft": "",
+ },
+ "dienst": {
+ "fraktion": "", "teilstreitkraft": "",
+ "einheit": {"verband": "", "bataillon": "", "kompanie": "",
+ "zug": "", "gruppe": ""},
+ "rang": "", "verwendung": "", "dienstbeginn": "", "status": "aktiv",
+ },
+ "beschreibung": "",
+ "auszeichnungen": [],
+ "einsaetze": [],
+ "vermerke": "",
+}
+
+
+class AktenFehler(Exception):
+ """Fehler, die sich dem Nutzer verstaendlich melden lassen."""
+
+
+def zeitstempel():
+ return datetime.datetime.now().isoformat(timespec="seconds")
+
+
+def leere_akte():
+ akte = copy.deepcopy(_VORLAGE)
+ akte["id"] = uuid.uuid4().hex
+ akte["erstellt"] = akte["geaendert"] = zeitstempel()
+ return akte
+
+
+def _ergaenzen(daten, vorlage):
+ """Fehlende Felder aus der Vorlage nachtragen, vorhandene nie ueberschreiben."""
+ for schluessel, standard in vorlage.items():
+ if schluessel not in daten:
+ daten[schluessel] = copy.deepcopy(standard)
+ elif isinstance(standard, dict) and isinstance(daten[schluessel], dict):
+ _ergaenzen(daten[schluessel], standard)
+ return daten
+
+
+def migrieren(daten):
+ """
+ Bringt eine gelesene Akte auf den aktuellen Stand.
+
+ Bei neuen Schema-Versionen kommen die Umbauschritte hierher. Unbekannte
+ Felder bleiben erhalten, damit eine aeltere Programmfassung Daten einer
+ neueren nicht stillschweigend verliert.
+ """
+ if not isinstance(daten, dict):
+ raise AktenFehler("Die Datei enthaelt keine Akte.")
+ return _ergaenzen(daten, _VORLAGE)
+
+
+def ordner_von(akte_id):
+ if not re.fullmatch(r"[0-9a-f]{32}", str(akte_id)):
+ raise AktenFehler(f"Ungueltige Akten-ID: {akte_id!r}")
+ return AKTEN_ORDNER / akte_id
+
+
+def _alle_nummern():
+ nummern = []
+ for datei in list(AKTEN_ORDNER.glob(f"*/{DATEI}")) + list(PAPIERKORB.glob(f"*/{DATEI}")):
+ try:
+ nummern.append(json.loads(datei.read_text(encoding="utf-8")).get("aktennummer", ""))
+ except Exception:
+ continue
+ return nummern
+
+
+def naechste_aktennummer(jahr=None):
+ """SM--; auch Akten im Papierkorb zaehlen mit."""
+ jahr = jahr or datetime.date.today().year
+ hoechste = 0
+ for nummer in _alle_nummern():
+ treffer = re.fullmatch(rf"SM-{jahr}-(\d+)", str(nummer))
+ if treffer:
+ hoechste = max(hoechste, int(treffer.group(1)))
+ return f"SM-{jahr}-{hoechste + 1:04d}"
+
+
+def speichern(akte, zeit_setzen=True):
+ """
+ Schreibt die Akte atomar und haelt die vorige Fassung als .bak.
+
+ zeit_setzen=False nutzt der Abgleich, wenn er Daten vom Server
+ uebernimmt: Die Aenderungszeit bleibt dann die des Servers, sonst
+ saehe die Akte beim naechsten Abgleich wie lokal geaendert aus.
+ """
+ if zeit_setzen or not akte.get("geaendert"):
+ akte["geaendert"] = zeitstempel()
+ ordner = ordner_von(akte["id"])
+ ordner.mkdir(parents=True, exist_ok=True)
+ ziel = ordner / DATEI
+ zwischen = ordner / (DATEI + ".tmp")
+ zwischen.write_text(json.dumps(akte, indent=2, ensure_ascii=False),
+ encoding="utf-8")
+ if ziel.exists():
+ shutil.copy2(ziel, ordner / (DATEI + ".bak"))
+ os.replace(zwischen, ziel)
+ return akte
+
+
+def neu_anlegen():
+ akte = leere_akte()
+ akte["aktennummer"] = naechste_aktennummer()
+ return speichern(akte)
+
+
+def laden(akte_id):
+ """Liest eine Akte; ist die Datei beschaedigt, wird die Sicherung versucht."""
+ ordner = ordner_von(akte_id)
+ for datei in (ordner / DATEI, ordner / (DATEI + ".bak")):
+ if not datei.exists():
+ continue
+ try:
+ return migrieren(json.loads(datei.read_text(encoding="utf-8")))
+ except (ValueError, AktenFehler):
+ continue
+ raise AktenFehler(f"Akte {akte_id} ist nicht lesbar.")
+
+
+def alle_akten():
+ """Alle lesbaren Akten, nach Aktennummer sortiert. Defekte werden uebersprungen."""
+ if not AKTEN_ORDNER.is_dir():
+ return []
+ akten = []
+ for ordner in AKTEN_ORDNER.iterdir():
+ if not ordner.is_dir() or ordner.name.startswith("_"):
+ continue
+ try:
+ akten.append(laden(ordner.name))
+ except AktenFehler:
+ continue
+ return sorted(akten, key=lambda a: a.get("aktennummer", ""))
+
+
+def in_papierkorb(akte_id):
+ """Verschiebt statt zu loeschen - Wiederherstellen bleibt moeglich."""
+ quelle = ordner_von(akte_id)
+ if not quelle.is_dir():
+ return None
+ PAPIERKORB.mkdir(parents=True, exist_ok=True)
+ ziel = PAPIERKORB / f"{akte_id}_{datetime.datetime.now():%Y%m%d-%H%M%S}"
+ shutil.move(str(quelle), str(ziel))
+ return ziel
+
+
+def portraet_pfad(akte_id):
+ pfad = ordner_von(akte_id) / PORTRAET
+ return pfad if pfad.is_file() else None
+
+
+def portraet_setzen(akte_id, quelle):
+ """
+ Uebernimmt ein Bild als Portraet: Kopie, hoechstens 512 Bildpunkte je
+ Seite, als PNG. Die Akte haengt danach nicht mehr am Original.
+ """
+ from PIL import Image, ImageOps, UnidentifiedImageError
+
+ try:
+ with Image.open(quelle) as bild:
+ bild = ImageOps.exif_transpose(bild)
+ bild = bild.convert("RGBA" if bild.mode in ("RGBA", "LA", "P") else "RGB")
+ bild.thumbnail((PORTRAET_MAX, PORTRAET_MAX))
+ ordner = ordner_von(akte_id)
+ ordner.mkdir(parents=True, exist_ok=True)
+ zwischen = ordner / (PORTRAET + ".tmp")
+ bild.save(zwischen, "PNG")
+ os.replace(zwischen, ordner / PORTRAET)
+ except (UnidentifiedImageError, OSError) as fehler:
+ raise AktenFehler(f"Das Bild konnte nicht gelesen werden:\n{fehler}") from fehler
+ return ordner_von(akte_id) / PORTRAET
+
+
+def portraet_entfernen(akte_id):
+ pfad = portraet_pfad(akte_id)
+ if pfad:
+ pfad.unlink()
+
+
+def anzeigename(akte):
+ """Kurzname fuer Listen: Rang, Name und Callsign, soweit vorhanden."""
+ p, d = akte.get("personalien", {}), akte.get("dienst", {})
+ name = " ".join(t for t in (p.get("vorname", ""), p.get("nachname", "")) if t)
+ teile = [t for t in (d.get("rang", ""), name) if t]
+ text = " ".join(teile)
+ if p.get("callsign"):
+ text = f'{text} „{p["callsign"]}“' if text else f'„{p["callsign"]}“'
+ return text or "Neue Akte"
+
+
+def listenname(akte):
+ """Knapper Name fuer die schmale Aktenliste: Callsign vor Nachname."""
+ p = akte.get("personalien", {})
+ vorname, nachname = p.get("vorname", ""), p.get("nachname", "")
+ name = f"{nachname}, {vorname}" if nachname and vorname else nachname or vorname
+ if p.get("callsign"):
+ return f'{p["callsign"]} · {nachname or vorname}' if name else p["callsign"]
+ return name or "Neue Akte"
diff --git a/akte_vorlagen.py b/akte_vorlagen.py
new file mode 100644
index 0000000..6032609
--- /dev/null
+++ b/akte_vorlagen.py
@@ -0,0 +1,362 @@
+"""
+Auswahllisten fuer die Akte: Fraktionen, Teilstreitkraefte, Dienstgrade,
+Verwendungen.
+
+Aufbau: Fraktion -> ihre Teilstreitkraefte -> Dienstgrade je
+Teilstreitkraft. Eine Fraktion bietet nur an, was es bei ihr wirklich gibt:
+Island hat keine Luftwaffe, die Insurgents keine Marine. Die erste
+Teilstreitkraft einer Fraktion ist die Vorbelegung. Seit 1.5.1 sind die
+Felder reine Auswahllisten ohne Freitext.
+
+Dienstgrade jeweils vom niedrigsten zum hoechsten. Fremdsprachige Ranggruppen
+in gaengiger Umschrift, bei nicht-lateinischen Sprachen mit englischer
+Entsprechung in Klammern.
+
+Quellen (Stand September 2026): Wikipedia-Artikel der jeweiligen
+Streitkraefte, fuer die Bundeswehr "Dienstgrade der Bundeswehr", fuer
+Italien "Gradi e qualifiche dell'Esercito Italiano", fuer Island
+"Icelandic Coast Guard", fuer Schweden "Militära grader i Sverige", fuer
+Norwegen "Militære grader i Norge" (nach Forsvaret, Dezember 2023). Bei den Squad-Fraktionen widersprechen sich die
+Quellen; aufgenommen ist die Vereinigungsmenge, auch Fraktionen, deren
+aktueller Status unklar ist (Middle Eastern Alliance, Canadian Resistance
+Forces).
+"""
+
+VERWENDUNGEN = [
+ "Squad Leader", "Fireteam Leader", "Rifleman", "Medic",
+ "Automatic Rifleman", "Machine Gunner", "Grenadier", "Marksman", "Sniper",
+ "Light Anti-Tank (LAT)", "Heavy Anti-Tank (HAT)", "Combat Engineer",
+ "Sapper", "Crewman", "Pilot", "Scout", "Raider", "Ambusher", "Funker",
+]
+
+_INFORMELL = [
+ "Kämpfer", "Veteran", "Truppführer", "Gruppenführer", "Zellenführer",
+ "Stellvertretender Kommandeur", "Kommandeur",
+]
+
+_RUSSLAND = [
+ "Ryadovoy (Private)", "Yefreytor (Lance Corporal)",
+ "Mladshiy serzhant (Junior Sergeant)", "Serzhant (Sergeant)",
+ "Starshiy serzhant (Senior Sergeant)", "Starshina (Sergeant Major)",
+ "Praporshchik (Warrant Officer)", "Starshiy praporshchik (Senior Warrant Officer)",
+ "Mladshiy leytenant (Junior Lieutenant)", "Leytenant (Lieutenant)",
+ "Starshiy leytenant (Senior Lieutenant)", "Kapitan (Captain)", "Mayor (Major)",
+ "Podpolkovnik (Lieutenant Colonel)", "Polkovnik (Colonel)",
+ "General-mayor (Major General)", "General-leytenant (Lieutenant General)",
+ "General-polkovnik (Colonel General)", "General armii (General of the Army)",
+]
+
+_CHINA = [
+ "Liebing (Private)", "Shangdengbing (Private First Class)",
+ "Xiashi (Corporal)", "Zhongshi (Sergeant)", "Shangshi (Staff Sergeant)",
+ "Siji junshizhang (Master Sergeant 4th Class)",
+ "Sanji junshizhang (Master Sergeant 3rd Class)",
+ "Erji junshizhang (Master Sergeant 2nd Class)",
+ "Yiji junshizhang (Master Sergeant 1st Class)",
+ "Shaowei (Second Lieutenant)", "Zhongwei (First Lieutenant)",
+ "Shangwei (Captain)", "Shaoxiao (Major)", "Zhongxiao (Lieutenant Colonel)",
+ "Shangxiao (Colonel)", "Daxiao (Senior Colonel)",
+ "Shaojiang (Major General)", "Zhongjiang (Lieutenant General)",
+ "Shangjiang (General)",
+]
+
+
+def _bundeswehr(unterste):
+ """Heer und Luftwaffe: gleiche Dienstgrade bis auf den untersten."""
+ return [
+ unterste, "Gefreiter", "Obergefreiter", "Hauptgefreiter",
+ "Stabsgefreiter", "Oberstabsgefreiter", "Korporal", "Stabskorporal",
+ "Unteroffizier", "Fahnenjunker", "Stabsunteroffizier", "Feldwebel",
+ "Fähnrich", "Oberfeldwebel", "Hauptfeldwebel", "Oberfähnrich",
+ "Stabsfeldwebel", "Oberstabsfeldwebel", "Leutnant", "Oberleutnant",
+ "Hauptmann", "Stabshauptmann", "Major", "Oberstleutnant", "Oberst",
+ "Brigadegeneral", "Generalmajor", "Generalleutnant", "General",
+ ]
+
+
+_BUNDESWEHR_MARINE = [
+ "Matrose", "Gefreiter", "Obergefreiter", "Hauptgefreiter",
+ "Stabsgefreiter", "Oberstabsgefreiter", "Korporal", "Stabskorporal",
+ "Maat", "Seekadett", "Obermaat", "Bootsmann", "Fähnrich zur See",
+ "Oberbootsmann", "Hauptbootsmann", "Oberfähnrich zur See",
+ "Stabsbootsmann", "Oberstabsbootsmann", "Leutnant zur See",
+ "Oberleutnant zur See", "Kapitänleutnant", "Stabskapitänleutnant",
+ "Korvettenkapitän", "Fregattenkapitän", "Kapitän zur See",
+ "Flottillenadmiral", "Konteradmiral", "Vizeadmiral", "Admiral",
+]
+
+
+_SCHWEDEN_OFFIZIERE = [
+ "Fänrik", "Löjtnant", "Kapten", "Major", "Överstelöjtnant", "Överste",
+ "Brigadgeneral", "Generalmajor", "Generallöjtnant", "General",
+]
+_SCHWEDEN_MARINEOFFIZIERE = [
+ "Fänrik", "Löjtnant", "Kapten", "Örlogskapten", "Kommendörkapten",
+ "Kommendör", "Flottiljamiral", "Konteramiral", "Viceamiral", "Amiral",
+]
+
+
+def _schweden(hoechster_specialist, offiziere):
+ """Mannschaften und Specialistofficerare sind in allen Teilen gleich bis auf OR-9."""
+ return [
+ "Menig", "Vicekorporal", "Korporal", "Furir", "Överfurir",
+ "Sergeant", "Översergeant", "Fanjunkare", "Överfanjunkare", "Förvaltare",
+ hoechster_specialist, *offiziere,
+ ]
+
+
+_NORWEGEN_OFFIZIERE = [
+ "Fenrik", "Løytnant", "Kaptein", "Major", "Oberstløytnant", "Oberst",
+ "Brigader", "Generalmajor", "Generalløytnant", "General",
+]
+
+
+def _island(*fachtitel):
+ """
+ Die Kuestenwache (Landhelgisgaeslan) fuehrt keine klassischen
+ Dienstgrade, sondern Besoldungsstufen, die in allen Bereichen gelten, und
+ Funktionstitel je Bereich. Deutsch in Klammern ist die woertliche
+ Uebersetzung.
+ """
+ return [
+ "Undirmaður AS-1 (Mannschaft, Einstieg)", "Undirmaður AS-2 (Mannschaft)",
+ "Undirmaður AS-3 (Mannschaft)", "Undirmaður AS-4 (Mannschaft)",
+ "Millistjórnandi MS-1 (Führungskraft / Spezialist)",
+ "Millistjórnandi MS-2 (Führungskraft / Spezialist)",
+ "Millistjórnandi MS-3 (Führungskraft / Spezialist)",
+ "Byrjandi í yfirmannastöðu (Offizier, Einstieg)", "Yfirmaður (Offizier)",
+ *fachtitel,
+ "Deildarstjóri (Abteilungsleiter)",
+ "Forstjóri Landhelgisgæslunnar (Direktor)",
+ ]
+
+
+FRAKTIONEN = {
+ # --- Squad: BLUFOR ---------------------------------------------------
+ "US Army": {"gruppe": "Squad", "teilstreitkraefte": {"Heer": [
+ "Private (PV1)", "Private (PV2)", "Private First Class (PFC)",
+ "Specialist (SPC)", "Corporal (CPL)", "Sergeant (SGT)",
+ "Staff Sergeant (SSG)", "Sergeant First Class (SFC)",
+ "Master Sergeant (MSG)", "First Sergeant (1SG)", "Sergeant Major (SGM)",
+ "Command Sergeant Major (CSM)", "Warrant Officer 1 (WO1)",
+ "Chief Warrant Officer 2 (CW2)", "Chief Warrant Officer 3 (CW3)",
+ "Chief Warrant Officer 4 (CW4)", "Chief Warrant Officer 5 (CW5)",
+ "Second Lieutenant (2LT)", "First Lieutenant (1LT)", "Captain (CPT)",
+ "Major (MAJ)", "Lieutenant Colonel (LTC)", "Colonel (COL)",
+ "Brigadier General (BG)", "Major General (MG)",
+ "Lieutenant General (LTG)", "General (GEN)"]}},
+ "US Marine Corps": {"gruppe": "Squad", "teilstreitkraefte": {"Marineinfanterie": [
+ "Private (Pvt)", "Private First Class (PFC)", "Lance Corporal (LCpl)",
+ "Corporal (Cpl)", "Sergeant (Sgt)", "Staff Sergeant (SSgt)",
+ "Gunnery Sergeant (GySgt)", "Master Sergeant (MSgt)",
+ "First Sergeant (1stSgt)", "Master Gunnery Sergeant (MGySgt)",
+ "Sergeant Major (SgtMaj)", "Warrant Officer (WO)",
+ "Chief Warrant Officer 2 (CWO2)", "Chief Warrant Officer 3 (CWO3)",
+ "Chief Warrant Officer 4 (CWO4)", "Chief Warrant Officer 5 (CWO5)",
+ "Second Lieutenant (2ndLt)", "First Lieutenant (1stLt)",
+ "Captain (Capt)", "Major (Maj)", "Lieutenant Colonel (LtCol)",
+ "Colonel (Col)", "Brigadier General (BGen)", "Major General (MajGen)",
+ "Lieutenant General (LtGen)", "General (Gen)"]}},
+ "British Army": {"gruppe": "Squad", "teilstreitkraefte": {"Heer": [
+ "Private (Pte)", "Lance Corporal (LCpl)", "Corporal (Cpl)",
+ "Sergeant (Sgt)", "Staff Sergeant (SSgt)", "Colour Sergeant (CSgt)",
+ "Warrant Officer Class 2 (WO2)", "Warrant Officer Class 1 (WO1)",
+ "Officer Cadet (OCdt)", "Second Lieutenant (2Lt)", "Lieutenant (Lt)",
+ "Captain (Capt)", "Major (Maj)", "Lieutenant Colonel (Lt Col)",
+ "Colonel (Col)", "Brigadier (Brig)", "Major General (Maj Gen)",
+ "Lieutenant General (Lt Gen)", "General (Gen)"]}},
+ "Canadian Army": {"gruppe": "Squad", "teilstreitkraefte": {"Heer": [
+ "Private (Pte)", "Corporal (Cpl)", "Master Corporal (MCpl)",
+ "Sergeant (Sgt)", "Warrant Officer (WO)",
+ "Master Warrant Officer (MWO)", "Chief Warrant Officer (CWO)",
+ "Officer Cadet (OCdt)", "Second Lieutenant (2Lt)", "Lieutenant (Lt)",
+ "Captain (Capt)", "Major (Maj)", "Lieutenant-Colonel (LCol)",
+ "Colonel (Col)", "Brigadier-General (BGen)", "Major-General (MGen)",
+ "Lieutenant-General (LGen)", "General (Gen)"]}},
+ "Australian Army": {"gruppe": "Squad", "teilstreitkraefte": {"Heer": [
+ "Private (PTE)", "Lance Corporal (LCPL)", "Corporal (CPL)",
+ "Sergeant (SGT)", "Staff Sergeant (SSGT)",
+ "Warrant Officer Class 2 (WO2)", "Warrant Officer Class 1 (WO1)",
+ "Officer Cadet (OCDT)", "Second Lieutenant (2LT)", "Lieutenant (LT)",
+ "Captain (CAPT)", "Major (MAJ)", "Lieutenant Colonel (LTCOL)",
+ "Colonel (COL)", "Brigadier (BRIG)", "Major General (MAJGEN)",
+ "Lieutenant General (LTGEN)", "General (GEN)"]}},
+ "Armed Forces of Ukraine": {"gruppe": "Squad", "teilstreitkraefte": {"Heer": [
+ "Soldat (Private)", "Starshyi soldat (Senior Soldier)",
+ "Molodshyi serzhant (Junior Sergeant)", "Serzhant (Sergeant)",
+ "Starshyi serzhant (Senior Sergeant)", "Holovnyi serzhant (Chief Sergeant)",
+ "Shtab-serzhant (Staff Sergeant)", "Maister-serzhant (Master Sergeant)",
+ "Starshyi maister-serzhant (Senior Master Sergeant)",
+ "Holovnyi maister-serzhant (Chief Master Sergeant)",
+ "Molodshyi leitenant (Junior Lieutenant)", "Leitenant (Lieutenant)",
+ "Starshyi leitenant (Senior Lieutenant)", "Kapitan (Captain)",
+ "Maior (Major)", "Pidpolkovnyk (Lieutenant Colonel)",
+ "Polkovnyk (Colonel)", "Bryhadnyi heneral (Brigadier General)",
+ "Heneral-maior (Major General)", "Heneral-leitenant (Lieutenant General)",
+ "Heneral (General)"]}},
+ # --- Squad: REDFOR ---------------------------------------------------
+ "Russian Ground Forces": {"gruppe": "Squad",
+ "teilstreitkraefte": {"Heer": _RUSSLAND}},
+ "Russian Airborne Forces (VDV)": {"gruppe": "Squad",
+ "teilstreitkraefte": {"Luftlandetruppe": _RUSSLAND}},
+ "People's Liberation Army": {"gruppe": "Squad",
+ "teilstreitkraefte": {"Heer": _CHINA}},
+ "PLA Navy Marine Corps": {"gruppe": "Squad",
+ "teilstreitkraefte": {"Marineinfanterie": _CHINA}},
+ # --- Squad: INDFOR ---------------------------------------------------
+ "Insurgents": {"gruppe": "Squad", "teilstreitkraefte": {"Miliz": _INFORMELL}},
+ "Irregular Militia": {"gruppe": "Squad", "teilstreitkraefte": {"Miliz": _INFORMELL}},
+ "Ground Forces of Iran": {"gruppe": "Squad", "teilstreitkraefte": {"Heer": [
+ "Sarbaz dovvom (Private 2nd Class)", "Sarbaz yekom (Private 1st Class)",
+ "Sarjukheh (Corporal)", "Gorouhban sevvom (Sergeant 3rd Class)",
+ "Gorouhban dovvom (Sergeant 2nd Class)", "Gorouhban yekom (Sergeant 1st Class)",
+ "Ostovar dovvom (Warrant Officer 2nd Class)",
+ "Ostovar yekom (Warrant Officer 1st Class)",
+ "Setvan sevvom (Third Lieutenant)", "Setvan dovvom (Second Lieutenant)",
+ "Setvan yekom (First Lieutenant)", "Sarvan (Captain)", "Sargord (Major)",
+ "Sarhang dovvom (Lieutenant Colonel)", "Sarhang (Colonel)",
+ "Sartip dovvom (Second Brigadier General)", "Sartip (Brigadier General)",
+ "Sarlashkar (Major General)", "Sepahbod (Lieutenant General)",
+ "Arteshbod (General)"]}},
+ "Turkish Land Forces": {"gruppe": "Squad", "teilstreitkraefte": {"Heer": [
+ "Er", "Onbaşı", "Çavuş", "Uzman Çavuş", "Astsubay Çavuş",
+ "Astsubay Kıdemli Çavuş", "Astsubay Üstçavuş",
+ "Astsubay Kıdemli Üstçavuş", "Astsubay Başçavuş",
+ "Astsubay Kıdemli Başçavuş", "Asteğmen", "Teğmen", "Üsteğmen",
+ "Yüzbaşı", "Binbaşı", "Yarbay", "Albay", "Tuğgeneral", "Tümgeneral",
+ "Korgeneral", "Orgeneral"]}},
+ "Private Military Contractor": {"gruppe": "Squad", "teilstreitkraefte": {
+ "Private Sicherheitsfirma": [
+ "Contractor", "Senior Contractor", "Deputy Team Leader", "Team Leader",
+ "Shift Leader", "Operations Manager", "Country Manager"]}},
+ "Middle Eastern Alliance": {"gruppe": "Squad", "teilstreitkraefte": {"Heer": [
+ "Jundi (Private)", "Jundi awwal (Private First Class)", "Areef (Corporal)",
+ "Raqib (Sergeant)", "Raqib awwal (Staff Sergeant)",
+ "Musa'id (Warrant Officer)", "Musa'id awwal (Chief Warrant Officer)",
+ "Mulazim (Second Lieutenant)", "Mulazim awwal (First Lieutenant)",
+ "Naqib (Captain)", "Ra'id (Major)", "Muqaddam (Lieutenant Colonel)",
+ "Aqid (Colonel)", "Amid (Brigadier General)", "Liwa (Major General)",
+ "Fariq (Lieutenant General)", "Fariq awwal (General)"]}},
+ "Canadian Resistance Forces": {"gruppe": "Squad",
+ "teilstreitkraefte": {"Miliz": _INFORMELL}},
+ # --- Weitere Armeen ---------------------------------------------------
+ "Bundeswehr": {"gruppe": "Weitere", "teilstreitkraefte": {
+ # Die unterste Stufe heisst im Heer je nach Truppe unterschiedlich
+ "Heer": _bundeswehr("Jäger / Grenadier / Schütze"),
+ "Luftwaffe": _bundeswehr("Flieger"),
+ "Marine": _BUNDESWEHR_MARINE}},
+ "Frankreich – Armée de Terre": {"gruppe": "Weitere", "teilstreitkraefte": {"Heer": [
+ "Soldat de 2e classe", "Soldat de 1re classe", "Caporal", "Caporal-chef",
+ "Caporal-chef de 1re classe", "Sergent", "Sergent-chef", "Adjudant",
+ "Adjudant-chef", "Major", "Aspirant", "Sous-lieutenant", "Lieutenant",
+ "Capitaine", "Commandant", "Lieutenant-colonel", "Colonel",
+ "Général de brigade", "Général de division", "Général de corps d'armée",
+ "Général d'armée"]}},
+ "Spanien – Ejército de Tierra": {"gruppe": "Weitere", "teilstreitkraefte": {"Heer": [
+ "Soldado", "Cabo", "Cabo primero", "Cabo mayor", "Sargento",
+ "Sargento primero", "Brigada", "Subteniente", "Suboficial mayor",
+ "Alférez", "Teniente", "Capitán", "Comandante", "Teniente coronel",
+ "Coronel", "General de brigada", "General de división",
+ "Teniente general", "General de ejército"]}},
+ "Italien – Esercito Italiano": {"gruppe": "Weitere", "teilstreitkraefte": {"Heer": [
+ "Soldato", "Caporale", "Caporal maggiore", "Graduato", "Graduato scelto",
+ "Graduato capo", "Primo graduato", "Graduato aiutante", "Sergente",
+ "Sergente maggiore", "Sergente maggiore capo", "Sergente maggiore aiutante",
+ "Maresciallo", "Maresciallo ordinario", "Maresciallo capo",
+ "Primo maresciallo", "Luogotenente", "Primo luogotenente",
+ "Sottotenente", "Tenente", "Capitano", "Maggiore", "Tenente colonnello",
+ "Colonnello", "Generale di brigata", "Generale di divisione",
+ "Generale di corpo d'armata", "Generale"]}},
+ # Schwedische Gradtabelle seit 2019. "Menig 1-4" sind Gehaltsstufen,
+ # keine Dienstgrade, und fehlen deshalb.
+ "Schweden – Försvarsmakten": {"gruppe": "Weitere", "teilstreitkraefte": {
+ "Heer (Armén)": _schweden("Regementsförvaltare", _SCHWEDEN_OFFIZIERE),
+ "Luftwaffe (Flygvapnet)": _schweden("Regementsförvaltare", _SCHWEDEN_OFFIZIERE),
+ "Marine (Marinen)": _schweden("Flottiljförvaltare", _SCHWEDEN_MARINEOFFIZIERE),
+ "Amphibienkorps (Amfibiekåren)": _schweden("Flottiljförvaltare",
+ _SCHWEDEN_MARINEOFFIZIERE),
+ }},
+ # Norwegische Gradtabelle nach Forsvaret, "Forsvarets distinksjoner"
+ # (Dezember 2023). Jede Teilstreitkraft hat eigene Mannschafts- und
+ # Unteroffiziersgrade.
+ "Norwegen – Forsvaret": {"gruppe": "Weitere", "teilstreitkraefte": {
+ "Heer (Hæren)": [
+ "Menig", "Ledende menig", "Visekorporal", "Visekorporal 1. klasse",
+ "Korporal", "Sersjant", "Sersjant klasse 1", "Oversersjant",
+ "Stabssersjant", "Kommandérsersjant", "Sersjantmajor",
+ *_NORWEGEN_OFFIZIERE[:2], "Kaptein / Rittmester", *_NORWEGEN_OFFIZIERE[3:]],
+ "Luftwaffe (Luftforsvaret)": [
+ "Flysoldat", "Ledende flysoldat", "Visespesialist", "Spesialist",
+ "Ledende spesialist", "Sersjant", "Vingsersjant", "Oversersjant",
+ "Stabssersjant", "Kommandérsersjant", "Sersjantmajor",
+ *_NORWEGEN_OFFIZIERE],
+ "Marine (Sjøforsvaret)": [
+ "Menig", "Ledende menig", "Visekonstabel", "Ledende visekonstabel",
+ "Konstabel", "Kvartermester", "Senior kvartermester", "Skvadronmester",
+ "Flotiljemester", "Orlogsmester", "Flaggmester",
+ "Fenrik", "Løytnant", "Kapteinløytnant", "Orlogskaptein",
+ "Kommandørkaptein", "Kommandør", "Flaggkommandør", "Kontreadmiral",
+ "Viseadmiral", "Admiral"],
+ }},
+ # Island hat keine Armee, nur die Kuestenwache mit vier Bereichen
+ "Island – Küstenwache": {"gruppe": "Weitere", "teilstreitkraefte": {
+ "Seebereich (Siglingasvið)": _island(
+ "Vélstjóri (Maschinist)", "Stýrimaður (Steuermann)",
+ "Yfirvélstjóri (Leitender Maschinist)",
+ "Yfirstýrimaður (Erster Steuermann)", "Næstráðandi (Stellvertreter)",
+ "Skipherra (Kommandant)", "Flaggskipherra (Flaggkommandant)",
+ "Framkvæmdastjóri siglingasviðs (Leiter Seebereich)"),
+ "Luftfahrt (Flugsvið)": _island(
+ "Flugmaður (Pilot)", "Flugstjóri (Flugkapitän)",
+ "Yfirflugstjóri (Chefpilot)", "Tæknistjóri (Technischer Leiter)",
+ "Flugrekstrarstjóri (Leiter Luftfahrt)"),
+ "Einsatzführung (Aðgerðasvið)": _island(
+ "Framkvæmdastjóri aðgerðasviðs (Leiter Einsatzführung)"),
+ "Verteidigung und Radar (Varnarmálasvið)": _island(
+ "Framkvæmdastjóri varnarmálasviðs (Leiter Verteidigung)"),
+ }},
+}
+
+
+def fraktionsnamen():
+ return list(FRAKTIONEN)
+
+
+def teilstreitkraefte_fuer(fraktion):
+ return list(FRAKTIONEN.get(fraktion, {}).get("teilstreitkraefte", {}))
+
+
+def standard_teilstreitkraft(fraktion):
+ namen = teilstreitkraefte_fuer(fraktion)
+ return namen[0] if namen else ""
+
+
+def raenge_fuer(fraktion, teilstreitkraft):
+ tsk = FRAKTIONEN.get(fraktion, {}).get("teilstreitkraefte", {})
+ return list(tsk.get(teilstreitkraft, []))
+
+
+def pruefen(dienst):
+ """
+ Hinweise zu Werten, die nicht zur Auswahl passen.
+
+ Akten aus der Zeit mit Freitext koennen solche Werte enthalten. Sie
+ werden nicht still geaendert - der Nutzer soll sehen, was nicht mehr
+ passt, und selbst neu waehlen.
+ """
+ fraktion = dienst.get("fraktion", "")
+ tsk = dienst.get("teilstreitkraft", "")
+ rang = dienst.get("rang", "")
+ verwendung = dienst.get("verwendung", "")
+ hinweise = []
+ if fraktion and fraktion not in FRAKTIONEN:
+ hinweise.append(f"Fraktion „{fraktion}“ steht nicht in der Liste.")
+ elif fraktion:
+ if tsk and tsk not in teilstreitkraefte_fuer(fraktion):
+ hinweise.append(f"Teilstreitkraft „{tsk}“ gibt es bei {fraktion} nicht.")
+ elif rang and rang not in raenge_fuer(fraktion, tsk):
+ wo = f"{fraktion} · {tsk}" if tsk else fraktion
+ hinweise.append(f"Dienstgrad „{rang}“ gibt es bei {wo} nicht.")
+ if verwendung and verwendung not in VERWENDUNGEN:
+ hinweise.append(f"Verwendung „{verwendung}“ steht nicht in der Liste.")
+ return hinweise
diff --git a/hintergrund.py b/hintergrund.py
new file mode 100644
index 0000000..53e26ed
--- /dev/null
+++ b/hintergrund.py
@@ -0,0 +1,46 @@
+"""
+Arbeit im Hintergrund, Ergebnis im Hauptthread von tkinter.
+
+Netzwerkaufrufe duerfen die Oberflaeche nicht einfrieren, und tkinter
+darf nur aus dem Hauptthread angefasst werden. Die Arbeit laeuft deshalb
+in einem Thread, das Ergebnis landet in einer Warteschlange, die der
+Hauptthread regelmaessig leert und an die Rueckrufe verteilt.
+"""
+
+import queue
+import threading
+import tkinter as tk
+
+
+class Hintergrund:
+ def __init__(self, widget, takt_ms=60):
+ self.widget = widget
+ self.takt_ms = takt_ms
+ self._warteschlange = queue.Queue()
+ self._pollen()
+
+ def starten(self, arbeit, fertig=None, fehler=None):
+ """arbeit() im Thread; danach fertig(ergebnis) oder fehler(ausnahme) im Hauptthread."""
+ def lauf():
+ try:
+ ergebnis = arbeit()
+ except Exception as ausnahme: # noqa: BLE001 - wird im Hauptthread gemeldet
+ self._warteschlange.put((fehler, ausnahme, True))
+ else:
+ self._warteschlange.put((fertig, ergebnis, False))
+ threading.Thread(target=lauf, daemon=True).start()
+
+ def _pollen(self):
+ try:
+ while True:
+ rueckruf, wert, ist_fehler = self._warteschlange.get_nowait()
+ if rueckruf is not None:
+ rueckruf(wert)
+ elif ist_fehler:
+ self.widget.report_callback_exception(type(wert), wert, wert.__traceback__)
+ except queue.Empty:
+ pass
+ try:
+ self.widget.after(self.takt_ms, self._pollen)
+ except tk.TclError:
+ pass # Fenster geschlossen
diff --git a/installer/DATENSCHUTZ-BAUSTEIN.md b/installer/DATENSCHUTZ-BAUSTEIN.md
new file mode 100644
index 0000000..e2e63a0
--- /dev/null
+++ b/installer/DATENSCHUTZ-BAUSTEIN.md
@@ -0,0 +1,80 @@
+# 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 im Programm „Mitmachen" wählt, legt einen
+Spielernamen fest; die Personalakten seiner Rollenspiel-Charaktere werden
+dann auf dem Server gespeichert, und er kann mit anderen Squads bilden.
+Ein Konto mit E-Mail-Adresse ist dafür nicht nötig, lässt sich aber
+freiwillig anlegen („Konto sichern"). Wer nicht mitmacht, überträgt keine
+Daten an uns; das Programm prüft dann lediglich beim Start, ob eine neue
+Version vorliegt.
+
+**Verantwortlicher:** [wie im Impressum]
+
+### Welche Daten wir verarbeiten
+
+- **Beim Mitmachen:** der gewählte Spielername und der Zeitpunkt.
+- **Nur bei gesichertem Konto:** E-Mail-Adresse und Passwort – dieses nur
+ als nicht umkehrbarer Hash –, dazu Zeitpunkt der E-Mail-Bestätigung und
+ der letzten Anmeldung.
+- **Schlüssel und Anmeldung:** Beim Mitmachen oder Anmelden erzeugen wir
+ ein zufälliges Token, das dein PC als Schlüssel aufbewahrt. Auf unserem
+ Server liegt davon nur ein Prüfwert, zusammen mit dem Rechnernamen, den
+ das Programm übermittelt, damit sich PCs 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 **Spielername** sind für alle
+Nutzer des Squad Managers sichtbar, die ebenfalls mitmachen – 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 – auch dann,
+wenn der Schlüssel auf deinem PC verloren geht und du kein gesichertes
+Konto hast. In dem Fall löschen wir die Charaktere auf Anfrage. Du kannst
+dein Konto jederzeit selbst im Programm löschen (Reiter SQUAD → Konto →
+Konto löschen). Dabei werden das Konto, alle Charaktere, Porträts und
+Sitzungen auf dem Server gelöscht. Führt einer deiner Charaktere ein
+Squad, geht die Führung an ein anderes Mitglied über. Kopien deiner
+Akten auf deinem eigenen PC bleiben davon unberührt.
+
+### Deine Rechte
+
+Du hast das Recht auf Auskunft, Berichtigung, Löschung, Einschränkung der
+Verarbeitung, Datenübertragbarkeit und Widerspruch sowie auf Beschwerde
+bei einer Datenschutz-Aufsichtsbehörde. Wende dich dazu an
+[info@tyrveil.com].
diff --git a/installer/HOCHLADEN.txt b/installer/HOCHLADEN.txt
index 1c9b779..dd8d2ab 100644
--- a/installer/HOCHLADEN.txt
+++ b/installer/HOCHLADEN.txt
@@ -1,48 +1,98 @@
================================================================
- Was auf sva.tyrveil.com muss
+ Was auf sva.tyrveil.com muss - Version __VERSION__
================================================================
-Lade diese drei Dateien in das Wurzelverzeichnis der Subdomain:
+Lade den Inhalt dieses Ordners in das Wurzelverzeichnis der Subdomain,
+außer dieser Anleitung selbst:
- version.json
- SquadManager-3.3.zip
- SquadManager-Setup-3.3.exe
+ SquadManager-__VERSION__.zip
+ SquadManager-Setup-__VERSION__.exe
+ icon.png
+ 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. Braucht die neue Fassung eine
+geänderte Datenbank, passt der Server sie bei der ersten Anfrage selbst
+an - ohne einrichten.php.
+
+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.
Danach müssen diese Adressen erreichbar sein:
+ https://sva.tyrveil.com/
https://sva.tyrveil.com/version.json
- https://sva.tyrveil.com/SquadManager-3.3.zip
- https://sva.tyrveil.com/SquadManager-Setup-3.3.exe
+ https://sva.tyrveil.com/SquadManager-__VERSION__.zip
+ https://sva.tyrveil.com/SquadManager-Setup-__VERSION__.exe
ALTE DATEIEN ENTFERNEN
----------------------
-Nach dem Hochladen die Dateien früherer Fassungen vom Server löschen,
-zurzeit:
+Nach dem Hochladen die Zip- und Setup-Dateien früherer Fassungen vom
+Server löschen, also alle SquadManager-*.zip und SquadManager-Setup-*.exe
+mit einer anderen Nummer als __VERSION__, und falls noch vorhanden:
SquadVoiceActivation-3.2.zip
SquadVoiceActivation-Setup-3.2.exe
-Solange sie online liegen, kann jemand mit der alten Fassung anfangen.
+Solange sie online liegen, kann jemand mit einer alten Fassung anfangen.
+
+
+KONTEN UND SQUADS: EINMALIG EINRICHTEN
+--------------------------------------
+Seit 1.6.0 gibt es Konten, Akten auf dem Server und Squads. Dafür liegt
+neben diesem Ordner zusätzlich dist\sva-privat. Einmalig:
+
+1. Den Ordner sva-privat in das Hauptverzeichnis des Webspace laden,
+ NEBEN den Ordner sva.tyrveil.com - nicht hinein. Im Plesk-Dateimanager
+ ist das die Ebene, auf der auch sva.tyrveil.com und httpdocs liegen.
+ Dort ist er aus dem Internet nicht erreichbar.
+
+2. In sva-privat die Datei config.beispiel.php kopieren und die Kopie
+ config.php nennen. Darin eintragen:
+ 'passwort' das Datenbank-Passwort aus Plesk
+ 'einrichtungs_schluessel' eine lange Zufallszeichenkette,
+ mindestens 24 Zeichen
+
+3. Den Inhalt von dist\server wie oben nach sva.tyrveil.com laden. Neu
+ dabei sind die Ordner api, konto, verwaltung und einrichten.php.
+
+4. https://sva.tyrveil.com/einrichten.php öffnen und den Schlüssel
+ eingeben. Die Seite prüft PHP, legt die Tabellen an und schickt an
+ info@tyrveil.com einen Link, mit dem du das Passwort für die
+ Verwaltung festlegst.
+
+5. In config.php den einrichtungs_schluessel wieder leeren: ''
+ Damit ist einrichten.php abgeschaltet.
+
+6. Die Verwaltung liegt unter https://sva.tyrveil.com/verwaltung/
+
+Zeigt einrichten.php "config.php fehlt", obwohl sie oben liegt: In Plesk
+unter PHP-Einstellungen muss open_basedir das Hauptverzeichnis des
+Webspace erlauben. Die Voreinstellung {WEBSPACEROOT}{/}{:}{TMP}{/} tut das.
+
+Bei späteren Updates nur sva-privat\app ersetzen. config.php und den
+Ordner daten (Porträts) nie überschreiben oder löschen.
ZUM VERTEILEN
-------------
-Deinen Freunden gibst du nur diesen einen Link:
+Deinen Freunden gibst du nur noch diesen Link. Er ändert sich nie:
- https://sva.tyrveil.com/SquadManager-Setup-3.3.exe
+ https://sva.tyrveil.com
-Beim ersten Start meldet sich Windows mit "Der Computer wurde durch
-Windows geschützt". Das liegt daran, dass die Datei nicht signiert ist,
-nicht an einem Fehler. Der Weg: Weitere Informationen -> Trotzdem
-ausführen. Sag das am besten gleich dazu.
+Die Seite liest beim Öffnen version.json und bietet immer den neuesten
+Installer an. Sie erklärt auch die Windows-Warnung beim ersten Start
+("Der Computer wurde durch Windows geschützt" -> Weitere Informationen
+-> Trotzdem ausführen).
NGINX
-----
-Meist genügt die vorhandene Konfiguration. Falls der Download der ZIP
-im Browser geöffnet statt gespeichert wird, hilft dieser Zusatz im
-server-Block:
+Meist genügt die vorhandene Konfiguration. Hilfreich im server-Block:
location ~* \.(zip|exe)$ {
add_header Content-Disposition "attachment";
@@ -53,10 +103,19 @@ server-Block:
default_type application/json;
}
-Die Zeile zu version.json ist die wichtigere: Ohne sie kann ein
+ location = /index.html {
+ add_header Cache-Control "no-cache";
+ }
+
+Die Zeile zu version.json ist die wichtigste: Ohne sie kann ein
zwischengeschalteter Zwischenspeicher noch die alte Versionsnummer
ausliefern, nachdem du längst eine neue hochgeladen hast.
+Zeigt https://sva.tyrveil.com/ trotz hochgeladener index.html weiter
+"403 Forbidden", fehlt im server-Block die Zeile
+
+ index index.html;
+
WIE DAS UPDATE FUNKTIONIERT
---------------------------
@@ -65,25 +124,32 @@ Versionsnummer als die installierte, erscheint unten im Fenster ein
Hinweisbalken mit einer Schaltfläche. Ein Klick lädt die ZIP, prüft die
Prüfsumme, ersetzt die Programmdateien und startet neu.
-Ist der Server nicht erreichbar, passiert schlicht nichts — das
+Ist der Server nicht erreichbar, passiert schlicht nichts - das
Programm läuft dann ganz normal ohne Hinweis weiter.
NEUE VERSION VERÖFFENTLICHEN
----------------------------
-1. In squad_manager.py die Zeile VERSION anpassen
+1. In squad_manager.py VERSION anpassen und BUILD um eins erhöhen.
+ Der Bau vergleicht BUILD mit dem Server und warnt, wenn es nicht
+ höher ist - dann bekäme niemand das Update.
2. Im Quellordner ausführen:
.venv\Scripts\python.exe werkzeuge\baue_release.py
-3. Den Inhalt von dist\server\ hochladen
+3. Den Inhalt von dist\server\ hochladen, wie oben beschrieben
Der Bauvorgang berechnet die Prüfsumme selbst und trägt sie in
version.json ein. Diese Datei niemals von Hand bearbeiten: Stimmt die
Prüfsumme nicht mit der ZIP überein, verweigert das Programm das
Update - genau so ist es gedacht.
-Das Feld "hinweis" darfst du füllen, es erscheint im Hinweisbalken:
+In version.json steht "version" immer auf 4.1, die echte Nummer unter
+"anzeige". Das ist Absicht: Programme bis 4.0 lesen nur "version" und
+bekommen so das Update auf die neue Zählung ab 1.5.0.
+
+Das Feld "hinweis" darfst du füllen, es erscheint im Hinweisbalken des
+Programms und auf der Downloadseite:
"hinweis": "Mikrofonliste aufgeräumt"
diff --git a/installer/downloadseite.html b/installer/downloadseite.html
new file mode 100644
index 0000000..be83d9d
--- /dev/null
+++ b/installer/downloadseite.html
@@ -0,0 +1,200 @@
+
+
+
+
+
+Squad Manager – Download
+
+
+
+
+
+
+
+
+
+
+
+
+
';
+};
+
+$pruefen('PHP ' . PHP_VERSION, version_compare(PHP_VERSION, '8.1', '>='), 'Mindestens PHP 8.1 nötig.');
+$treiber = DB::sqlite() ? 'pdo_sqlite' : 'pdo_mysql';
+$pruefen("Erweiterung $treiber", extension_loaded($treiber), 'In Plesk unter PHP-Einstellungen aktivieren.');
+$pruefen('Erweiterung gd (Porträts)', extension_loaded('gd'), 'In Plesk unter PHP-Einstellungen aktivieren.');
+$pruefen('Erweiterung mbstring', extension_loaded('mbstring'), 'In Plesk unter PHP-Einstellungen aktivieren.');
+$pruefen('Datenordner beschreibbar', is_writable(sm_daten_ordner()) && is_writable(sm_daten_ordner('portraets')),
+ 'Der Ordner sva-privat/daten muss für PHP beschreibbar sein.');
+
+$adminHinweis = '';
+if ($ok) {
+ try {
+ $tabellen = DB::schemaAnlegen();
+ $pruefen('Datenbank: ' . count($tabellen) . ' Tabellen vorhanden', true);
+
+ $email = mb_strtolower((string) sm_config('admin_email', 'info@tyrveil.com'));
+ $admin = DB::eine('SELECT * FROM sm_nutzer WHERE email = ?', [$email]);
+ if ($admin === null) {
+ $name = DB::wert("SELECT 1 FROM sm_nutzer WHERE benutzername_klein = 'admin'") ? 'Admin-' . random_int(100, 999) : 'Admin';
+ DB::einfuegen('sm_nutzer', [
+ 'benutzername' => $name, 'benutzername_klein' => mb_strtolower($name), 'email' => $email,
+ 'passwort_hash' => null, 'rolle' => 'admin', 'email_bestaetigt_am' => DB::jetzt(),
+ 'gesperrt' => 0, 'erstellt_am' => DB::jetzt(),
+ ]);
+ $admin = DB::eine('SELECT * FROM sm_nutzer WHERE email = ?', [$email]);
+ $pruefen("Verwaltungszugang für $email angelegt", true);
+ } else {
+ DB::aktualisieren('sm_nutzer', ['rolle' => 'admin', 'gesperrt' => 0], 'id = ?', [$admin['id']]);
+ $pruefen("Verwaltungszugang für $email vorhanden", true);
+ }
+
+ if ($admin['passwort_hash'] === null) {
+ $link = Konten::passwortLinkSenden($admin, 7 * 86400,
+ "der Verwaltungszugang für sva.tyrveil.com ist eingerichtet. Lege hier dein Passwort fest:\n\n"
+ . "%LINK%\n\nDer Link ist sieben Tage gültig.");
+ $adminHinweis = Web::hinweis('Eine Mail mit dem Link zum Passwort-Festlegen ging an ' . Web::e($email)
+ . '. Es gilt nur der zuletzt verschickte Link. Falls die Mail nicht ankommt, kannst du ihn auch direkt hier öffnen: '
+ . 'Passwort jetzt festlegen', 'warnung');
+ } else {
+ $adminHinweis = Web::hinweis('Der Verwaltungszugang hat schon ein Passwort. Vergessen? '
+ . 'Neues anfordern');
+ }
+ } catch (Throwable $fehler) {
+ sm_log('Einrichtung: ' . $fehler->getMessage());
+ $pruefen('Datenbankverbindung', false, $fehler instanceof PDOException
+ ? 'Zugangsdaten in config.php prüfen. Meldung: ' . $fehler->getMessage()
+ : $fehler->getMessage());
+ }
+}
+
+Web::seite('Einrichtung', '
Einrichtung
' . implode('', $zeilen) . '
'
+ . $adminHinweis
+ . ($ok ? Web::hinweis('Fertig. Trage in config.php den '
+ . 'einrichtungs_schluessel wieder leer ein – damit ist diese Seite abgeschaltet.', 'warnung')
+ : Web::hinweis('Die Einrichtung ist noch nicht abgeschlossen. Behebe die markierten Punkte und lade die Seite erneut.', 'fehler')));
diff --git a/server/sva.tyrveil.com/konto/bestaetigen.php b/server/sva.tyrveil.com/konto/bestaetigen.php
new file mode 100644
index 0000000..4f1217d
--- /dev/null
+++ b/server/sva.tyrveil.com/konto/bestaetigen.php
@@ -0,0 +1,14 @@
+
E-Mail bestätigt
'
+ . '
Danke, ' . Web::e($nutzer['benutzername']) . '. Deine Adresse ist bestätigt.