Compare commits

...

15 commits

Author SHA1 Message Date
danny
a5da53d373 1.7.0: Mitmachen im Squad ohne Konto
Der Squad-Reiter braucht kein Konto mehr: Spielername eingeben, der PC
bekommt einen Schluessel (Token ohne Ablauf), die Akten werden fuer alle
sichtbar. E-Mail und Passwort sind optional ("Konto sichern") und machen
die Charaktere reset- und mehr-PC-fest. Ohne gesichertes Konto bietet das
Menue kein Abmelden, weil das den Schluessel loeschte.

Server: Aktionen mitmachen und konto_sichern, Konten ohne E-Mail
(Datenbank-Stand 2, eingespielt von DB::migrieren() bei der ersten
Anfrage), Loeschen ohne Passwort fuer reine Schluessel-Konten, Verwaltung
zeigt sie als "nur Schluessel". Deinstallationsfrage nennt den Schluessel.

Tests: Server 108, Zwei-PC 34, Oberflaeche 24 - auch gegen das Paket.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-15 06:35:54 +02:00
danny
c175e42546 1.6.1: Deinstallation fragt ausdruecklich nach den Akten
Die Rueckfrage "Einstellungen entfernen?" loeschte den ganzen Ordner
%APPDATA%\SquadManager und damit auch alle lokalen Akten, ohne sie zu
nennen. Jetzt steht beides in der Frage, dazu der Hinweis, dass mit einem
Konto gesicherte Akten auf dem Server bleiben.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-15 06:21:23 +02:00
danny
4d9e30bc90 1.6.0: Squad-Reiter, Anmeldung und Abgleich im Programm
- Neuer Hauptreiter SQUAD: Anmeldung und Registrierung; angemeldet alle
  Charaktere mit Zustand (KIA/MIA/WIA), Suche und Fraktionsfilter,
  fremde Akten als Dokument, Squads gruenden und verwalten, Einladungen
  annehmen, ablehnen, zurueckziehen; Konto abmelden oder loeschen
- Akten werden nach dem Anmelden, kurz nach jeder Aenderung und alle
  5 Minuten mit dem Server abgeglichen; Zustand unter der Aktenliste
- Dokumentansicht als dokument_zeichnen() fuer eigene und fremde Akten;
  ohne Portraet scheint "KEIN PORTRAET" nicht mehr durch den Stempel
- Release-Bau: Bezeichner wie "konto_loeschen" bekommen keine Umlaute
  mehr - sonst waeren vier Serveraktionen im Paket kaputt gewesen
- Tests koennen mit SM_PROGRAMM gegen das gebaute Paket laufen
- Datenschutz-Baustein fuer tyrveil.com, Anleitung und Doku auf 1.6.0

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-13 20:09:31 +02:00
danny
0c7aae5b93 Abgleich der Akten mit dem Server (ohne Oberflaeche)
- konto.py: Aufrufe der Schnittstelle, Anmeldung; das Token liegt per
  DPAPI an das Windows-Konto gebunden in konto.json
- abgleich.py: gleicht lokale Akten und Server ab. server.json neben
  jeder Akte haelt den Stand des letzten Abgleichs (Pruefwert des Inhalts
  statt Zeitstempel, der nur sekundengenau ist). Konflikte sichern die
  Serverfassung als konflikt-<Zeit>.json; auf dem Server geloeschte Akten
  wandern lokal in den Papierkorb
- hintergrund.py: Netzwerkarbeit im Thread, Ergebnis im tkinter-Hauptthread
- akte_modell.speichern(zeit_setzen=False) fuer uebernommene Serverdaten
- Server liefert portraet_kennung, damit ein zweiter Rechner neue Bilder erkennt
- Tests: werkzeuge/abgleich_test.py mit zwei simulierten Rechnern (34
  Faelle); der Testserver nutzt php-cgi statt "php -S", das unter Windows
  nach vielen Verbindungen haengen bleibt

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-13 19:50:57 +02:00
danny
fb318980a1 PHP-Dateien immer mit LF-Zeilenenden
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-13 17:50:45 +02:00
danny
6e4d4afc1d Server fuer Konten, Akten und Squads
PHP 8 ohne Framework unter server/: oeffentliche Einstiege fuer
sva.tyrveil.com (Schnittstelle, Konto-Links, Verwaltung, Einrichtung) und
die Logik in sva-privat neben dem Dokumentenstamm.

- Konten mit E-Mail-Bestaetigung, Anmeldung per Token, Passwort
  vergessen, Konto loeschen
- Akten auf dem Server mit serververgebener Aktennummer und
  Versionspruefung; Portraets werden neu als PNG gespeichert
- Squads mit Einladungen, Fuehrung uebergeben, Aufloesen
- Verwaltung fuer info@tyrveil.com: Nutzer, Charaktere, Squads
- Bremsen gegen Durchprobieren, Token nur als Hash, CSRF-Schutz

werkzeuge/server_test.py prueft alles lokal mit SQLite (91 Faelle).
Der Release-Bau legt dist/server und dist/sva-privat an, ohne config.php.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-13 17:50:33 +02:00
danny
58a3573fd6 1.5.1: Schweden und Norwegen als Armeen
Schweden (Försvarsmakten) mit Heer, Luftwaffe, Marine und Amphibienkorps
nach der Gradtabelle seit 2019; Norwegen (Forsvaret) mit Heer, Luftwaffe
und Marine nach der Rangübersicht von Forsvaret (Dezember 2023), jeweils
mit den eigenen Mannschafts-, Unteroffiziers- und Marinegraden.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-13 17:29:31 +02:00
danny
9b6cbc7e4e 1.5.1: Fraktionen mit eigenen Teilstreitkraeften und Raengen
Jede Fraktion bietet nur noch ihre Teilstreitkraefte an, jede
Teilstreitkraft ihre Dienstgrade. Island hat nur die vier Bereiche der
Kuestenwache (See, Luftfahrt, Einsatzfuehrung, Verteidigung), die
Bundeswehr Heer, Luftwaffe und Marine mit eigenen Marine-Dienstgraden.
Fraktion, Teilstreitkraft, Dienstgrad und Verwendung sind reine
Auswahllisten. Alte Akten mit unpassenden Werten werden beim Laden nicht
geaendert, sondern mit einem Hinweis markiert.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-13 17:26:52 +02:00
danny
cc1f1dba25 Neue Versionszaehlung: 1.5.0 (Build 1)
Die angezeigte Version springt von 4.0 auf 1.5.0 zurueck. Damit Updates
weiter ankommen, vergleicht das Programm jetzt eine Zaehlnummer BUILD
statt der Anzeige. version.json fuehrt "anzeige" und "build" und fuer
Programme bis 4.0 dauerhaft "version": "4.1". Getestet mit dem echten
pruefe_update() aus 3.2, 3.3 und 4.0.

Der Release-Bau warnt, wenn BUILD nicht hoeher ist als auf dem Server.
Die Downloadseite zeigt "anzeige".

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-11 06:36:27 +02:00
danny
f89396e1b9 Stufe 3: Akte als PNG-Karte teilen
Neuer Knopf "Teilen ..." in der Akte. akte_karte.py zeichnet mit Pillow
eine Karte 1200 x 675 fuer Discord: Portraet, Callsign, Dienstgrad,
Fraktion, Einheit, Status mit Stempel, Auszeichnungen. Kopieren legt sie
als DIB und als PNG in die Zwischenablage (Strg+V in Discord), alternativ
Speichern als PNG-Datei.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-11 06:27:37 +02:00
danny
6ca9c48868 Downloadseite fuer sva.tyrveil.com
Der Release-Bau erzeugt aus installer/downloadseite.html die Seite
index.html samt icon.png. Sie liest beim Aufruf version.json und bietet
immer den neuesten Installer an; der Link fuer Freunde ist damit
dauerhaft https://sva.tyrveil.com. Die beim Bau eingesetzte Version,
Groesse und das Datum dienen als Rueckfallebene.

HOCHLADEN.txt wird jetzt mit der aktuellen Version erzeugt und nennt die
Reihenfolge beim Hochladen (version.json zuletzt).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-11 06:02:30 +02:00
danny
a200987237 Updater: geschuetzte Programmordner, Installer nur pro Benutzer
Lag das Programm unter C:\Program Files (Installer-Wahl "fuer alle
Benutzer"), scheiterte das Kopieren beim Update still und die alte
Fassung startete neu. Neu:

- update_helfer.py ersetzt die Batchdatei. Wartet per Prozess-ID auf das
  Programmende, prueft den Ordner per Schreibprobe und kopiert bei Bedarf
  in einem zweiten Prozess mit Adminrechten. Fehler werden gemeldet und
  protokolliert, mit Link zum Installer.
- Das Programm kuendigt die Windows-Abfrage vor dem Download an.
- Der Helfer aus dem neuen Paket hat Vorrang.
- Installer ohne die Wahl "fuer alle Benutzer"; eine alte Installation
  fuer alle Benutzer wird vorher entfernt.
- version.json fuehrt die Installer-Adresse.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-10 19:15:13 +02:00
danny
dac2e85f6a Installer-Version 4.0
Vom Release-Bau eingetragen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-10 18:50:38 +02:00
danny
8c0d364a8a Stufe 2: Akte vollstaendig (4.0)
Mehrere Akten mit Liste, Formular und Dokumentansicht, Portraet,
Statusstempel bei gefallen und vermisst, Vorschlagslisten fuer 22
Fraktionen samt Dienstgraden. Datenmodell in akte_modell.py ohne
tkinter, Vorlagen in akte_vorlagen.py. Speichern atomar mit Sicherung,
Loeschen ueber einen Papierkorb-Ordner. Neue Abhaengigkeit Pillow.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-10 18:50:18 +02:00
danny
f49e9a3ed0 Stufe 1: Hauptreiter FUNK und AKTE, Stil in theme.py (3.4)
- Farben, Schriften, ttk-Stil und Pegelanzeige liegen jetzt in theme.py,
  damit mehrere Module denselben Stil nutzen, ohne sich gegenseitig zu
  importieren
- Zwei Reiterebenen: FUNK (Mikrofon, Tasten und Verhalten) und AKTE; die
  Statusleiste bleibt fuer alle Module sichtbar
- Zuletzt gewaehlter Hauptreiter wird gespeichert
- akte.py als Platzhalter, damit das Update 3.3 -> 3.4 bereits neue
  Dateien mitliefert
- clam-Innenabstand fuer gewaehlte Hauptreiter festgesetzt, die Schrift
  sprang sonst um 4 Pixel
- Build nimmt theme.py und akte.py mit; Doku nachgezogen

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-10 18:27:04 +02:00
45 changed files with 8460 additions and 262 deletions

12
.claude/launch.json Normal file
View file

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

3
.gitattributes vendored
View file

@ -11,3 +11,6 @@
*.png binary
*.ico binary
# Server-Dateien laufen unter Linux
*.php text eol=lf

4
.gitignore vendored
View file

@ -9,3 +9,7 @@ __pycache__/
# Editor
.idea/
.vscode/
# Server: Zugangsdaten und Nutzerdaten nie ins Repository
server/sva-privat/config.php
server/sva-privat/daten/

View file

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

View file

@ -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\<id>\` 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-<Jahr>-<n>`, 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-<Zeit>.json` neben die Akte, lokale Fassung gewinnt. Auf dem
Server gelöschte Akten wandern lokal in den Papierkorb. Der Papierkorb im
Programm merkt Akten in `akten/_abgleich_loeschen.json` zum Löschen auf dem
Server vor. Die Aktennummer vergibt der Server; der Abgleich schreibt sie
lokal zurück (`modell.speichern(zeit_setzen=False)`). Danach lädt
`AkteSeite.nach_abgleich()` geänderte Akten neu, die offene nur, wenn sie
selbst betroffen ist.
Tests: `werkzeuge/abgleich_test.py` (zwei Rechner als eigene Prozesse mit
eigenem `%APPDATA%`, 34 Fälle) und `werkzeuge/oberflaeche_test.py`
(Programm gegen den Testserver, Anmeldung, Einladung annehmen, fremde
Akte, Konto löschen, mit Bildschirmfotos). Beide nutzen den Testserver aus
`server_test.py`; `konto.py` liest die Serveradresse aus `SM_SERVER`
(nur `http://127.0.0.1` ist neben HTTPS erlaubt).
**Teilen:** Knopf „Teilen …" in der Leiste der Akte. `akte_karte.karte()`
zeichnet mit Pillow eine Karte 1200 × 675 (Discord zeigt das groß) —
bewusst kein Bildschirmfoto, damit sie überall gleich aussieht. Inhalt:
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-<v>.zip`, der Installer
`SquadManager-Setup-<v>.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
`<quelle> <ziel> <pid> [<installer-url>]` 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-<Jahr>-<id>`), 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*

View file

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

285
abgleich.py Normal file
View file

@ -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-<Zeit>.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()

914
akte.py Normal file
View file

@ -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("<Escape>", 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("<Configure>", lambda e: self.canvas.configure(
scrollregion=self.canvas.bbox("all")))
self.canvas.bind("<Configure>", 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("<MouseWheel>", 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("<<TreeviewSelect>>", 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("<Configure>", 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("<MouseWheel>", 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("<<Modified>>", 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("<Double-1>", 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)

291
akte_karte.py Normal file
View file

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

241
akte_modell.py Normal file
View file

@ -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\\<id>\\akte.json
%APPDATA%\\SquadManager\\akten\\<id>\\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-<Jahr>-<laufende Nummer>; 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"

362
akte_vorlagen.py Normal file
View file

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

46
hintergrund.py Normal file
View file

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

View file

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

View file

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

View file

@ -0,0 +1,200 @@
<!doctype html>
<html lang="de">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Squad Manager – Download</title>
<meta name="description" content="Hält in Squad die Sprechtaste gedrückt, solange du sprichst. Dazu eine Personalakte für deine Charaktere.">
<meta property="og:title" content="Squad Manager">
<meta property="og:description" content="Hält in Squad die Sprechtaste gedrückt, solange du sprichst. Dazu eine Personalakte für deine Charaktere.">
<meta property="og:image" content="https://sva.tyrveil.com/icon.png">
<meta name="theme-color" content="#6e8b3d">
<link rel="icon" href="icon.png">
<style>
:root {
--bg: #151814; --panel: #1e231b; --panel-hi: #2a3125; --line: #3d4634;
--fg: #c9cec0; --dim: #7f8874; --olive: #6e8b3d; --olive-hi: #8cb04d;
--amber: #d9a441; --amber-dunkel: #2b2416;
--mono: Consolas, "Cascadia Mono", "Courier New", monospace;
}
* { box-sizing: border-box; }
[hidden] { display: none !important; }
html { background: var(--bg); }
body {
margin: 0; color: var(--fg); background: var(--bg);
font: 15px/1.6 "Segoe UI", system-ui, -apple-system, sans-serif;
}
main { max-width: 760px; margin: 0 auto; padding: 48px 20px 24px; }
a { color: var(--olive-hi); }
.kopf { display: flex; align-items: center; gap: 16px; margin-bottom: 36px; }
.kopf img { width: 56px; height: 56px; }
.kopf h1 { margin: 0; font-size: 26px; letter-spacing: .04em; line-height: 1.2; }
.kopf p { margin: 2px 0 0; color: var(--dim); }
.download {
background: var(--panel); border: 1px solid var(--line);
padding: 22px 26px 26px; margin-bottom: 40px;
}
.download .zeile {
display: flex; justify-content: space-between; gap: 12px; flex-wrap: wrap;
font: 12px var(--mono); color: var(--dim); letter-spacing: .06em;
}
.version { font: 700 44px/1.1 var(--mono); color: var(--olive-hi); margin: 14px 0 6px; }
.meta { display: flex; flex-wrap: wrap; gap: 6px 18px; margin: 0 0 22px; color: var(--dim); font-size: 14px; }
.meta span:empty { display: none; }
.meta span::before {
content: ""; display: inline-block; width: 5px; height: 5px; margin: 0 8px 2px 0;
background: var(--line); vertical-align: middle;
}
.knopf {
display: inline-block; padding: 13px 28px; text-decoration: none;
background: var(--olive); color: #10130d; border: 1px solid var(--olive-hi);
font-weight: 600; font-size: 16px;
}
.knopf:hover, .knopf:focus-visible { background: var(--olive-hi); outline: none; }
.hinweis {
margin: 18px 0 0; padding: 10px 14px; background: var(--amber-dunkel);
border-left: 3px solid var(--amber); color: var(--amber);
}
.nebenbei { margin: 16px 0 0; color: var(--dim); font-size: 14px; }
h2 {
font: 700 13px var(--mono); letter-spacing: .08em; color: var(--olive-hi);
border-bottom: 1px solid var(--line); padding-bottom: 6px; margin: 0 0 18px;
}
section { margin-bottom: 40px; }
.schritte { list-style: none; padding: 0; margin: 0; counter-reset: schritt; }
.schritte li {
counter-increment: schritt; position: relative;
padding-left: 46px; margin-bottom: 18px;
}
.schritte li::before {
content: counter(schritt); position: absolute; left: 0; top: 1px;
width: 28px; height: 28px; display: grid; place-items: center;
border: 1px solid var(--amber); color: var(--amber); font: 700 14px var(--mono);
}
.schritte b { color: #e2e6da; }
.schritte em { font-style: normal; color: var(--amber); }
.module { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; }
.module article { background: var(--panel); border: 1px solid var(--line); padding: 16px 18px; }
.module h3 { margin: 0 0 6px; font: 700 15px var(--mono); letter-spacing: .08em; color: var(--olive-hi); }
.module p { margin: 0; font-size: 14px; }
.vertrauen { color: var(--dim); font-size: 14px; border-left: 3px solid var(--line); padding-left: 14px; }
footer {
max-width: 760px; margin: 0 auto; padding: 18px 20px 40px;
font: 12px var(--mono); color: var(--dim); letter-spacing: .06em;
}
@media (max-width: 620px) {
main { padding-top: 28px; }
.module { grid-template-columns: 1fr; }
.version { font-size: 36px; }
.knopf { display: block; text-align: center; }
}
</style>
</head>
<body>
<main>
<header class="kopf">
<img src="icon.png" alt="">
<div>
<h1>SQUAD MANAGER</h1>
<p>Sprachaktivierung und Personalakte für Squad</p>
</div>
</header>
<div class="download">
<div class="zeile"><span>AKTUELLE VERSION</span><span>FÜR WINDOWS 10 UND 11</span></div>
<div class="version" id="version">__VERSION__</div>
<p class="meta"><span id="groesse">__GROESSE__</span><span id="datum">Stand __DATUM__</span></p>
<a class="knopf" id="knopf" href="__INSTALLER__">Installer herunterladen</a>
<p class="hinweis" id="hinweis" hidden></p>
<p class="nebenbei" id="kein-windows" hidden>Du bist gerade nicht an einem Windows-PC. Öffne diese Seite später dort – der Installer läuft nur unter Windows.</p>
</div>
<section>
<h2>I. INSTALLATION</h2>
<ol class="schritte">
<li><b>Python installieren</b>, falls noch nicht vorhanden: Version 3.9 oder neuer von <a href="https://www.python.org/downloads/">python.org</a>. Im Installationsfenster <em>„Add python.exe to PATH“</em> ankreuzen.</li>
<li><b>Installer starten.</b> Windows meldet sich mit „Der Computer wurde durch Windows geschützt“. Das liegt daran, dass die Datei nicht signiert ist, nicht an einem Fehler: <em>Weitere Informationen → Trotzdem ausführen</em>.</li>
<li><b>Fertig.</b> Der Installer richtet den Rest ein und legt eine Verknüpfung im Startmenü an. Neue Versionen meldet das Programm danach selbst, ein Klick spielt sie ein.</li>
</ol>
</section>
<section>
<h2>II. MODULE</h2>
<div class="module">
<article>
<h3>FUNK</h3>
<p>Hält die Sprechtaste gedrückt, solange du sprichst, und lässt sie nach dem letzten Wort los. Sperrt von selbst, wenn Squad nicht im Vordergrund ist oder du eine Funktaste hältst.</p>
</article>
<article>
<h3>AKTE</h3>
<p>Personalakte für deine Charaktere: Porträt, Dienstgrad, Einheit, Auszeichnungen und Einsätze – mit Vorlagen für alle Squad-Fraktionen und mehrere echte Armeen.</p>
</article>
</div>
</section>
<p class="vertrauen">Greift nicht in Squad ein: kein Hook, keine DLL, kein Speicherzugriff. Das Programm liest nur den Pegel deines Mikrofons und drückt die Taste, die du festlegst.</p>
</main>
<footer>SVA.TYRVEIL.COM</footer>
<script>
(function () {
if (!/Windows/i.test(navigator.userAgent)) {
document.getElementById("kein-windows").hidden = false;
}
// Die Seite wird beim Bau mit der aktuellen Version erzeugt. Liegt auf
// dem Server schon eine neuere version.json, gilt diese.
fetch("version.json", { cache: "no-store" })
.then(function (antwort) {
if (!antwort.ok) throw new Error(antwort.status);
var geaendert = antwort.headers.get("Last-Modified");
return antwort.json().then(function (daten) { return [daten, geaendert]; });
})
.then(function (paar) {
var daten = paar[0];
// "anzeige" seit 1.5.0; "version" steht fuer alte Programme fest auf 4.1
var version = String(daten.anzeige || daten.version || "").trim();
if (!version) return;
var adresse = String(daten.installer || "").trim();
if (!/^https:\/\//i.test(adresse)) {
var paket = String(daten.datei || "").trim();
if (!/^https:\/\//i.test(paket)) return;
adresse = paket.replace(/[^\/]+$/, "SquadManager-Setup-" + version + ".exe");
}
document.getElementById("knopf").href = adresse;
var feld = document.getElementById("version");
if (feld.textContent.trim() !== version) {
feld.textContent = version;
var groesse = document.getElementById("groesse");
var datum = document.getElementById("datum");
groesse.textContent = "";
var zeit = paar[1] ? new Date(paar[1]) : null;
datum.textContent = zeit && !isNaN(zeit) ? "Stand " + zeit.toLocaleDateString("de-DE") : "";
fetch(adresse, { method: "HEAD" }).then(function (antwort) {
var bytes = Number(antwort.headers.get("Content-Length"));
if (antwort.ok && bytes) {
groesse.textContent = (bytes / 1048576).toFixed(1).replace(".", ",") + " MB";
}
}).catch(function () {});
}
var hinweis = String(daten.hinweis || "").trim();
if (hinweis) {
var zeile = document.getElementById("hinweis");
zeile.textContent = "Neu in " + version + ": " + hinweis;
zeile.hidden = false;
}
})
.catch(function () {});
})();
</script>
</body>
</html>

View file

@ -2,7 +2,7 @@
; Uebersetzen mit: ISCC.exe setup.iss
#define Name "Squad Manager"
#define Version "3.3"
#define Version "1.7.0"
#define Herausgeber "tyrveil.com"
#define Website "https://sva.tyrveil.com"
@ -19,8 +19,10 @@ DefaultGroupName={#Name}
DisableProgramGroupPage=yes
DisableDirPage=no
AllowNoIcons=yes
; Immer nur fuer den aktuellen Benutzer. Unter "Programme" darf das Programm
; seine Dateien ohne Adminrechte nicht ersetzen - der Updater scheiterte
; dort bis 3.4 still. Die fruehere Wahl "fuer alle Benutzer" ist deshalb weg.
PrivilegesRequired=lowest
PrivilegesRequiredOverridesAllowed=dialog
OutputDir=..\dist
OutputBaseFilename=SquadManager-Setup-{#Version}
SetupIconFile=..\icon.ico
@ -64,6 +66,71 @@ Type: files; Name: "{userdesktop}\Squad Manager.lnk"
Type: files; Name: "{userprograms}\Squad Manager.lnk"
[Code]
function AlteInstallationFuerAlle(var Deinstaller: String): Boolean;
var
Schluessel: String;
begin
{ Eine Installation "fuer alle Benutzer" steht unter HKLM. Die AppId kommt
aus [Setup], damit Testbauten mit eigener AppId nur sich selbst finden. }
Schluessel := 'Software\Microsoft\Windows\CurrentVersion\Uninstall\' +
ExpandConstant('{#emit SetupSetting("AppId")}') + '_is1';
Result := RegQueryStringValue(HKLM32, Schluessel, 'UninstallString', Deinstaller);
if not Result and IsWin64 then
Result := RegQueryStringValue(HKLM64, Schluessel, 'UninstallString', Deinstaller);
end;
function InitializeSetup(): Boolean;
var
Deinstaller: String;
Code, Runden: Integer;
begin
Result := True;
if not AlteInstallationFuerAlle(Deinstaller) then
Exit;
if SuppressibleMsgBox(
'Squad Manager ist auf diesem PC noch fuer alle Benutzer installiert, im ' +
'Ordner "Programme". Dort kann es sich nicht selbst aktualisieren.' + #13#10#13#10 +
'Die alte Installation wird jetzt entfernt, Windows fragt dafuer nach ' +
'Administratorrechten. Danach wird in deinen Benutzerordner installiert. ' +
'Einstellungen und Akten bleiben erhalten.' + #13#10#13#10 +
'Fragt die alte Deinstallation, ob die Einstellungen entfernt werden ' +
'sollen, bitte Nein waehlen.',
mbConfirmation, MB_OKCANCEL, IDOK) <> IDOK then
begin
Result := False;
Exit;
end;
if not ShellExec('runas', RemoveQuotes(Deinstaller),
'/SILENT /SUPPRESSMSGBOXES /NORESTART', '', SW_SHOWNORMAL,
ewWaitUntilTerminated, Code) then
begin
MsgBox('Die alte Installation konnte nicht entfernt werden:' + #13#10 +
SysErrorMessage(Code) + #13#10#13#10 +
'Entferne "Squad Manager" unter Einstellungen > Apps und starte ' +
'diesen Installer danach erneut.', mbError, MB_OK);
Result := False;
Exit;
end;
{ Der Deinstaller arbeitet mit einer Kopie seiner selbst weiter und kann
zurueckkehren, bevor sie fertig ist. Bis zu 30 Sekunden abwarten. }
Runden := 0;
while AlteInstallationFuerAlle(Deinstaller) and (Runden < 60) do
begin
Sleep(500);
Runden := Runden + 1;
end;
if AlteInstallationFuerAlle(Deinstaller) then
begin
MsgBox('Die alte Installation ist noch vorhanden. Entferne "Squad Manager" ' +
'unter Einstellungen > Apps und starte diesen Installer danach erneut.',
mbError, MB_OK);
Result := False;
end;
end;
function DesktopWunsch(Param: String): String;
begin
if WizardIsTaskSelected('desktopicon') then
@ -83,7 +150,12 @@ begin
ein reflexhaftes Ja loeschte die Einstellungen. Der alte Ordner
SquadVoiceActivation bleibt stehen - eine Installation von 3.1 kann ihn
noch benutzen. }
Auswahl := SuppressibleMsgBox('Sollen auch die gespeicherten Einstellungen entfernt werden?',
{ Der Ordner enthaelt seit 3.4 auch die Akten - das muss in der Frage stehen }
Auswahl := SuppressibleMsgBox('Sollen auch die Einstellungen, die lokal gespeicherten Akten und ' +
'der Squad-Schluessel dieses PCs entfernt werden?' + #13#10#13#10 +
'Ohne gesichertes Konto (E-Mail und Passwort) lassen sich deine ' +
'Charaktere danach nicht mehr bearbeiten. Mit gesichertem Konto ' +
'kommen sie nach der naechsten Anmeldung zurueck.',
mbConfirmation, MB_YESNO, IDNO);
if Auswahl = IDYES then
DelTree(ExpandConstant('{userappdata}\SquadManager'), True, True, True);

249
konto.py Normal file
View file

@ -0,0 +1,249 @@
"""
Verbindung zum Server sva.tyrveil.com: Konto, Akten und Squads.
Ohne tkinter. Alle Aufrufe blockieren und gehoeren in einen
Hintergrund-Thread (siehe hintergrund.py).
Das Sitzungstoken liegt in %APPDATA%\\SquadManager\\konto.json, mit der
Windows-Datenschutz-API (DPAPI) an das Windows-Konto gebunden: Eine auf
einen anderen Rechner kopierte Datei ist dort wertlos.
"""
import base64
import ctypes
import ctypes.wintypes as wintypes
import json
import os
import socket
import threading
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path
# Fuer Tests laesst sich ein lokaler Server einsetzen, nur ueber http://127.0.0.1
SERVER = os.environ.get("SM_SERVER", "https://sva.tyrveil.com").rstrip("/")
KONTO_DATEI = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "konto.json"
ZEITLIMIT = 25
class ServerFehler(Exception):
"""Fehler vom oder auf dem Weg zum Server, mit Code und lesbarer Meldung."""
def __init__(self, code, meldung, http=0, extra=None):
super().__init__(meldung)
self.code = code
self.meldung = meldung
self.http = http
self.extra = extra or {}
def _adresse_pruefen():
teile = urllib.parse.urlsplit(SERVER)
if teile.scheme == "https":
return
if teile.scheme == "http" and teile.hostname in ("127.0.0.1", "localhost"):
return
raise ServerFehler("unsicher", "Der Server muss über HTTPS erreichbar sein.")
# -- Token geschuetzt ablegen ------------------------------------------------
class _BLOB(ctypes.Structure):
_fields_ = [("cbData", wintypes.DWORD), ("pbData", ctypes.POINTER(ctypes.c_char))]
def _dpapi(daten, schuetzen):
crypt32 = ctypes.WinDLL("crypt32", use_last_error=True)
kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
funktion = crypt32.CryptProtectData if schuetzen else crypt32.CryptUnprotectData
funktion.argtypes = (ctypes.POINTER(_BLOB), ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_void_p, wintypes.DWORD, ctypes.POINTER(_BLOB))
funktion.restype = wintypes.BOOL
kernel32.LocalFree.argtypes = (ctypes.c_void_p,)
puffer = ctypes.create_string_buffer(daten, len(daten))
ein = _BLOB(len(daten), ctypes.cast(puffer, ctypes.POINTER(ctypes.c_char)))
aus = _BLOB()
CRYPTPROTECT_UI_FORBIDDEN = 0x01
if not funktion(ctypes.byref(ein), None, None, None, None, CRYPTPROTECT_UI_FORBIDDEN, ctypes.byref(aus)):
raise OSError(ctypes.get_last_error(), "DPAPI")
try:
return ctypes.string_at(aus.pbData, aus.cbData)
finally:
kernel32.LocalFree(ctypes.cast(aus.pbData, ctypes.c_void_p))
_sperre = threading.Lock()
_sitzung = None
_geladen = False
def sitzung():
"""Die gespeicherte Anmeldung {"token", "nutzer"} oder None."""
global _sitzung, _geladen
with _sperre:
if not _geladen:
_geladen = True
try:
roh = json.loads(KONTO_DATEI.read_text(encoding="utf-8"))
# Eine Anmeldung gilt nur fuer den Server, bei dem sie entstand
if roh.get("server") == SERVER:
token = _dpapi(base64.b64decode(roh["token"]), False).decode("ascii")
_sitzung = {"token": token, "nutzer": roh.get("nutzer") or {}}
except (OSError, ValueError, KeyError, TypeError):
_sitzung = None
return dict(_sitzung) if _sitzung else None
def _merken(token, nutzer):
global _sitzung, _geladen
KONTO_DATEI.parent.mkdir(parents=True, exist_ok=True)
zwischen = KONTO_DATEI.with_suffix(".tmp")
zwischen.write_text(json.dumps({
"server": SERVER,
"token": base64.b64encode(_dpapi(token.encode("ascii"), True)).decode("ascii"),
"nutzer": nutzer,
}, ensure_ascii=False, indent=2), encoding="utf-8")
os.replace(zwischen, KONTO_DATEI)
with _sperre:
_sitzung, _geladen = {"token": token, "nutzer": nutzer}, True
def _vergessen():
global _sitzung, _geladen
with _sperre:
_sitzung, _geladen = None, True
try:
KONTO_DATEI.unlink()
except OSError:
pass
# -- Aufrufe -------------------------------------------------------------------
def anfrage(aktion, token=None, **felder):
"""Ruft eine Aktion der Schnittstelle auf. Gibt die Antwort zurueck oder wirft ServerFehler."""
_adresse_pruefen()
kopf = {"Content-Type": "application/json", "User-Agent": "SquadManager"}
if token:
kopf["X-SM-Token"] = token
koerper = json.dumps({"aktion": aktion, **felder}, ensure_ascii=False).encode("utf-8")
anfrage_ = urllib.request.Request(SERVER + "/api/", data=koerper, headers=kopf, method="POST")
http = 200
try:
with urllib.request.urlopen(anfrage_, timeout=ZEITLIMIT) as antwort:
text = antwort.read()
except urllib.error.HTTPError as fehler:
http, text = fehler.code, fehler.read()
except (urllib.error.URLError, OSError) as fehler:
raise ServerFehler("offline", "Keine Verbindung zum Server. Besteht eine Internetverbindung?") from fehler
try:
daten = json.loads(text.decode("utf-8"))
except ValueError:
raise ServerFehler("serverfehler", f"Der Server antwortet nicht wie erwartet (HTTP {http}).", http) from None
if not isinstance(daten, dict) or daten.get("ok") is not True:
daten = daten if isinstance(daten, dict) else {}
code = daten.get("fehler", "serverfehler")
if code == "nicht_angemeldet" and token:
_vergessen()
raise ServerFehler(code, daten.get("meldung", "Unbekannter Fehler vom Server."), http, daten)
return daten
def aufrufen(aktion, **felder):
"""Wie anfrage(), mit dem Token der gespeicherten Anmeldung."""
stand = sitzung()
if not stand:
raise ServerFehler("nicht_angemeldet", "Bitte melde dich an.")
return anfrage(aktion, token=stand["token"], **felder)
def angemeldet():
return sitzung() is not None
def nutzer():
stand = sitzung()
return stand["nutzer"] if stand else None
def gesichert():
"""True, wenn das Konto E-Mail und Passwort hat - sonst haengt es am Schluessel dieses PCs."""
stand = nutzer()
return bool(stand and stand.get("gesichert", True))
def mitmachen(spielername):
"""Mitmachen ohne Konto: Der Server legt einen Nutzer an, das Token ist der Schluessel des PCs."""
antwort = anfrage("mitmachen", spielername=spielername, geraet=socket.gethostname()[:100])
_merken(antwort["token"], antwort["nutzer"])
return antwort["nutzer"]
def konto_sichern(email, passwort):
antwort = aufrufen("konto_sichern", email=email, passwort=passwort)
_merken(sitzung()["token"], antwort["nutzer"])
return antwort["nutzer"]
def registrieren(benutzername, email, passwort):
return anfrage("registrieren", benutzername=benutzername, email=email, passwort=passwort)
def anmelden(login, passwort):
antwort = anfrage("anmelden", login=login, passwort=passwort, geraet=socket.gethostname()[:100])
_merken(antwort["token"], antwort["nutzer"])
return antwort["nutzer"]
def abmelden():
stand = sitzung()
try:
if stand:
anfrage("abmelden", token=stand["token"])
except ServerFehler:
pass
finally:
_vergessen()
def pruefen():
"""Fragt, ob die gespeicherte Anmeldung noch gilt. Aktualisiert die Nutzerdaten."""
stand = sitzung()
if not stand:
return None
antwort = anfrage("ich", token=stand["token"])
if antwort["nutzer"] != stand["nutzer"]:
_merken(stand["token"], antwort["nutzer"])
return antwort["nutzer"]
def bestaetigung_erneut(email):
return anfrage("bestaetigung_erneut", email=email)
def passwort_vergessen(email):
return anfrage("passwort_vergessen", email=email)
def bild(charakter_id):
"""Portraet eines Charakters als PNG-Bytes oder None."""
_adresse_pruefen()
stand = sitzung()
if not stand:
raise ServerFehler("nicht_angemeldet", "Bitte melde dich an.")
anfrage_ = urllib.request.Request(f"{SERVER}/api/bild.php?id={int(charakter_id)}",
headers={"X-SM-Token": stand["token"], "User-Agent": "SquadManager"})
try:
with urllib.request.urlopen(anfrage_, timeout=ZEITLIMIT) as antwort:
return antwort.read(16 * 1024 * 1024)
except urllib.error.HTTPError as fehler:
if fehler.code == 404:
return None
raise ServerFehler("serverfehler", f"Porträt nicht abrufbar (HTTP {fehler.code}).", fehler.code) from None
except (urllib.error.URLError, OSError) as fehler:
raise ServerFehler("offline", "Keine Verbindung zum Server.") from fehler
def webseite(pfad):
return SERVER + pfad

View file

@ -1,2 +1,3 @@
numpy>=1.26
sounddevice>=0.4.6
Pillow>=10.4

View file

@ -0,0 +1,174 @@
<?php
/*
* Schnittstelle fuer das Programm.
*
* Alle Aufrufe: POST /api/ mit JSON {"aktion": "...", ...}. Angemeldete
* Aufrufe schicken das Sitzungstoken im Kopf X-SM-Token - nicht in
* Authorization, das Plesk-Konfigurationen gern verschlucken. Antwort immer
* JSON: {"ok": true, ...} oder {"ok": false, "fehler": "code", "meldung": "Text"}.
*/
declare(strict_types=1);
final class Api
{
private const OHNE_ANMELDUNG = ['status', 'mitmachen', 'registrieren', 'anmelden', 'bestaetigung_erneut',
'passwort_vergessen'];
private const MAX_ANFRAGE_BYTES = 12 * 1024 * 1024;
private static function senden(array $daten, int $http = 200): never
{
http_response_code($http);
header('Content-Type: application/json; charset=utf-8');
header('Cache-Control: no-store');
header('X-Content-Type-Options: nosniff');
echo json_encode($daten, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
exit;
}
private static function text(array $anfrage, string $feld, int $max = 1000): string
{
$wert = $anfrage[$feld] ?? '';
if (!is_string($wert) && !is_int($wert)) {
throw new SmFehler('feld_ungueltig', "Feld $feld ist ungültig.");
}
return mb_substr((string) $wert, 0, $max);
}
private static function zahl(array $anfrage, string $feld): int
{
$wert = $anfrage[$feld] ?? null;
if (!is_int($wert) && !(is_string($wert) && ctype_digit($wert))) {
throw new SmFehler('feld_ungueltig', "Feld $feld fehlt oder ist keine Zahl.");
}
return (int) $wert;
}
public static function behandeln(): never
{
try {
if (($_SERVER['REQUEST_METHOD'] ?? '') !== 'POST') {
throw new SmFehler('methode', 'Nur POST.', 405);
}
$roh = file_get_contents('php://input', false, null, 0, self::MAX_ANFRAGE_BYTES + 1);
if ($roh === false || strlen($roh) > self::MAX_ANFRAGE_BYTES) {
throw new SmFehler('anfrage_zu_gross', 'Die Anfrage ist zu groß.', 413);
}
DB::migrieren();
$anfrage = json_decode($roh, true);
if (!is_array($anfrage) || !is_string($anfrage['aktion'] ?? null)) {
throw new SmFehler('anfrage_ungueltig', 'Ungültige Anfrage.');
}
$aktion = $anfrage['aktion'];
$nutzer = null;
if (!in_array($aktion, self::OHNE_ANMELDUNG, true)) {
$nutzer = Sicherheit::sitzung((string) ($_SERVER['HTTP_X_SM_TOKEN'] ?? ''));
if ($nutzer === null) {
throw new SmFehler('nicht_angemeldet', 'Bitte melde dich an.', 401);
}
}
self::senden(['ok' => true] + self::ausfuehren($aktion, $anfrage, $nutzer));
} catch (SmFehler $fehler) {
self::senden(['ok' => false, 'fehler' => $fehler->fehlercode, 'meldung' => $fehler->getMessage()]
+ $fehler->extra, $fehler->http);
} catch (Throwable $fehler) {
sm_log('API: ' . $fehler::class . ': ' . $fehler->getMessage() . ' in '
. $fehler->getFile() . ':' . $fehler->getLine());
self::senden(['ok' => false, 'fehler' => 'serverfehler',
'meldung' => 'Auf dem Server ist ein Fehler aufgetreten.'], 500);
}
}
private static function ausfuehren(string $aktion, array $a, ?array $nutzer): array
{
switch ($aktion) {
case 'status':
return ['api' => SM_API_VERSION, 'zeit' => DB::jetzt()];
// -- Konto ------------------------------------------------------
case 'mitmachen':
return Konten::mitmachen(self::text($a, 'spielername', 64), self::text($a, 'geraet', 100));
case 'konto_sichern':
return ['nutzer' => Konten::kontoSichern($nutzer, self::text($a, 'email', 250),
self::text($a, 'passwort', 500)),
'meldung' => 'Wir haben dir eine Mail zur Bestätigung geschickt.'];
case 'registrieren':
Konten::registrieren(self::text($a, 'benutzername', 64), self::text($a, 'email', 250),
self::text($a, 'passwort', 500));
return ['meldung' => 'Konto angelegt. Wir haben dir eine Mail zur Bestätigung geschickt.'];
case 'bestaetigung_erneut':
Konten::bestaetigungErneut(self::text($a, 'email', 250));
return ['meldung' => 'Falls ein unbestätigtes Konto zu dieser Adresse gehört, ist die Mail unterwegs.'];
case 'anmelden':
return Konten::anmelden(self::text($a, 'login', 250), self::text($a, 'passwort', 500),
self::text($a, 'geraet', 100));
case 'passwort_vergessen':
Konten::passwortVergessen(self::text($a, 'email', 250));
return ['meldung' => 'Falls ein Konto zu dieser Adresse gehört, ist die Mail unterwegs.'];
case 'abmelden':
Konten::abmelden($nutzer);
return [];
case 'ich':
return ['nutzer' => Konten::oeffentlich($nutzer)];
case 'konto_loeschen':
Konten::kontoLoeschen($nutzer, self::text($a, 'passwort', 500));
return [];
// -- Eigene Charaktere -------------------------------------------
case 'charaktere_eigene':
return ['charaktere' => Charaktere::eigene($nutzer)];
case 'charakter_speichern':
$basis = $a['basis_version'] ?? null;
return ['charakter' => Charaktere::speichern($nutzer, self::text($a, 'lokale_id', 64),
$a['daten'] ?? null, is_int($basis) ? $basis : null, ($a['erzwingen'] ?? false) === true)];
case 'charakter_loeschen':
Charaktere::loeschen($nutzer, self::text($a, 'lokale_id', 64));
return [];
case 'portraet_hochladen':
return ['charakter' => Charaktere::portraetSetzen($nutzer, self::text($a, 'lokale_id', 64),
self::text($a, 'bild', self::MAX_ANFRAGE_BYTES))];
case 'portraet_entfernen':
return ['charakter' => Charaktere::portraetEntfernen($nutzer, self::text($a, 'lokale_id', 64))];
// -- Alle Charaktere ---------------------------------------------
case 'charaktere_alle':
return ['charaktere' => Charaktere::alle($nutzer, self::text($a, 'suche', 64),
self::text($a, 'fraktion', 80))];
case 'charakter_ansehen':
return ['charakter' => Charaktere::ansehen($nutzer, self::zahl($a, 'id'))];
// -- Squads -------------------------------------------------------
case 'squads':
return ['squads' => Squads::liste($nutzer)];
case 'squad_ansehen':
return ['squad' => Squads::details($nutzer, self::zahl($a, 'squad_id'))];
case 'squad_gruenden':
return ['squad' => Squads::gruenden($nutzer, self::zahl($a, 'charakter_id'),
self::text($a, 'name', 100), self::text($a, 'beschreibung', 2000))];
case 'squad_einladen':
return ['einladung' => Squads::einladen($nutzer, self::zahl($a, 'squad_id'),
self::zahl($a, 'charakter_id'))];
case 'einladungen':
return Squads::einladungen($nutzer);
case 'einladung_beantworten':
Squads::beantworten($nutzer, self::zahl($a, 'einladung_id'), ($a['annehmen'] ?? false) === true);
return [];
case 'einladung_zurueckziehen':
Squads::zurueckziehen($nutzer, self::zahl($a, 'einladung_id'));
return [];
case 'squad_verlassen':
Squads::verlassen($nutzer, self::zahl($a, 'charakter_id'));
return [];
case 'squad_entfernen':
Squads::entfernen($nutzer, self::zahl($a, 'squad_id'), self::zahl($a, 'charakter_id'));
return [];
case 'squad_fuehrung_uebergeben':
Squads::fuehrungUebergeben($nutzer, self::zahl($a, 'squad_id'), self::zahl($a, 'charakter_id'));
return [];
case 'squad_aufloesen':
Squads::aufloesen($nutzer, self::zahl($a, 'squad_id'));
return [];
}
throw new SmFehler('aktion_unbekannt', 'Unbekannte Aktion.', 404);
}
}

View file

@ -0,0 +1,325 @@
<?php
/*
* Charaktere (Akten) auf dem Server.
*
* Die Akte selbst liegt als JSON in "daten", so wie das Programm sie
* speichert. Die Felder fuer Listen und Suche (Callsign, Rang, Status ...)
* werden beim Speichern daraus abgeleitet. Aktennummern vergibt der Server,
* damit sie ueber alle Spieler eindeutig sind.
*/
declare(strict_types=1);
final class Charaktere
{
public const MAX_JE_NUTZER = 50;
public const MAX_DATEN_BYTES = 262144;
public const MAX_BILD_BYTES = 8 * 1024 * 1024;
public const BILD_KANTE = 512;
private static function text(mixed $wert, int $max): string
{
return is_string($wert) ? mb_substr(trim($wert), 0, $max) : '';
}
/** Listenfelder aus der Akte. */
private static function felder(array $daten): array
{
$p = is_array($daten['personalien'] ?? null) ? $daten['personalien'] : [];
$d = is_array($daten['dienst'] ?? null) ? $daten['dienst'] : [];
return [
'callsign' => self::text($p['callsign'] ?? '', 64),
'vorname' => self::text($p['vorname'] ?? '', 64),
'nachname' => self::text($p['nachname'] ?? '', 64),
'fraktion' => self::text($d['fraktion'] ?? '', 80),
'teilstreitkraft' => self::text($d['teilstreitkraft'] ?? '', 80),
'rang' => self::text($d['rang'] ?? '', 120),
'verwendung' => self::text($d['verwendung'] ?? '', 80),
'status' => in_array($d['status'] ?? '', SM_STATUS, true) ? $d['status'] : 'aktiv',
];
}
private static function squadKurz(array $zeile): ?array
{
if ($zeile['squad_id'] === null) {
return null;
}
$squad = DB::eine('SELECT id, name, fuehrer_id FROM sm_squad WHERE id = ?', [$zeile['squad_id']]);
return $squad === null ? null : [
'id' => (int) $squad['id'],
'name' => $squad['name'],
'ist_fuehrer' => (int) $squad['fuehrer_id'] === (int) $zeile['id'],
];
}
/**
* Wechselt mit jedem neuen Portraet (der Dateiname ist zufaellig). Daran
* erkennt ein zweiter Rechner, dass er das Bild neu laden muss.
*/
private static function kennung(array $zeile): ?string
{
return $zeile['portraet'] === null ? null : basename((string) $zeile['portraet'], '.png');
}
/** Vollstaendige Sicht auf einen eigenen Charakter. */
public static function eigeneZeile(array $zeile): array
{
return [
'id' => (int) $zeile['id'],
'lokale_id' => $zeile['lokale_id'],
'aktennummer' => $zeile['aktennummer'],
'version' => (int) $zeile['version'],
'geaendert_am' => $zeile['geaendert_am'],
'portraet' => $zeile['portraet'] !== null,
'portraet_kennung' => self::kennung($zeile),
'squad' => self::squadKurz($zeile),
'daten' => json_decode($zeile['daten'], true) ?: new stdClass(),
];
}
/** Kurzfassung fuer die Liste aller Charaktere. $zeile braucht "spieler" aus sm_nutzer. */
public static function zusammenfassung(array $zeile, array $betrachter): array
{
return [
'id' => (int) $zeile['id'],
'aktennummer' => $zeile['aktennummer'],
'callsign' => $zeile['callsign'],
'vorname' => $zeile['vorname'],
'nachname' => $zeile['nachname'],
'rang' => $zeile['rang'],
'fraktion' => $zeile['fraktion'],
'teilstreitkraft' => $zeile['teilstreitkraft'],
'verwendung' => $zeile['verwendung'],
'status' => $zeile['status'],
'spieler' => $zeile['spieler'],
'eigener' => (int) $zeile['nutzer_id'] === (int) $betrachter['id'],
'portraet' => $zeile['portraet'] !== null,
'portraet_kennung' => self::kennung($zeile),
'squad' => self::squadKurz($zeile),
'geaendert_am' => $zeile['geaendert_am'],
];
}
public static function speichern(array $nutzer, string $lokaleId, mixed $daten,
?int $basisVersion, bool $erzwingen): array
{
if (!preg_match('/^[0-9a-f]{32}$/', $lokaleId)) {
throw new SmFehler('lokale_id_ungueltig', 'Ungültige Akten-ID.');
}
if (!is_array($daten)) {
throw new SmFehler('daten_ungueltig', 'Die Akte ist unvollständig.');
}
if (strlen((string) json_encode($daten)) > self::MAX_DATEN_BYTES) {
throw new SmFehler('akte_zu_gross', 'Die Akte ist zu groß.', 413);
}
$felder = self::felder($daten);
$nutzerId = (int) $nutzer['id'];
return DB::transaktion(function () use ($nutzerId, $lokaleId, $daten, $felder, $basisVersion, $erzwingen) {
$vorhanden = DB::eine('SELECT * FROM sm_charakter WHERE nutzer_id = ? AND lokale_id = ?'
. DB::sperre(), [$nutzerId, $lokaleId]);
if ($vorhanden !== null) {
if ($basisVersion !== null && $basisVersion !== (int) $vorhanden['version'] && !$erzwingen) {
throw new SmFehler('konflikt', 'Die Akte wurde inzwischen an anderer Stelle geändert.',
409, ['charakter' => self::eigeneZeile($vorhanden)]);
}
$id = (int) $vorhanden['id'];
$daten['aktennummer'] = $vorhanden['aktennummer'];
DB::aktualisieren('sm_charakter', $felder + [
'daten' => self::json($daten),
'version' => (int) $vorhanden['version'] + 1,
'geaendert_am' => DB::jetzt(),
], 'id = ?', [$id]);
} else {
$anzahl = (int) DB::wert('SELECT COUNT(*) FROM sm_charakter WHERE nutzer_id = ?', [$nutzerId]);
if ($anzahl >= self::MAX_JE_NUTZER) {
throw new SmFehler('zu_viele_charaktere',
'Mehr als ' . self::MAX_JE_NUTZER . ' Charaktere pro Konto sind nicht möglich.', 409);
}
$id = DB::einfuegen('sm_charakter', $felder + [
'nutzer_id' => $nutzerId,
'lokale_id' => $lokaleId,
'daten' => '{}',
'version' => 1,
'erstellt_am' => DB::jetzt(),
'geaendert_am' => DB::jetzt(),
]);
$daten['aktennummer'] = sprintf('SM-%s-%04d', gmdate('Y'), $id);
DB::aktualisieren('sm_charakter',
['aktennummer' => $daten['aktennummer'], 'daten' => self::json($daten)], 'id = ?', [$id]);
}
return self::eigeneZeile(DB::eine('SELECT * FROM sm_charakter WHERE id = ?', [$id]));
});
}
private static function json(array $daten): string
{
return json_encode($daten, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR);
}
public static function eigene(array $nutzer): array
{
$zeilen = DB::alle('SELECT * FROM sm_charakter WHERE nutzer_id = ? ORDER BY erstellt_am, id',
[$nutzer['id']]);
return array_map([self::class, 'eigeneZeile'], $zeilen);
}
private static function eigenerMitSperre(array $nutzer, string $lokaleId): array
{
$zeile = DB::eine('SELECT * FROM sm_charakter WHERE nutzer_id = ? AND lokale_id = ?' . DB::sperre(),
[$nutzer['id'], $lokaleId]);
if ($zeile === null) {
throw new SmFehler('charakter_nicht_gefunden', 'Diese Akte gibt es auf dem Server nicht.', 404);
}
return $zeile;
}
public static function loeschen(array $nutzer, string $lokaleId): void
{
DB::transaktion(function () use ($nutzer, $lokaleId) {
self::loeschenIntern(self::eigenerMitSperre($nutzer, $lokaleId));
});
}
/** Fuer die Verwaltung: Loeschen ohne Besitzpruefung. */
public static function loeschenNachId(int $id): void
{
DB::transaktion(function () use ($id) {
$zeile = DB::eine('SELECT * FROM sm_charakter WHERE id = ?' . DB::sperre(), [$id]);
if ($zeile !== null) {
self::loeschenIntern($zeile);
}
});
}
private static function loeschenIntern(array $zeile): void
{
Squads::beimLoeschen($zeile);
self::bildDateiLoeschen($zeile['portraet']);
DB::ausfuehren('DELETE FROM sm_charakter WHERE id = ?', [$zeile['id']]);
}
public static function alleVonNutzerLoeschen(int $nutzerId): void
{
foreach (DB::alle('SELECT * FROM sm_charakter WHERE nutzer_id = ?', [$nutzerId]) as $zeile) {
self::loeschenIntern($zeile);
}
}
// -- Portraets ---------------------------------------------------------
private static function bildDateiLoeschen(?string $datei): void
{
if ($datei !== null && preg_match('/^[0-9]+-[0-9a-f]{16}\.png$/', $datei)) {
@unlink(sm_daten_ordner('portraets') . '/' . $datei);
}
}
/**
* Nimmt ein Bild an und speichert es neu als PNG, hoechstens 512 Pixel.
* Das Neuzeichnen verwirft alles ausser den Bildpunkten - eingeschleuster
* Code in einer Bilddatei kommt so nicht auf den Server.
*/
public static function portraetSetzen(array $nutzer, string $lokaleId, string $base64): array
{
if (!function_exists('imagecreatefromstring')) {
throw new SmFehler('server_ohne_gd', 'Der Server kann gerade keine Bilder verarbeiten.', 500);
}
$roh = base64_decode($base64, true);
if ($roh === false || $roh === '') {
throw new SmFehler('bild_ungueltig', 'Das Bild konnte nicht gelesen werden.');
}
if (strlen($roh) > self::MAX_BILD_BYTES) {
throw new SmFehler('bild_zu_gross', 'Das Bild ist zu groß (höchstens 8 MB).', 413);
}
$info = @getimagesizefromstring($roh);
$erlaubt = [IMAGETYPE_JPEG, IMAGETYPE_PNG, IMAGETYPE_WEBP, IMAGETYPE_GIF];
if ($info === false || !in_array($info[2], $erlaubt, true)) {
throw new SmFehler('bild_ungueltig', 'Erlaubt sind JPG, PNG, WebP und GIF.');
}
if ($info[0] * $info[1] > 40_000_000) {
throw new SmFehler('bild_zu_gross', 'Das Bild hat zu viele Bildpunkte.', 413);
}
$quelle = @imagecreatefromstring($roh);
if ($quelle === false) {
throw new SmFehler('bild_ungueltig', 'Das Bild konnte nicht gelesen werden.');
}
[$breite, $hoehe] = [imagesx($quelle), imagesy($quelle)];
$faktor = min(1, self::BILD_KANTE / max($breite, $hoehe));
$nb = max(1, (int) round($breite * $faktor));
$nh = max(1, (int) round($hoehe * $faktor));
$ziel = imagecreatetruecolor($nb, $nh);
imagealphablending($ziel, false);
imagesavealpha($ziel, true);
imagefill($ziel, 0, 0, imagecolorallocatealpha($ziel, 0, 0, 0, 127));
imagecopyresampled($ziel, $quelle, 0, 0, 0, 0, $nb, $nh, $breite, $hoehe);
return DB::transaktion(function () use ($nutzer, $lokaleId, $ziel) {
$zeile = self::eigenerMitSperre($nutzer, $lokaleId);
$datei = $zeile['id'] . '-' . Sicherheit::zufall(8) . '.png';
if (!imagepng($ziel, sm_daten_ordner('portraets') . '/' . $datei, 6)) {
throw new SmFehler('bild_speichern', 'Das Bild konnte nicht gespeichert werden.', 500);
}
self::bildDateiLoeschen($zeile['portraet']);
DB::aktualisieren('sm_charakter', ['portraet' => $datei, 'geaendert_am' => DB::jetzt()],
'id = ?', [$zeile['id']]);
return self::eigeneZeile(DB::eine('SELECT * FROM sm_charakter WHERE id = ?', [$zeile['id']]));
});
}
public static function portraetEntfernen(array $nutzer, string $lokaleId): array
{
return DB::transaktion(function () use ($nutzer, $lokaleId) {
$zeile = self::eigenerMitSperre($nutzer, $lokaleId);
self::bildDateiLoeschen($zeile['portraet']);
DB::aktualisieren('sm_charakter', ['portraet' => null, 'geaendert_am' => DB::jetzt()],
'id = ?', [$zeile['id']]);
return self::eigeneZeile(DB::eine('SELECT * FROM sm_charakter WHERE id = ?', [$zeile['id']]));
});
}
/** Pfad zur Bilddatei eines Charakters oder null. */
public static function bildPfad(int $id): ?string
{
$datei = DB::wert('SELECT portraet FROM sm_charakter WHERE id = ?', [$id]);
if (!is_string($datei) || !preg_match('/^[0-9]+-[0-9a-f]{16}\.png$/', $datei)) {
return null;
}
$pfad = sm_daten_ordner('portraets') . '/' . $datei;
return is_file($pfad) ? $pfad : null;
}
// -- Fuer alle sichtbar -------------------------------------------------
private const LISTE_SQL = 'SELECT c.*, n.benutzername AS spieler
FROM sm_charakter c JOIN sm_nutzer n ON n.id = c.nutzer_id
WHERE n.gesperrt = 0';
public static function alle(array $nutzer, string $suche = '', string $fraktion = ''): array
{
$sql = self::LISTE_SQL;
$werte = [];
$suche = trim($suche);
if ($suche !== '') {
$muster = '%' . str_replace(['!', '%', '_'], ['!!', '!%', '!_'], mb_substr($suche, 0, 64)) . '%';
$sql .= " AND (c.callsign LIKE ? ESCAPE '!' OR c.vorname LIKE ? ESCAPE '!'"
. " OR c.nachname LIKE ? ESCAPE '!' OR n.benutzername LIKE ? ESCAPE '!')";
array_push($werte, $muster, $muster, $muster, $muster);
}
if (trim($fraktion) !== '') {
$sql .= ' AND c.fraktion = ?';
$werte[] = trim($fraktion);
}
$sql .= ' ORDER BY c.callsign, c.nachname, c.id LIMIT 500';
return array_map(fn($zeile) => self::zusammenfassung($zeile, $nutzer), DB::alle($sql, $werte));
}
public static function ansehen(array $nutzer, int $id): array
{
$zeile = DB::eine(self::LISTE_SQL . ' AND c.id = ?', [$id]);
if ($zeile === null) {
throw new SmFehler('charakter_nicht_gefunden', 'Diesen Charakter gibt es nicht.', 404);
}
return self::zusammenfassung($zeile, $nutzer)
+ ['daten' => json_decode($zeile['daten'], true) ?: new stdClass()];
}
}

View file

@ -0,0 +1,266 @@
<?php
/*
* Datenbankzugriff ueber PDO.
*
* Auf dem Server MySQL/MariaDB, bei den lokalen Tests SQLite. Die Abfragen
* sind so geschrieben, dass sie auf beiden laufen; die wenigen Unterschiede
* (Tabellenanlage, Zeilensperren) stecken hier.
*/
declare(strict_types=1);
final class DB
{
private static ?PDO $pdo = null;
public static function pdo(): PDO
{
if (self::$pdo === null) {
self::$pdo = new PDO(
(string) sm_config('datenbank.dsn'),
(string) sm_config('datenbank.benutzer', ''),
(string) sm_config('datenbank.passwort', ''),
[
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
PDO::ATTR_EMULATE_PREPARES => false,
],
);
if (self::sqlite()) {
self::$pdo->exec('PRAGMA foreign_keys = ON');
self::$pdo->exec('PRAGMA busy_timeout = 5000');
}
}
return self::$pdo;
}
public static function sqlite(): bool
{
return str_starts_with((string) sm_config('datenbank.dsn'), 'sqlite:');
}
public static function jetzt(int $plusSekunden = 0): string
{
return gmdate('Y-m-d H:i:s', time() + $plusSekunden);
}
public static function alle(string $sql, array $werte = []): array
{
$abfrage = self::pdo()->prepare($sql);
$abfrage->execute($werte);
return $abfrage->fetchAll();
}
public static function eine(string $sql, array $werte = []): ?array
{
$abfrage = self::pdo()->prepare($sql);
$abfrage->execute($werte);
$zeile = $abfrage->fetch();
return $zeile === false ? null : $zeile;
}
public static function wert(string $sql, array $werte = []): mixed
{
$abfrage = self::pdo()->prepare($sql);
$abfrage->execute($werte);
$wert = $abfrage->fetchColumn();
return $wert === false ? null : $wert;
}
public static function ausfuehren(string $sql, array $werte = []): int
{
$abfrage = self::pdo()->prepare($sql);
$abfrage->execute($werte);
return $abfrage->rowCount();
}
public static function einfuegen(string $tabelle, array $werte): int
{
$spalten = array_keys($werte);
$sql = sprintf('INSERT INTO %s (%s) VALUES (%s)', $tabelle,
implode(', ', $spalten), implode(', ', array_fill(0, count($spalten), '?')));
self::ausfuehren($sql, array_values($werte));
return (int) self::pdo()->lastInsertId();
}
public static function aktualisieren(string $tabelle, array $werte, string $bedingung,
array $bedingungWerte): int
{
$teile = array_map(fn($spalte) => "$spalte = ?", array_keys($werte));
$sql = sprintf('UPDATE %s SET %s WHERE %s', $tabelle, implode(', ', $teile), $bedingung);
return self::ausfuehren($sql, [...array_values($werte), ...$bedingungWerte]);
}
/** Fuehrt $arbeit in einer Transaktion aus; bei einer Ausnahme wird alles zurueckgenommen. */
public static function transaktion(callable $arbeit): mixed
{
$pdo = self::pdo();
$pdo->beginTransaction();
try {
$ergebnis = $arbeit();
$pdo->commit();
return $ergebnis;
} catch (Throwable $fehler) {
$pdo->rollBack();
throw $fehler;
}
}
/**
* Zeilensperre fuer SELECT innerhalb einer Transaktion. Verhindert etwa,
* dass zwei gleichzeitige Einladungen denselben Charakter in zwei Squads
* bringen. SQLite sperrt ohnehin die ganze Datenbank beim Schreiben.
*/
public static function sperre(): string
{
return self::sqlite() ? '' : ' FOR UPDATE';
}
/** Legt fehlende Tabellen an. Gibt die Namen aller Tabellen zurueck. */
public static function schemaAnlegen(): array
{
$sqlite = self::sqlite();
$id = $sqlite ? 'INTEGER PRIMARY KEY AUTOINCREMENT' : 'INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY';
$ref = $sqlite ? 'INTEGER' : 'INT UNSIGNED';
$lang = $sqlite ? 'TEXT' : 'MEDIUMTEXT';
$ende = $sqlite ? ')' : ') ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci';
$tabellen = [
'sm_meta' => "CREATE TABLE IF NOT EXISTS sm_meta (
schluessel VARCHAR(64) NOT NULL PRIMARY KEY,
wert TEXT NULL
$ende",
'sm_nutzer' => "CREATE TABLE IF NOT EXISTS sm_nutzer (
id $id,
benutzername VARCHAR(32) NOT NULL,
benutzername_klein VARCHAR(32) NOT NULL,
email VARCHAR(191) NULL,
passwort_hash VARCHAR(255) NULL,
rolle VARCHAR(16) NOT NULL DEFAULT 'nutzer',
email_bestaetigt_am DATETIME NULL,
gesperrt TINYINT NOT NULL DEFAULT 0,
erstellt_am DATETIME NOT NULL,
letzte_anmeldung_am DATETIME NULL,
UNIQUE (benutzername_klein),
UNIQUE (email)
$ende",
'sm_token' => "CREATE TABLE IF NOT EXISTS sm_token (
id $id,
nutzer_id $ref NOT NULL,
art VARCHAR(16) NOT NULL,
token_hash CHAR(64) NOT NULL,
geraet VARCHAR(100) NULL,
erstellt_am DATETIME NOT NULL,
laeuft_ab_am DATETIME NOT NULL,
genutzt_am DATETIME NULL,
UNIQUE (token_hash),
FOREIGN KEY (nutzer_id) REFERENCES sm_nutzer (id) ON DELETE CASCADE
$ende",
'sm_squad' => "CREATE TABLE IF NOT EXISTS sm_squad (
id $id,
name VARCHAR(48) NOT NULL,
name_klein VARCHAR(48) NOT NULL,
beschreibung TEXT NULL,
fuehrer_id $ref NULL,
erstellt_am DATETIME NOT NULL,
UNIQUE (name_klein)
$ende",
'sm_charakter' => "CREATE TABLE IF NOT EXISTS sm_charakter (
id $id,
nutzer_id $ref NOT NULL,
lokale_id CHAR(32) NOT NULL,
aktennummer VARCHAR(24) NULL,
callsign VARCHAR(64) NOT NULL DEFAULT '',
vorname VARCHAR(64) NOT NULL DEFAULT '',
nachname VARCHAR(64) NOT NULL DEFAULT '',
fraktion VARCHAR(80) NOT NULL DEFAULT '',
teilstreitkraft VARCHAR(80) NOT NULL DEFAULT '',
rang VARCHAR(120) NOT NULL DEFAULT '',
verwendung VARCHAR(80) NOT NULL DEFAULT '',
status VARCHAR(20) NOT NULL DEFAULT 'aktiv',
daten $lang NOT NULL,
portraet VARCHAR(80) NULL,
squad_id $ref NULL,
squad_seit DATETIME NULL,
version INT NOT NULL DEFAULT 1,
erstellt_am DATETIME NOT NULL,
geaendert_am DATETIME NOT NULL,
UNIQUE (nutzer_id, lokale_id),
UNIQUE (aktennummer),
FOREIGN KEY (nutzer_id) REFERENCES sm_nutzer (id) ON DELETE CASCADE,
FOREIGN KEY (squad_id) REFERENCES sm_squad (id) ON DELETE SET NULL
$ende",
'sm_einladung' => "CREATE TABLE IF NOT EXISTS sm_einladung (
id $id,
squad_id $ref NOT NULL,
charakter_id $ref NOT NULL,
von_charakter_id $ref NULL,
status VARCHAR(16) NOT NULL DEFAULT 'offen',
erstellt_am DATETIME NOT NULL,
beantwortet_am DATETIME NULL,
FOREIGN KEY (squad_id) REFERENCES sm_squad (id) ON DELETE CASCADE,
FOREIGN KEY (charakter_id) REFERENCES sm_charakter (id) ON DELETE CASCADE
$ende",
'sm_versuch' => "CREATE TABLE IF NOT EXISTS sm_versuch (
id $id,
art VARCHAR(16) NOT NULL,
schluessel CHAR(64) NOT NULL,
zeit DATETIME NOT NULL
$ende",
];
foreach ($tabellen as $sql) {
self::pdo()->exec($sql);
}
// Nicht eindeutige Indizes: SQLite kennt IF NOT EXISTS, MySQL nicht
$indizes = [
['sm_charakter', 'ix_charakter_squad', 'squad_id'],
['sm_einladung', 'ix_einladung_charakter', 'charakter_id, status'],
['sm_einladung', 'ix_einladung_squad', 'squad_id, status'],
['sm_versuch', 'ix_versuch', 'art, schluessel, zeit'],
['sm_token', 'ix_token_nutzer', 'nutzer_id, art'],
];
foreach ($indizes as [$tabelle, $name, $spalten]) {
if ($sqlite) {
self::pdo()->exec("CREATE INDEX IF NOT EXISTS $name ON $tabelle ($spalten)");
} elseif (!self::wert("SELECT COUNT(*) FROM information_schema.statistics
WHERE table_schema = DATABASE() AND table_name = ? AND index_name = ?",
[$tabelle, $name])) {
self::pdo()->exec("CREATE INDEX $name ON $tabelle ($spalten)");
}
}
if (self::wert("SELECT wert FROM sm_meta WHERE schluessel = 'schema'") === null) {
self::einfuegen('sm_meta', ['schluessel' => 'schema', 'wert' => (string) self::SCHEMA]);
}
self::migrieren();
return array_keys($tabellen);
}
public const SCHEMA = 2;
/**
* Bringt eine bestehende Datenbank auf den aktuellen Stand.
*
* Laeuft von selbst bei der ersten Anfrage nach einem Update - ohne
* einrichten.php, das nach der Ersteinrichtung geloescht sein soll. Eine
* Markerdatei im Datenordner erspart danach jede weitere Abfrage.
*
* Stand 2 (1.7.0): Konten ohne E-Mail - Mitmachen nur mit dem Schluessel
* des PCs.
*/
public static function migrieren(): void
{
$marke = sm_daten_ordner() . '/schema-' . self::SCHEMA . '.ok';
if (is_file($marke)) {
return;
}
$stand = (int) (self::wert("SELECT wert FROM sm_meta WHERE schluessel = 'schema'") ?? 1);
if ($stand < 2) {
if (!self::sqlite()) {
self::pdo()->exec('ALTER TABLE sm_nutzer MODIFY email VARCHAR(191) NULL');
}
self::ausfuehren("UPDATE sm_meta SET wert = '2' WHERE schluessel = 'schema'");
}
@file_put_contents($marke, self::jetzt());
}
}

View file

@ -0,0 +1,292 @@
<?php
/*
* Nutzerkonten: Registrierung mit E-Mail-Bestaetigung, Anmeldung,
* Passwort vergessen, Konto loeschen.
*/
declare(strict_types=1);
final class Konten
{
/** Laufzeit des Schluessels eines PCs ohne Konto: praktisch unbegrenzt. */
public const SCHLUESSEL_TAGE = 36500;
public static function oeffentlich(array $nutzer): array
{
return [
'id' => (int) $nutzer['id'],
'benutzername' => $nutzer['benutzername'],
'email' => $nutzer['email'],
'rolle' => $nutzer['rolle'],
// false: nur der Schluessel dieses PCs, keine E-Mail und kein Passwort
'gesichert' => $nutzer['email'] !== null,
'bestaetigt' => $nutzer['email_bestaetigt_am'] !== null,
];
}
private static function namePruefen(string $name, string $was = 'Der Benutzername'): string
{
$name = trim($name);
if (!preg_match('/^[A-Za-z0-9_.-]{3,32}$/', $name)) {
throw new SmFehler('benutzername_ungueltig', "$was braucht 3 bis 32 Zeichen: "
. 'Buchstaben, Ziffern, Punkt, Minus oder Unterstrich.');
}
return $name;
}
/**
* Mitmachen ohne Konto: legt einen Nutzer nur mit Spielernamen an. Das
* Token ist der Schluessel des PCs und laeuft nicht ab. Wer ihn verliert,
* kann seine Charaktere nicht mehr bearbeiten - ausser er hat das Konto
* vorher mit E-Mail und Passwort gesichert.
*/
public static function mitmachen(string $spielername, string $geraet): array
{
$name = self::namePruefen($spielername, 'Der Spielername');
Sicherheit::bremseOderFehler('mitmachen', Sicherheit::ip(), 5, 3600);
if (DB::wert('SELECT 1 FROM sm_nutzer WHERE benutzername_klein = ?', [mb_strtolower($name)])) {
throw new SmFehler('benutzername_vergeben', 'Diesen Spielernamen gibt es schon.', 409);
}
try {
$id = DB::einfuegen('sm_nutzer', [
'benutzername' => $name,
'benutzername_klein' => mb_strtolower($name),
'email' => null,
'passwort_hash' => null,
'rolle' => 'nutzer',
'gesperrt' => 0,
'erstellt_am' => DB::jetzt(),
'letzte_anmeldung_am' => DB::jetzt(),
]);
} catch (PDOException $fehler) {
if ((string) $fehler->getCode() === '23000') {
throw new SmFehler('benutzername_vergeben', 'Diesen Spielernamen gibt es schon.', 409);
}
throw $fehler;
}
$token = Sicherheit::tokenAnlegen($id, 'sitzung', self::SCHLUESSEL_TAGE * 86400, $geraet);
return ['token' => $token,
'nutzer' => self::oeffentlich(DB::eine('SELECT * FROM sm_nutzer WHERE id = ?', [$id]))];
}
/** Haengt E-Mail und Passwort an ein Konto, das bisher nur den Schluessel des PCs hatte. */
public static function kontoSichern(array $nutzer, string $email, string $passwort): array
{
if ($nutzer['email'] !== null) {
throw new SmFehler('schon_gesichert', 'Dieses Konto ist schon mit einer E-Mail-Adresse gesichert.', 409);
}
$email = mb_strtolower(trim($email));
if (strlen($email) > 191 || !filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new SmFehler('email_ungueltig', 'Die E-Mail-Adresse ist ungültig.');
}
$regel = Sicherheit::passwortRegeln($passwort);
if ($regel !== null) {
throw new SmFehler('passwort_zu_schwach', $regel);
}
Sicherheit::bremseOderFehler('sichern', Sicherheit::ip(), 5, 3600);
if (DB::wert('SELECT 1 FROM sm_nutzer WHERE email = ?', [$email])) {
throw new SmFehler('email_vergeben', 'Mit dieser E-Mail-Adresse gibt es schon ein Konto.', 409);
}
try {
DB::aktualisieren('sm_nutzer', ['email' => $email, 'passwort_hash' => Sicherheit::passwortHash($passwort)],
'id = ? AND email IS NULL', [$nutzer['id']]);
} catch (PDOException $fehler) {
if ((string) $fehler->getCode() === '23000') {
throw new SmFehler('email_vergeben', 'Mit dieser E-Mail-Adresse gibt es schon ein Konto.', 409);
}
throw $fehler;
}
self::bestaetigungSenden((int) $nutzer['id'], $nutzer['benutzername'], $email);
return self::oeffentlich(DB::eine('SELECT * FROM sm_nutzer WHERE id = ?', [$nutzer['id']]));
}
public static function link(string $pfad): string
{
return rtrim((string) sm_config('basis_url', 'https://sva.tyrveil.com'), '/') . $pfad;
}
public static function registrieren(string $benutzername, string $email, string $passwort): void
{
$benutzername = trim($benutzername);
$email = mb_strtolower(trim($email));
if (!preg_match('/^[A-Za-z0-9_.-]{3,32}$/', $benutzername)) {
throw new SmFehler('benutzername_ungueltig', 'Der Benutzername braucht 3 bis 32 Zeichen: '
. 'Buchstaben, Ziffern, Punkt, Minus oder Unterstrich.');
}
if (strlen($email) > 191 || !filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new SmFehler('email_ungueltig', 'Die E-Mail-Adresse ist ungültig.');
}
$regel = Sicherheit::passwortRegeln($passwort);
if ($regel !== null) {
throw new SmFehler('passwort_zu_schwach', $regel);
}
Sicherheit::bremseOderFehler('registrieren', Sicherheit::ip(), 5, 3600);
if (DB::wert('SELECT 1 FROM sm_nutzer WHERE benutzername_klein = ?', [mb_strtolower($benutzername)])) {
throw new SmFehler('benutzername_vergeben', 'Dieser Benutzername ist schon vergeben.', 409);
}
if (DB::wert('SELECT 1 FROM sm_nutzer WHERE email = ?', [$email])) {
throw new SmFehler('email_vergeben',
'Mit dieser E-Mail-Adresse gibt es schon ein Konto. Passwort vergessen?', 409);
}
try {
$id = DB::einfuegen('sm_nutzer', [
'benutzername' => $benutzername,
'benutzername_klein' => mb_strtolower($benutzername),
'email' => $email,
'passwort_hash' => Sicherheit::passwortHash($passwort),
'rolle' => 'nutzer',
'gesperrt' => 0,
'erstellt_am' => DB::jetzt(),
]);
} catch (PDOException $fehler) {
// Zwei gleichzeitige Registrierungen mit demselben Namen
if ((string) $fehler->getCode() === '23000') {
throw new SmFehler('benutzername_vergeben', 'Benutzername oder E-Mail ist schon vergeben.', 409);
}
throw $fehler;
}
self::bestaetigungSenden($id, $benutzername, $email);
}
private static function bestaetigungSenden(int $nutzerId, string $benutzername, string $email): void
{
Sicherheit::alleTokenLoeschen($nutzerId, 'bestaetigung');
$token = Sicherheit::tokenAnlegen($nutzerId, 'bestaetigung', 48 * 3600);
$link = self::link('/konto/bestaetigen.php?t=' . $token);
Mail::senden($email, 'Squad Manager: E-Mail-Adresse bestätigen',
"Hallo $benutzername,\n\n"
. "bitte bestätige deine E-Mail-Adresse, damit du dich im Squad Manager anmelden kannst:\n\n"
. "$link\n\n"
. "Der Link ist 48 Stunden gültig. Hast du kein Konto angelegt, ignoriere diese Mail einfach."
. Mail::fusszeile());
}
public static function bestaetigen(string $token): array
{
$zeile = Sicherheit::tokenFinden($token, 'bestaetigung');
if ($zeile === null) {
throw new SmFehler('link_ungueltig', 'Dieser Link ist ungültig oder abgelaufen.', 404);
}
if ($zeile['email_bestaetigt_am'] === null) {
DB::aktualisieren('sm_nutzer', ['email_bestaetigt_am' => DB::jetzt()], 'id = ?', [$zeile['id']]);
}
Sicherheit::tokenLoeschen((int) $zeile['token_id']);
return $zeile;
}
/** Antwortet immer gleich, damit sich nicht erraten laesst, welche Adressen registriert sind. */
public static function bestaetigungErneut(string $email): void
{
$email = mb_strtolower(trim($email));
Sicherheit::bremseOderFehler('bestaetigung', Sicherheit::ip(), 5, 3600);
$nutzer = DB::eine('SELECT * FROM sm_nutzer WHERE email = ?', [$email]);
if ($nutzer && $nutzer['email_bestaetigt_am'] === null && !(int) $nutzer['gesperrt']
&& Sicherheit::bremse('bestaetigung_mail', $email, 3, 3600)) {
self::bestaetigungSenden((int) $nutzer['id'], $nutzer['benutzername'], $nutzer['email']);
}
}
public static function anmelden(string $login, string $passwort, string $geraet): array
{
$login = mb_strtolower(trim($login));
Sicherheit::bremseOderFehler('anmelden', Sicherheit::ip() . '|' . $login, 10, 900);
$nutzer = DB::eine('SELECT * FROM sm_nutzer WHERE benutzername_klein = ? OR email = ?', [$login, $login]);
$hash = $nutzer['passwort_hash'] ?? null;
// Auch ohne Nutzer einen echten Hash pruefen, sonst verraet die
// Antwortzeit, welche Namen existieren
$passt = password_verify($passwort, $hash ?? password_hash('platzhalter', PASSWORD_DEFAULT));
if (!$nutzer || $hash === null || !$passt) {
throw new SmFehler('anmeldung_falsch', 'Benutzername oder Passwort stimmt nicht.', 401);
}
if ((int) $nutzer['gesperrt'] === 1) {
throw new SmFehler('gesperrt', 'Dieses Konto ist gesperrt.', 403);
}
if ($nutzer['email_bestaetigt_am'] === null) {
throw new SmFehler('nicht_bestaetigt',
'Bitte bestätige zuerst deine E-Mail-Adresse – der Link steht in der Mail von uns.', 403);
}
if (password_needs_rehash($hash, PASSWORD_DEFAULT)) {
DB::aktualisieren('sm_nutzer', ['passwort_hash' => Sicherheit::passwortHash($passwort)],
'id = ?', [$nutzer['id']]);
}
Sicherheit::bremseLoesen('anmelden', Sicherheit::ip() . '|' . $login);
$token = Sicherheit::tokenAnlegen((int) $nutzer['id'], 'sitzung',
Sicherheit::SITZUNG_TAGE * 86400, $geraet);
DB::aktualisieren('sm_nutzer', ['letzte_anmeldung_am' => DB::jetzt()], 'id = ?', [$nutzer['id']]);
return ['token' => $token, 'nutzer' => self::oeffentlich($nutzer)];
}
public static function abmelden(array $nutzer): void
{
Sicherheit::tokenLoeschen((int) $nutzer['token_id']);
}
public static function passwortVergessen(string $email): void
{
$email = mb_strtolower(trim($email));
Sicherheit::bremseOderFehler('vergessen', Sicherheit::ip(), 5, 3600);
$nutzer = DB::eine('SELECT * FROM sm_nutzer WHERE email = ?', [$email]);
if ($nutzer && !(int) $nutzer['gesperrt'] && Sicherheit::bremse('vergessen_mail', $email, 3, 3600)) {
self::passwortLinkSenden($nutzer, 3600,
"jemand – hoffentlich du – möchte das Passwort für deinen Squad Manager-Zugang zurücksetzen.\n\n"
. "Neues Passwort festlegen:\n\n%LINK%\n\n"
. "Der Link ist eine Stunde gültig. Warst du das nicht, ignoriere diese Mail; "
. "dein Passwort bleibt dann unverändert.");
}
}
/** Verschickt einen Link zum Passwort-Setzen. Gibt den Link zurueck (fuer die Einrichtung). */
public static function passwortLinkSenden(array $nutzer, int $gueltigSekunden, string $text): string
{
Sicherheit::alleTokenLoeschen((int) $nutzer['id'], 'passwort');
$token = Sicherheit::tokenAnlegen((int) $nutzer['id'], 'passwort', $gueltigSekunden);
$link = self::link('/konto/passwort.php?t=' . $token);
Mail::senden($nutzer['email'], 'Squad Manager: Passwort festlegen',
"Hallo {$nutzer['benutzername']},\n\n" . str_replace('%LINK%', $link, $text) . Mail::fusszeile());
return $link;
}
public static function passwortSetzen(string $token, string $passwort): array
{
$zeile = Sicherheit::tokenFinden($token, 'passwort');
if ($zeile === null) {
throw new SmFehler('link_ungueltig', 'Dieser Link ist ungültig oder abgelaufen.', 404);
}
$regel = Sicherheit::passwortRegeln($passwort);
if ($regel !== null) {
throw new SmFehler('passwort_zu_schwach', $regel);
}
DB::transaktion(function () use ($zeile, $passwort) {
// Wer den Link aus der Mail nutzt, hat die Adresse damit auch bestaetigt
DB::aktualisieren('sm_nutzer', [
'passwort_hash' => Sicherheit::passwortHash($passwort),
'email_bestaetigt_am' => $zeile['email_bestaetigt_am'] ?? DB::jetzt(),
], 'id = ?', [$zeile['id']]);
Sicherheit::alleTokenLoeschen((int) $zeile['id'], 'passwort');
Sicherheit::alleTokenLoeschen((int) $zeile['id'], 'sitzung');
});
return $zeile;
}
public static function kontoLoeschen(array $nutzer, string $passwort): void
{
// Ohne Passwort (nur Schluessel) ist der Schluessel selbst der Nachweis
if ($nutzer['passwort_hash'] !== null && !password_verify($passwort, $nutzer['passwort_hash'])) {
throw new SmFehler('anmeldung_falsch', 'Das Passwort stimmt nicht.', 401);
}
if ($nutzer['rolle'] === 'admin') {
throw new SmFehler('admin', 'Der Verwaltungszugang lässt sich nicht selbst löschen.', 403);
}
self::loeschen((int) $nutzer['id']);
}
/** Loescht Konto samt Charakteren; Squads werden dabei weitergegeben oder aufgeloest. */
public static function loeschen(int $nutzerId): void
{
DB::transaktion(function () use ($nutzerId) {
Charaktere::alleVonNutzerLoeschen($nutzerId);
DB::ausfuehren('DELETE FROM sm_nutzer WHERE id = ?', [$nutzerId]);
});
}
}

View file

@ -0,0 +1,121 @@
<?php
/*
* E-Mail-Versand fuer Bestaetigung und Passwort.
*
* Standard ist PHPs mail(): Auf Plesk geht das an den lokalen Mailserver,
* der fuer die eigene Domain signiert und zustellt - ohne Postfach-Passwort
* in config.php. SMTP ist als Ausweg eingebaut, "datei" schreibt die Mails
* nur in einen Ordner (fuer Tests).
*/
declare(strict_types=1);
final class Mail
{
public static function senden(string $an, string $betreff, string $text): bool
{
$absender = (string) sm_config('mail.absender', 'info@tyrveil.com');
$name = (string) sm_config('mail.absender_name', 'Squad Manager');
$kopf = [
'From' => sprintf('%s <%s>', mb_encode_mimeheader($name, 'UTF-8', 'Q'), $absender),
'Reply-To' => $absender,
'MIME-Version' => '1.0',
'Content-Type' => 'text/plain; charset=UTF-8',
'Content-Transfer-Encoding' => 'quoted-printable',
'X-Mailer' => 'Squad Manager',
];
$betreffKodiert = mb_encode_mimeheader($betreff, 'UTF-8', 'Q');
$inhalt = quoted_printable_encode(str_replace(["\r\n", "\r"], "\n", $text));
try {
return match ((string) sm_config('mail.art', 'php_mail')) {
'datei' => self::alsDatei($an, $betreffKodiert, $kopf, $inhalt),
'smtp' => self::ueberSmtp($an, $betreffKodiert, $kopf, $inhalt, $absender),
default => mail($an, $betreffKodiert, str_replace("\n", "\r\n", $inhalt),
$kopf, '-f' . $absender),
};
} catch (Throwable $fehler) {
sm_log('Mailversand an ' . $an . ' gescheitert: ' . $fehler->getMessage());
return false;
}
}
private static function alsDatei(string $an, string $betreff, array $kopf, string $inhalt): bool
{
$zeilen = ["To: $an", "Subject: $betreff"];
foreach ($kopf as $schluessel => $wert) {
$zeilen[] = "$schluessel: $wert";
}
$datei = sm_daten_ordner('mails') . '/' . gmdate('Ymd-His') . '-' . Sicherheit::zufall(4) . '.eml';
return file_put_contents($datei, implode("\r\n", $zeilen) . "\r\n\r\n" . $inhalt) !== false;
}
private static function ueberSmtp(string $an, string $betreff, array $kopf, string $inhalt,
string $absender): bool
{
$host = (string) sm_config('mail.smtp.host', 'localhost');
$port = (int) sm_config('mail.smtp.port', 587);
$art = (string) sm_config('mail.smtp.verschluesselung', 'tls');
$adresse = ($art === 'ssl' ? 'ssl://' : 'tcp://') . "$host:$port";
$verbindung = @stream_socket_client($adresse, $nr, $meldung, 15);
if ($verbindung === false) {
throw new RuntimeException("SMTP-Verbindung zu $adresse: $meldung");
}
stream_set_timeout($verbindung, 15);
$lesen = function (int $erwartet) use ($verbindung): string {
$antwort = '';
while (($zeile = fgets($verbindung, 1024)) !== false) {
$antwort .= $zeile;
if (strlen($zeile) < 4 || $zeile[3] === ' ') {
break;
}
}
if ((int) substr($antwort, 0, 3) !== $erwartet) {
throw new RuntimeException('SMTP: ' . trim($antwort));
}
return $antwort;
};
$schreiben = function (string $befehl, int $erwartet) use ($verbindung, $lesen): string {
fwrite($verbindung, $befehl . "\r\n");
return $lesen($erwartet);
};
$lesen(220);
$schreiben('EHLO sva.tyrveil.com', 250);
if ($art === 'tls') {
$schreiben('STARTTLS', 220);
if (!stream_socket_enable_crypto($verbindung, true, STREAM_CRYPTO_METHOD_TLS_CLIENT)) {
throw new RuntimeException('SMTP: STARTTLS gescheitert');
}
$schreiben('EHLO sva.tyrveil.com', 250);
}
$benutzer = (string) sm_config('mail.smtp.benutzer', '');
if ($benutzer !== '') {
$schreiben('AUTH LOGIN', 334);
$schreiben(base64_encode($benutzer), 334);
$schreiben(base64_encode((string) sm_config('mail.smtp.passwort', '')), 235);
}
$schreiben("MAIL FROM:<$absender>", 250);
$schreiben("RCPT TO:<$an>", 250);
$schreiben('DATA', 354);
$nachricht = ["To: $an", "Subject: $betreff", 'Date: ' . date(DATE_RFC2822)];
foreach ($kopf as $schluessel => $wert) {
$nachricht[] = "$schluessel: $wert";
}
$daten = implode("\r\n", $nachricht) . "\r\n\r\n" . str_replace("\n", "\r\n", $inhalt);
// Punkt am Zeilenanfang verdoppeln, sonst endet DATA vorzeitig
$daten = preg_replace('/^\./m', '..', $daten);
$schreiben($daten . "\r\n.", 250);
fwrite($verbindung, "QUIT\r\n");
fclose($verbindung);
return true;
}
public static function fusszeile(): string
{
return "\n\n-- \nSquad Manager · " . sm_config('basis_url', 'https://sva.tyrveil.com')
. "\nImpressum und Datenschutz: "
. sm_config('rechtliches_url', 'https://tyrveil.com/rechtliches#impressum');
}
}

View file

@ -0,0 +1,145 @@
<?php
/*
* Token, Passwoerter und Bremsen gegen Durchprobieren und Spam.
*
* Token werden nur als SHA-256-Hash gespeichert: Wer die Datenbank liest,
* kann sich damit nicht anmelden. Passwoerter mit password_hash().
*/
declare(strict_types=1);
final class Sicherheit
{
public const SITZUNG_TAGE = 180;
public const PASSWORT_MIN = 10;
public static function zufall(int $bytes = 32): string
{
return bin2hex(random_bytes($bytes));
}
public static function hash(string $token): string
{
return hash('sha256', $token);
}
/** Legt ein Token an und gibt es im Klartext zurueck - nur dieses eine Mal. */
public static function tokenAnlegen(int $nutzerId, string $art, int $gueltigSekunden,
?string $geraet = null): string
{
$token = self::zufall();
DB::einfuegen('sm_token', [
'nutzer_id' => $nutzerId,
'art' => $art,
'token_hash' => self::hash($token),
'geraet' => $geraet === null ? null : mb_substr($geraet, 0, 100),
'erstellt_am' => DB::jetzt(),
'laeuft_ab_am' => DB::jetzt($gueltigSekunden),
]);
return $token;
}
/** Gueltiges Token samt Nutzer, sonst null. */
public static function tokenFinden(string $token, string $art): ?array
{
if (!preg_match('/^[0-9a-f]{64}$/', $token)) {
return null;
}
return DB::eine(
'SELECT t.id AS token_id, t.laeuft_ab_am, t.genutzt_am, n.*
FROM sm_token t JOIN sm_nutzer n ON n.id = t.nutzer_id
WHERE t.token_hash = ? AND t.art = ? AND t.laeuft_ab_am > ?',
[self::hash($token), $art, DB::jetzt()]);
}
public static function tokenLoeschen(int $tokenId): void
{
DB::ausfuehren('DELETE FROM sm_token WHERE id = ?', [$tokenId]);
}
public static function alleTokenLoeschen(int $nutzerId, string $art): void
{
DB::ausfuehren('DELETE FROM sm_token WHERE nutzer_id = ? AND art = ?', [$nutzerId, $art]);
}
/**
* Prueft das Sitzungstoken des Programms. Wer das Programm regelmaessig
* nutzt, bleibt angemeldet: Die Laufzeit verlaengert sich, hoechstens
* einmal am Tag geschrieben.
*/
public static function sitzung(string $token): ?array
{
$zeile = self::tokenFinden($token, 'sitzung');
if ($zeile === null || (int) $zeile['gesperrt'] === 1) {
return null;
}
if ($zeile['genutzt_am'] === null || $zeile['genutzt_am'] < DB::jetzt(-86400)) {
// Nie verkuerzen: Der Schluessel eines PCs ohne Konto laeuft gar nicht ab
$neu = max((string) $zeile['laeuft_ab_am'], DB::jetzt(self::SITZUNG_TAGE * 86400));
DB::aktualisieren('sm_token', ['genutzt_am' => DB::jetzt(), 'laeuft_ab_am' => $neu],
'id = ?', [$zeile['token_id']]);
}
return $zeile;
}
public static function passwortRegeln(string $passwort): ?string
{
if (mb_strlen($passwort) < self::PASSWORT_MIN) {
return 'Das Passwort braucht mindestens ' . self::PASSWORT_MIN . ' Zeichen.';
}
if (strlen($passwort) > 200) {
return 'Das Passwort ist zu lang.';
}
return null;
}
public static function passwortHash(string $passwort): string
{
return password_hash($passwort, PASSWORD_DEFAULT);
}
public static function ip(): string
{
return (string) ($_SERVER['REMOTE_ADDR'] ?? '0.0.0.0');
}
/**
* Zaehlt Versuche je Art und Schluessel (etwa IP oder E-Mail) im
* Zeitfenster. Gibt false zurueck, wenn das Limit erreicht ist - dann
* wird auch nichts mehr gezaehlt.
*/
public static function bremse(string $art, string $wer, int $max, int $fensterSekunden): bool
{
$schluessel = self::hash($art . '|' . $wer);
$anzahl = (int) DB::wert(
'SELECT COUNT(*) FROM sm_versuch WHERE art = ? AND schluessel = ? AND zeit > ?',
[$art, $schluessel, DB::jetzt(-$fensterSekunden)]);
if ($anzahl >= $max) {
return false;
}
DB::einfuegen('sm_versuch', ['art' => $art, 'schluessel' => $schluessel, 'zeit' => DB::jetzt()]);
if (random_int(1, 50) === 1) {
self::aufraeumen();
}
return true;
}
public static function bremseLoesen(string $art, string $wer): void
{
DB::ausfuehren('DELETE FROM sm_versuch WHERE art = ? AND schluessel = ?',
[$art, self::hash($art . '|' . $wer)]);
}
public static function bremseOderFehler(string $art, string $wer, int $max, int $fenster): void
{
if (!self::bremse($art, $wer, $max, $fenster)) {
throw new SmFehler('zu_viele_versuche',
'Zu viele Versuche. Bitte warte einige Minuten.', 429);
}
}
public static function aufraeumen(): void
{
DB::ausfuehren('DELETE FROM sm_versuch WHERE zeit < ?', [DB::jetzt(-86400)]);
DB::ausfuehren('DELETE FROM sm_token WHERE laeuft_ab_am < ?', [DB::jetzt()]);
}
}

View file

@ -0,0 +1,317 @@
<?php
/*
* Squads: Ein Charakter gruendet ein Squad und fuehrt es. Er laedt andere
* Charaktere ein, deren Spieler annehmen muessen. Jeder Charakter ist in
* hoechstens einem Squad.
*
* Alle Aenderungen laufen in Transaktionen mit Zeilensperre, damit etwa zwei
* gleichzeitig angenommene Einladungen einen Charakter nicht doppelt
* zuordnen.
*/
declare(strict_types=1);
final class Squads
{
public const MAX_OFFENE_EINLADUNGEN = 30;
private static function eigenerCharakter(array $nutzer, int $charakterId): array
{
$zeile = DB::eine('SELECT * FROM sm_charakter WHERE id = ? AND nutzer_id = ?' . DB::sperre(),
[$charakterId, $nutzer['id']]);
if ($zeile === null) {
throw new SmFehler('charakter_nicht_gefunden',
'Diesen Charakter gibt es nicht oder er gehört dir nicht.', 404);
}
return $zeile;
}
private static function squadMitSperre(int $squadId): array
{
$squad = DB::eine('SELECT * FROM sm_squad WHERE id = ?' . DB::sperre(), [$squadId]);
if ($squad === null) {
throw new SmFehler('squad_nicht_gefunden', 'Dieses Squad gibt es nicht mehr.', 404);
}
return $squad;
}
private static function alsFuehrer(array $nutzer, int $squadId): array
{
$squad = self::squadMitSperre($squadId);
if (!DB::wert('SELECT 1 FROM sm_charakter WHERE id = ? AND nutzer_id = ?',
[$squad['fuehrer_id'], $nutzer['id']])) {
throw new SmFehler('kein_fuehrer', 'Das kann nur der Squadführer.', 403);
}
return $squad;
}
private static function name(string $name): string
{
$name = trim(preg_replace('/\s+/u', ' ', $name) ?? '');
if (mb_strlen($name) < 3 || mb_strlen($name) > 48 || preg_match('/[\x00-\x1F\x7F]/u', $name)) {
throw new SmFehler('name_ungueltig', 'Der Squadname braucht 3 bis 48 Zeichen.');
}
return $name;
}
public static function gruenden(array $nutzer, int $charakterId, string $name,
string $beschreibung = ''): array
{
$name = self::name($name);
return DB::transaktion(function () use ($nutzer, $charakterId, $name, $beschreibung) {
$charakter = self::eigenerCharakter($nutzer, $charakterId);
if ($charakter['squad_id'] !== null) {
throw new SmFehler('bereits_im_squad', 'Dieser Charakter ist schon in einem Squad.', 409);
}
if (DB::wert('SELECT 1 FROM sm_squad WHERE name_klein = ?', [mb_strtolower($name)])) {
throw new SmFehler('name_vergeben', 'Diesen Squadnamen gibt es schon.', 409);
}
$id = DB::einfuegen('sm_squad', [
'name' => $name,
'name_klein' => mb_strtolower($name),
'beschreibung' => mb_substr(trim($beschreibung), 0, 2000),
'fuehrer_id' => $charakterId,
'erstellt_am' => DB::jetzt(),
]);
DB::aktualisieren('sm_charakter', ['squad_id' => $id, 'squad_seit' => DB::jetzt()],
'id = ?', [$charakterId]);
self::hinfaellig($charakterId);
return self::details($nutzer, $id);
});
}
public static function einladen(array $nutzer, int $squadId, int $charakterId): array
{
return DB::transaktion(function () use ($nutzer, $squadId, $charakterId) {
$squad = self::alsFuehrer($nutzer, $squadId);
$ziel = DB::eine('SELECT c.* FROM sm_charakter c JOIN sm_nutzer n ON n.id = c.nutzer_id
WHERE c.id = ? AND n.gesperrt = 0' . DB::sperre(), [$charakterId]);
if ($ziel === null) {
throw new SmFehler('charakter_nicht_gefunden', 'Diesen Charakter gibt es nicht.', 404);
}
if ($ziel['squad_id'] !== null) {
throw new SmFehler('bereits_im_squad', 'Dieser Charakter ist schon in einem Squad.', 409);
}
if (DB::wert("SELECT 1 FROM sm_einladung WHERE squad_id = ? AND charakter_id = ? AND status = 'offen'",
[$squadId, $charakterId])) {
throw new SmFehler('schon_eingeladen', 'Dieser Charakter ist schon eingeladen.', 409);
}
if ((int) DB::wert("SELECT COUNT(*) FROM sm_einladung WHERE squad_id = ? AND status = 'offen'",
[$squadId]) >= self::MAX_OFFENE_EINLADUNGEN) {
throw new SmFehler('zu_viele_einladungen', 'Zu viele offene Einladungen.', 409);
}
$id = DB::einfuegen('sm_einladung', [
'squad_id' => $squadId,
'charakter_id' => $charakterId,
'von_charakter_id' => $squad['fuehrer_id'],
'status' => 'offen',
'erstellt_am' => DB::jetzt(),
]);
return self::einladungDarstellen(DB::eine('SELECT * FROM sm_einladung WHERE id = ?', [$id]));
});
}
private static function charakterKurz(?int $id): ?array
{
if ($id === null) {
return null;
}
$zeile = DB::eine('SELECT c.id, c.callsign, c.vorname, c.nachname, c.rang, c.status,
n.benutzername AS spieler
FROM sm_charakter c JOIN sm_nutzer n ON n.id = c.nutzer_id WHERE c.id = ?', [$id]);
return $zeile === null ? null : ['id' => (int) $zeile['id']] + $zeile;
}
private static function einladungDarstellen(array $zeile): array
{
$squad = DB::eine('SELECT id, name FROM sm_squad WHERE id = ?', [$zeile['squad_id']]);
return [
'id' => (int) $zeile['id'],
'status' => $zeile['status'],
'erstellt_am' => $zeile['erstellt_am'],
'squad' => $squad === null ? null : ['id' => (int) $squad['id'], 'name' => $squad['name']],
'charakter' => self::charakterKurz((int) $zeile['charakter_id']),
'von' => self::charakterKurz($zeile['von_charakter_id'] === null ? null : (int) $zeile['von_charakter_id']),
];
}
/** Offene Einladungen an eigene Charaktere und von eigenen Squads. */
public static function einladungen(array $nutzer): array
{
$eingang = DB::alle("SELECT e.* FROM sm_einladung e JOIN sm_charakter c ON c.id = e.charakter_id
WHERE c.nutzer_id = ? AND e.status = 'offen' ORDER BY e.erstellt_am", [$nutzer['id']]);
$ausgang = DB::alle("SELECT e.* FROM sm_einladung e
JOIN sm_squad s ON s.id = e.squad_id
JOIN sm_charakter f ON f.id = s.fuehrer_id
WHERE f.nutzer_id = ? AND e.status = 'offen' ORDER BY e.erstellt_am", [$nutzer['id']]);
return [
'eingang' => array_map([self::class, 'einladungDarstellen'], $eingang),
'ausgang' => array_map([self::class, 'einladungDarstellen'], $ausgang),
];
}
private static function einladungMitSperre(int $einladungId): array
{
$einladung = DB::eine('SELECT * FROM sm_einladung WHERE id = ?' . DB::sperre(), [$einladungId]);
if ($einladung === null || $einladung['status'] !== 'offen') {
throw new SmFehler('einladung_nicht_offen', 'Diese Einladung ist nicht mehr offen.', 409);
}
return $einladung;
}
public static function beantworten(array $nutzer, int $einladungId, bool $annehmen): void
{
DB::transaktion(function () use ($nutzer, $einladungId, $annehmen) {
$einladung = self::einladungMitSperre($einladungId);
$charakter = self::eigenerCharakter($nutzer, (int) $einladung['charakter_id']);
if ($annehmen) {
if ($charakter['squad_id'] !== null) {
throw new SmFehler('bereits_im_squad',
'Dieser Charakter ist schon in einem Squad. Verlasse es zuerst.', 409);
}
self::squadMitSperre((int) $einladung['squad_id']);
DB::aktualisieren('sm_charakter',
['squad_id' => $einladung['squad_id'], 'squad_seit' => DB::jetzt()],
'id = ?', [$charakter['id']]);
}
DB::aktualisieren('sm_einladung',
['status' => $annehmen ? 'angenommen' : 'abgelehnt', 'beantwortet_am' => DB::jetzt()],
'id = ?', [$einladungId]);
if ($annehmen) {
self::hinfaellig((int) $charakter['id']);
}
});
}
/** Weitere offene Einladungen eines Charakters, der gerade einem Squad beigetreten ist. */
private static function hinfaellig(int $charakterId): void
{
DB::ausfuehren("UPDATE sm_einladung SET status = 'hinfaellig', beantwortet_am = ?
WHERE charakter_id = ? AND status = 'offen'", [DB::jetzt(), $charakterId]);
}
public static function zurueckziehen(array $nutzer, int $einladungId): void
{
DB::transaktion(function () use ($nutzer, $einladungId) {
$einladung = self::einladungMitSperre($einladungId);
self::alsFuehrer($nutzer, (int) $einladung['squad_id']);
DB::aktualisieren('sm_einladung', ['status' => 'zurueckgezogen', 'beantwortet_am' => DB::jetzt()],
'id = ?', [$einladungId]);
});
}
public static function verlassen(array $nutzer, int $charakterId): void
{
DB::transaktion(function () use ($nutzer, $charakterId) {
$charakter = self::eigenerCharakter($nutzer, $charakterId);
if ($charakter['squad_id'] === null) {
throw new SmFehler('nicht_im_squad', 'Dieser Charakter ist in keinem Squad.', 409);
}
$squad = self::squadMitSperre((int) $charakter['squad_id']);
if ((int) $squad['fuehrer_id'] === $charakterId) {
$weitere = (int) DB::wert('SELECT COUNT(*) FROM sm_charakter WHERE squad_id = ? AND id <> ?',
[$squad['id'], $charakterId]);
if ($weitere > 0) {
throw new SmFehler('fuehrer_muss_uebergeben',
'Als Squadführer musst du zuerst die Führung übergeben oder das Squad auflösen.', 409);
}
self::aufloesenIntern((int) $squad['id']);
return;
}
DB::aktualisieren('sm_charakter', ['squad_id' => null, 'squad_seit' => null], 'id = ?', [$charakterId]);
});
}
public static function entfernen(array $nutzer, int $squadId, int $charakterId): void
{
DB::transaktion(function () use ($nutzer, $squadId, $charakterId) {
$squad = self::alsFuehrer($nutzer, $squadId);
if ((int) $squad['fuehrer_id'] === $charakterId) {
throw new SmFehler('fuehrer', 'Der Squadführer kann sich nicht selbst entfernen.', 409);
}
$anzahl = DB::aktualisieren('sm_charakter', ['squad_id' => null, 'squad_seit' => null],
'id = ? AND squad_id = ?', [$charakterId, $squadId]);
if ($anzahl === 0) {
throw new SmFehler('nicht_im_squad', 'Dieser Charakter ist nicht in deinem Squad.', 409);
}
});
}
public static function fuehrungUebergeben(array $nutzer, int $squadId, int $charakterId): void
{
DB::transaktion(function () use ($nutzer, $squadId, $charakterId) {
self::alsFuehrer($nutzer, $squadId);
if (!DB::wert('SELECT 1 FROM sm_charakter WHERE id = ? AND squad_id = ?', [$charakterId, $squadId])) {
throw new SmFehler('nicht_im_squad', 'Dieser Charakter ist nicht in deinem Squad.', 409);
}
DB::aktualisieren('sm_squad', ['fuehrer_id' => $charakterId], 'id = ?', [$squadId]);
});
}
public static function aufloesen(array $nutzer, int $squadId): void
{
DB::transaktion(function () use ($nutzer, $squadId) {
self::alsFuehrer($nutzer, $squadId);
self::aufloesenIntern($squadId);
});
}
/** Fuer die Verwaltung. */
public static function aufloesenNachId(int $squadId): void
{
DB::transaktion(fn() => self::aufloesenIntern($squadId));
}
private static function aufloesenIntern(int $squadId): void
{
DB::ausfuehren('UPDATE sm_charakter SET squad_id = NULL, squad_seit = NULL WHERE squad_id = ?', [$squadId]);
DB::ausfuehren('DELETE FROM sm_einladung WHERE squad_id = ?', [$squadId]);
DB::ausfuehren('DELETE FROM sm_squad WHERE id = ?', [$squadId]);
}
/**
* Ein Charakter wird geloescht. Fuehrt er ein Squad, uebernimmt das
* dienstaelteste Mitglied; ist er allein, wird das Squad aufgeloest.
*/
public static function beimLoeschen(array $charakter): void
{
if ($charakter['squad_id'] === null) {
return;
}
$squad = DB::eine('SELECT * FROM sm_squad WHERE id = ?' . DB::sperre(), [$charakter['squad_id']]);
if ($squad === null || (int) $squad['fuehrer_id'] !== (int) $charakter['id']) {
return;
}
$nachfolger = DB::wert('SELECT id FROM sm_charakter WHERE squad_id = ? AND id <> ?
ORDER BY squad_seit, id LIMIT 1', [$squad['id'], $charakter['id']]);
if ($nachfolger === null) {
self::aufloesenIntern((int) $squad['id']);
} else {
DB::aktualisieren('sm_squad', ['fuehrer_id' => (int) $nachfolger], 'id = ?', [$squad['id']]);
}
}
public static function details(array $nutzer, int $squadId): array
{
$squad = DB::eine('SELECT * FROM sm_squad WHERE id = ?', [$squadId]);
if ($squad === null) {
throw new SmFehler('squad_nicht_gefunden', 'Dieses Squad gibt es nicht mehr.', 404);
}
$mitglieder = DB::alle('SELECT c.*, n.benutzername AS spieler
FROM sm_charakter c JOIN sm_nutzer n ON n.id = c.nutzer_id
WHERE c.squad_id = ? ORDER BY c.squad_seit, c.id', [$squadId]);
return [
'id' => (int) $squad['id'],
'name' => $squad['name'],
'beschreibung' => (string) $squad['beschreibung'],
'fuehrer_id' => (int) $squad['fuehrer_id'],
'erstellt_am' => $squad['erstellt_am'],
'mitglieder' => array_map(fn($zeile) => Charaktere::zusammenfassung($zeile, $nutzer), $mitglieder),
];
}
public static function liste(array $nutzer): array
{
$ids = DB::alle('SELECT id FROM sm_squad ORDER BY name');
return array_map(fn($zeile) => self::details($nutzer, (int) $zeile['id']), $ids);
}
}

View file

@ -0,0 +1,75 @@
<?php
/*
* Gemeinsamer Einstieg fuer alle Seiten und die Schnittstelle.
*
* Liegt ausserhalb des Web-Verzeichnisses. Die oeffentlichen Dateien unter
* /sva.tyrveil.com binden nur diese Datei ein; Logik, config.php und die
* Portraets sind so nicht ueber das Web abrufbar.
*/
declare(strict_types=1);
const SM_API_VERSION = 1;
const SM_STATUS = ['aktiv', 'verwundet', 'vermisst', 'gefallen', 'außer Dienst'];
define('SM_PRIVAT', dirname(__DIR__));
$smConfigPfad = SM_PRIVAT . '/config.php';
if (!is_file($smConfigPfad)) {
http_response_code(503);
header('Content-Type: text/plain; charset=utf-8');
exit("Squad Manager ist noch nicht eingerichtet: config.php fehlt im Ordner sva-privat.\n");
}
$GLOBALS['SM_CONFIG'] = require $smConfigPfad;
unset($smConfigPfad);
/** Liest einen Wert aus config.php, Pfad mit Punkten: 'mail.absender'. */
function sm_config(string $pfad, mixed $standard = null): mixed
{
$wert = $GLOBALS['SM_CONFIG'];
foreach (explode('.', $pfad) as $teil) {
if (!is_array($wert) || !array_key_exists($teil, $wert)) {
return $standard;
}
$wert = $wert[$teil];
}
return $wert;
}
function sm_daten_ordner(string $unter = ''): string
{
$ordner = rtrim((string) sm_config('daten_ordner', SM_PRIVAT . '/daten'), '/\\');
$pfad = $unter === '' ? $ordner : $ordner . '/' . $unter;
if (!is_dir($pfad)) {
@mkdir($pfad, 0770, true);
}
return $pfad;
}
function sm_log(string $text): void
{
@file_put_contents(sm_daten_ordner() . '/fehler.log',
'[' . gmdate('Y-m-d H:i:s') . "] $text\n", FILE_APPEND | LOCK_EX);
}
date_default_timezone_set('UTC');
ini_set('display_errors', sm_config('fehler_anzeigen', false) ? '1' : '0');
error_reporting(E_ALL);
mb_internal_encoding('UTF-8');
/** Fehler, die als verstaendliche Meldung beim Nutzer ankommen sollen. */
final class SmFehler extends RuntimeException
{
public function __construct(
public readonly string $fehlercode,
string $meldung,
public readonly int $http = 400,
public readonly array $extra = [],
) {
parent::__construct($meldung);
}
}
foreach (['db', 'sicherheit', 'mail', 'konten', 'charaktere', 'squads', 'web'] as $smDatei) {
require __DIR__ . "/$smDatei.php";
}
unset($smDatei);

View file

@ -0,0 +1,400 @@
<?php
/*
* Verwaltung unter /verwaltung/ - nur fuer Konten mit der Rolle admin.
*
* Eigene PHP-Sitzung (Cookie nur fuer /verwaltung/, HttpOnly, SameSite
* Strict), CSRF-Token fuer jede Aenderung, zwei Stunden Leerlauf.
* Loeschen fuehrt immer ueber eine Bestaetigungsseite; JavaScript gibt es
* bewusst keines.
*/
declare(strict_types=1);
final class Verwaltung
{
private const LEERLAUF = 7200;
public static function starten(): void
{
session_name('sm_verwaltung');
session_set_cookie_params([
'lifetime' => 0,
'path' => '/verwaltung/',
'secure' => str_starts_with((string) sm_config('basis_url', ''), 'https://'),
'httponly' => true,
'samesite' => 'Strict',
]);
session_start();
}
/** Angemeldeter Admin oder null. Ein geaendertes Passwort beendet die Sitzung. */
public static function admin(): ?array
{
$id = $_SESSION['admin_id'] ?? null;
if (!is_int($id) || (time() - (int) ($_SESSION['zuletzt'] ?? 0)) > self::LEERLAUF) {
return null;
}
$nutzer = DB::eine("SELECT * FROM sm_nutzer WHERE id = ? AND rolle = 'admin' AND gesperrt = 0", [$id]);
if ($nutzer === null || !hash_equals((string) ($_SESSION['fingerabdruck'] ?? ''),
hash('sha256', (string) $nutzer['passwort_hash']))) {
return null;
}
$_SESSION['zuletzt'] = time();
return $nutzer;
}
public static function csrf(): string
{
if (empty($_SESSION['csrf'])) {
$_SESSION['csrf'] = Sicherheit::zufall(24);
}
return $_SESSION['csrf'];
}
public static function csrfFeld(): string
{
return '<input type="hidden" name="csrf" value="' . Web::e(self::csrf()) . '">';
}
private static function csrfPruefen(): void
{
if (!hash_equals(self::csrf(), (string) ($_POST['csrf'] ?? ''))) {
throw new SmFehler('csrf', 'Die Sitzung ist abgelaufen. Bitte lade die Seite neu.', 400);
}
}
private static function weiter(string $seite, string $meldung = '', string $art = 'info'): never
{
if ($meldung !== '') {
$_SESSION['meldung'] = [$meldung, $art];
}
header('Location: ./?seite=' . rawurlencode($seite), true, 303);
exit;
}
private static function meldung(): string
{
[$text, $art] = $_SESSION['meldung'] ?? ['', 'info'];
unset($_SESSION['meldung']);
return $text === '' ? '' : Web::hinweis(Web::e($text), $art);
}
// -- Ablauf -------------------------------------------------------------
public static function behandeln(): never
{
self::starten();
$seite = (string) ($_GET['seite'] ?? 'uebersicht');
try {
$admin = self::admin();
if ($admin === null) {
self::anmeldung();
}
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
self::csrfPruefen();
self::aktion($admin, (string) ($_POST['aktion'] ?? ''));
}
match ($seite) {
'nutzer' => self::seiteNutzer(),
'charaktere' => self::seiteCharaktere(),
'charakter' => self::seiteCharakter((int) ($_GET['id'] ?? 0)),
'squads' => self::seiteSquads(),
'bestaetigen' => self::seiteBestaetigen(),
'bild' => self::bild((int) ($_GET['id'] ?? 0)),
default => self::seiteUebersicht(),
};
} catch (SmFehler $fehler) {
Web::seite('Verwaltung', Web::hinweis(Web::e($fehler->getMessage()), 'fehler')
. '<p><a href="./">Zur Übersicht</a></p>');
}
}
private static function anmeldung(): never
{
$fehler = '';
if ($_SERVER['REQUEST_METHOD'] === 'POST' && ($_POST['aktion'] ?? '') === 'anmelden') {
try {
self::csrfPruefen();
$email = mb_strtolower(trim((string) ($_POST['email'] ?? '')));
Sicherheit::bremseOderFehler('verwaltung', Sicherheit::ip(), 8, 900);
$nutzer = DB::eine("SELECT * FROM sm_nutzer WHERE email = ? AND rolle = 'admin' AND gesperrt = 0", [$email]);
$hash = $nutzer['passwort_hash'] ?? null;
if ($hash === null || !password_verify((string) ($_POST['passwort'] ?? ''), $hash)) {
throw new SmFehler('anmeldung_falsch', 'E-Mail oder Passwort stimmt nicht.');
}
Sicherheit::bremseLoesen('verwaltung', Sicherheit::ip());
session_regenerate_id(true);
$_SESSION['admin_id'] = (int) $nutzer['id'];
$_SESSION['zuletzt'] = time();
$_SESSION['fingerabdruck'] = hash('sha256', $hash);
DB::aktualisieren('sm_nutzer', ['letzte_anmeldung_am' => DB::jetzt()], 'id = ?', [$nutzer['id']]);
self::weiter('uebersicht');
} catch (SmFehler $f) {
$fehler = Web::hinweis(Web::e($f->getMessage()), 'fehler');
}
}
Web::seite('Verwaltung', '<div class="karte"><h1>Anmelden</h1>' . $fehler
. '<form method="post" action="./">' . self::csrfFeld()
. '<input type="hidden" name="aktion" value="anmelden">'
. '<label for="email">E-Mail</label><input type="email" id="email" name="email" autocomplete="username" required>'
. '<label for="passwort">Passwort</label><input type="password" id="passwort" name="passwort" autocomplete="current-password" required>'
. '<button type="submit">Anmelden</button></form>'
. '<p class="dim">Passwort vergessen? <a href="/konto/vergessen.php">Neues Passwort anfordern</a></p></div>');
}
private static function aktion(array $admin, string $aktion): never
{
$id = (int) ($_POST['id'] ?? 0);
switch ($aktion) {
case 'abmelden':
$_SESSION = [];
session_destroy();
header('Location: ./', true, 303);
exit;
case 'nutzer_sperren':
case 'nutzer_entsperren':
self::nichtSelbst($admin, $id);
DB::aktualisieren('sm_nutzer', ['gesperrt' => $aktion === 'nutzer_sperren' ? 1 : 0], 'id = ?', [$id]);
if ($aktion === 'nutzer_sperren') {
Sicherheit::alleTokenLoeschen($id, 'sitzung');
}
self::weiter('nutzer', $aktion === 'nutzer_sperren' ? 'Nutzer gesperrt und abgemeldet.' : 'Nutzer entsperrt.');
case 'nutzer_bestaetigen':
DB::aktualisieren('sm_nutzer', ['email_bestaetigt_am' => DB::jetzt()],
'id = ? AND email_bestaetigt_am IS NULL', [$id]);
self::weiter('nutzer', 'E-Mail-Adresse als bestätigt markiert.');
case 'nutzer_passwortlink':
$nutzer = DB::eine('SELECT * FROM sm_nutzer WHERE id = ?', [$id]);
if ($nutzer !== null && $nutzer['email'] !== null) {
Konten::passwortLinkSenden($nutzer, 86400,
"über die Verwaltung wurde ein Link zum Festlegen eines neuen Passworts angefordert:\n\n"
. "%LINK%\n\nDer Link ist 24 Stunden gültig.");
}
self::weiter('nutzer', 'Link zum Passwort-Festlegen verschickt.');
case 'nutzer_loeschen':
self::nichtSelbst($admin, $id);
Konten::loeschen($id);
self::weiter('nutzer', 'Nutzer samt Charakteren gelöscht.');
case 'charakter_loeschen':
Charaktere::loeschenNachId($id);
self::weiter('charaktere', 'Charakter gelöscht.');
case 'squad_aufloesen':
Squads::aufloesenNachId($id);
self::weiter('squads', 'Squad aufgelöst.');
}
throw new SmFehler('aktion_unbekannt', 'Unbekannte Aktion.');
}
private static function nichtSelbst(array $admin, int $id): void
{
if ((int) $admin['id'] === $id) {
throw new SmFehler('selbst', 'Den eigenen Verwaltungszugang kannst du nicht sperren oder löschen.');
}
}
// -- Seiten -------------------------------------------------------------
private static function navigation(string $aktiv): string
{
$punkte = ['uebersicht' => 'ÜBERSICHT', 'nutzer' => 'NUTZER', 'charaktere' => 'CHARAKTERE', 'squads' => 'SQUADS'];
$html = '<nav>';
foreach ($punkte as $seite => $text) {
$html .= '<a href="./?seite=' . $seite . '"' . ($seite === $aktiv ? ' class="aktiv"' : '') . ">$text</a>";
}
return $html . '<form method="post" action="./" style="margin-left:auto">' . self::csrfFeld()
. '<input type="hidden" name="aktion" value="abmelden"><button class="leise">Abmelden</button></form></nav>';
}
private static function knopf(string $aktion, int $id, string $text, bool $gefahr = false): string
{
return '<form method="post" action="./">' . self::csrfFeld()
. '<input type="hidden" name="aktion" value="' . Web::e($aktion) . '">'
. '<input type="hidden" name="id" value="' . $id . '">'
. '<button class="leise' . ($gefahr ? ' gefahr' : '') . '">' . Web::e($text) . '</button></form> ';
}
/** Loeschen und Aufloesen ueber eine eigene Seite statt ueber JavaScript-Rueckfragen. */
private static function loeschLink(string $aktion, int $id, string $text): string
{
return '<a class="dim" href="./?seite=bestaetigen&amp;aktion=' . Web::e($aktion) . '&amp;id=' . $id . '">'
. Web::e($text) . '</a>';
}
private static function datum(?string $wert): string
{
return $wert === null ? '<span class="dim">—</span>' : Web::e(substr($wert, 0, 16)) . ' <span class="dim">UTC</span>';
}
private static function suchfeld(string $seite): array
{
$suche = trim(mb_substr((string) ($_GET['q'] ?? ''), 0, 64));
$html = '<form class="suche" method="get" action="./"><input type="hidden" name="seite" value="' . $seite . '">'
. '<input type="search" name="q" value="' . Web::e($suche) . '" placeholder="Suchen …"><button>Suchen</button></form>';
$muster = '%' . str_replace(['!', '%', '_'], ['!!', '!%', '!_'], $suche) . '%';
return [$suche, $muster, $html];
}
private static function seiteUebersicht(): never
{
$zahlen = [
'Nutzer' => DB::wert('SELECT COUNT(*) FROM sm_nutzer'),
'Nur Schlüssel' => DB::wert('SELECT COUNT(*) FROM sm_nutzer WHERE email IS NULL'),
'Unbestätigt' => DB::wert('SELECT COUNT(*) FROM sm_nutzer WHERE email IS NOT NULL AND email_bestaetigt_am IS NULL'),
'Gesperrt' => DB::wert('SELECT COUNT(*) FROM sm_nutzer WHERE gesperrt = 1'),
'Charaktere' => DB::wert('SELECT COUNT(*) FROM sm_charakter'),
'Squads' => DB::wert('SELECT COUNT(*) FROM sm_squad'),
'Offene Einladungen' => DB::wert("SELECT COUNT(*) FROM sm_einladung WHERE status = 'offen'"),
];
$html = self::meldung() . '<h1>Übersicht</h1><div class="zahlen">';
foreach ($zahlen as $text => $wert) {
$html .= '<div><b>' . (int) $wert . '</b>' . Web::e($text) . '</div>';
}
$html .= '</div><h2>NEUESTE KONTEN</h2><div class="tabelle"><table><tr><th>Benutzername</th><th>E-Mail</th><th>Registriert</th></tr>';
foreach (DB::alle('SELECT benutzername, email, erstellt_am FROM sm_nutzer ORDER BY id DESC LIMIT 10') as $n) {
$html .= '<tr><td>' . Web::e($n['benutzername']) . '</td><td>'
. ($n['email'] === null ? '<span class="dim">nur Schlüssel</span>' : Web::e($n['email']))
. '</td><td>' . self::datum($n['erstellt_am']) . '</td></tr>';
}
Web::seite('Verwaltung', $html . '</table></div>', '1100px', self::navigation('uebersicht'));
}
private static function seiteNutzer(): never
{
[$suche, $muster, $suchHtml] = self::suchfeld('nutzer');
$sql = 'SELECT n.*, (SELECT COUNT(*) FROM sm_charakter c WHERE c.nutzer_id = n.id) AS anzahl FROM sm_nutzer n';
$werte = [];
if ($suche !== '') {
$sql .= " WHERE n.benutzername LIKE ? ESCAPE '!' OR n.email LIKE ? ESCAPE '!'";
$werte = [$muster, $muster];
}
$zeilen = DB::alle($sql . ' ORDER BY n.id DESC LIMIT 300', $werte);
$html = self::meldung() . '<h1>Nutzer</h1>' . $suchHtml
. '<div class="tabelle"><table><tr><th>Benutzername</th><th>E-Mail</th><th>Rolle</th><th>Bestätigt</th>'
. '<th>Charaktere</th><th>Registriert</th><th>Letzte Anmeldung</th><th></th></tr>';
foreach ($zeilen as $n) {
$id = (int) $n['id'];
$gesperrt = (int) $n['gesperrt'] === 1;
$aktionen = $gesperrt ? self::knopf('nutzer_entsperren', $id, 'Entsperren')
: self::knopf('nutzer_sperren', $id, 'Sperren', true);
$nurSchluessel = $n['email'] === null;
if (!$nurSchluessel && $n['email_bestaetigt_am'] === null) {
$aktionen .= self::knopf('nutzer_bestaetigen', $id, 'Bestätigen');
}
if (!$nurSchluessel) {
$aktionen .= self::knopf('nutzer_passwortlink', $id, 'Passwort-Link');
}
if ($n['rolle'] !== 'admin') {
$aktionen .= self::loeschLink('nutzer_loeschen', $id, 'Löschen …');
}
$html .= '<tr><td>' . Web::e($n['benutzername']) . ($gesperrt ? ' <span class="hinweis fehler" style="padding:1px 6px">gesperrt</span>' : '')
. '</td><td>' . ($nurSchluessel ? '<span class="dim">nur Schlüssel</span>' : Web::e($n['email']))
. '</td><td>' . Web::e($n['rolle']) . '</td><td>'
. ($nurSchluessel ? '<span class="dim">—</span>'
: ($n['email_bestaetigt_am'] === null ? '<span style="color:var(--amber)">nein</span>' : 'ja'))
. '</td><td class="mono">' . (int) $n['anzahl'] . '</td><td>' . self::datum($n['erstellt_am'])
. '</td><td>' . self::datum($n['letzte_anmeldung_am']) . '</td><td>' . $aktionen . '</td></tr>';
}
Web::seite('Verwaltung', $html . '</table></div>', '1300px', self::navigation('nutzer'));
}
private static function seiteCharaktere(): never
{
[$suche, $muster, $suchHtml] = self::suchfeld('charaktere');
$sql = 'SELECT c.*, n.benutzername AS spieler, s.name AS squad FROM sm_charakter c
JOIN sm_nutzer n ON n.id = c.nutzer_id LEFT JOIN sm_squad s ON s.id = c.squad_id';
$werte = [];
if ($suche !== '') {
$sql .= " WHERE c.callsign LIKE ? ESCAPE '!' OR c.nachname LIKE ? ESCAPE '!' OR c.vorname LIKE ? ESCAPE '!'"
. " OR n.benutzername LIKE ? ESCAPE '!' OR c.aktennummer LIKE ? ESCAPE '!'";
$werte = array_fill(0, 5, $muster);
}
$zeilen = DB::alle($sql . ' ORDER BY c.geaendert_am DESC LIMIT 300', $werte);
$html = self::meldung() . '<h1>Charaktere</h1>' . $suchHtml
. '<div class="tabelle"><table><tr><th>Akte</th><th>Callsign</th><th>Name</th><th>Dienstgrad</th>'
. '<th>Fraktion</th><th>Status</th><th>Spieler</th><th>Squad</th><th>Geändert</th><th></th></tr>';
foreach ($zeilen as $c) {
$id = (int) $c['id'];
$html .= '<tr><td class="mono">' . Web::e($c['aktennummer']) . '</td><td>' . Web::e($c['callsign'])
. '</td><td>' . Web::e(trim($c['vorname'] . ' ' . $c['nachname'])) . '</td><td>' . Web::e($c['rang'])
. '</td><td>' . Web::e(trim($c['fraktion'] . ($c['teilstreitkraft'] ? ' · ' . $c['teilstreitkraft'] : '')))
. '</td><td>' . Web::e($c['status']) . '</td><td>' . Web::e($c['spieler']) . '</td><td>'
. Web::e($c['squad'] ?? '—') . '</td><td>' . self::datum($c['geaendert_am']) . '</td><td>'
. '<a href="./?seite=charakter&amp;id=' . $id . '">Ansehen</a> · '
. self::loeschLink('charakter_loeschen', $id, 'Löschen …') . '</td></tr>';
}
Web::seite('Verwaltung', $html . '</table></div>', '1300px', self::navigation('charaktere'));
}
private static function seiteCharakter(int $id): never
{
$c = DB::eine('SELECT c.*, n.benutzername AS spieler, n.email FROM sm_charakter c
JOIN sm_nutzer n ON n.id = c.nutzer_id WHERE c.id = ?', [$id]);
if ($c === null) {
throw new SmFehler('nicht_gefunden', 'Diesen Charakter gibt es nicht.');
}
$daten = json_encode(json_decode($c['daten'], true), JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
$bild = $c['portraet'] !== null
? '<img src="./?seite=bild&amp;id=' . $id . '" alt="Porträt" style="max-width:220px;border:1px solid var(--line);float:right;margin:0 0 12px 18px">'
: '';
$html = '<h1>' . Web::e($c['callsign'] ?: trim($c['vorname'] . ' ' . $c['nachname'])) . '</h1><div class="karte">'
. $bild . '<p class="mono">' . Web::e($c['aktennummer']) . '</p><p>' . Web::e(trim($c['rang'] . ' '
. $c['vorname'] . ' ' . $c['nachname'])) . '<br>' . Web::e($c['fraktion']) . ' · ' . Web::e($c['teilstreitkraft'])
. '<br>Status: ' . Web::e($c['status']) . '</p><p class="dim">Spieler: ' . Web::e($c['spieler']) . ' (' . Web::e($c['email'])
. ')<br>Version ' . (int) $c['version'] . ', geändert ' . self::datum($c['geaendert_am']) . '</p>'
. '<p>' . self::loeschLink('charakter_loeschen', $id, 'Charakter löschen …') . '</p>'
. '<h2>AKTE (ROHDATEN)</h2><pre>' . Web::e($daten) . '</pre></div>';
Web::seite('Verwaltung', $html, '900px', self::navigation('charaktere'));
}
private static function seiteSquads(): never
{
$html = self::meldung() . '<h1>Squads</h1><div class="tabelle"><table><tr><th>Name</th><th>Führer</th>'
. '<th>Mitglieder</th><th>Gegründet</th><th></th></tr>';
foreach (DB::alle('SELECT * FROM sm_squad ORDER BY name') as $s) {
$mitglieder = DB::alle('SELECT id, callsign, nachname FROM sm_charakter WHERE squad_id = ? ORDER BY squad_seit', [$s['id']]);
$namen = array_map(fn($m) => ((int) $m['id'] === (int) $s['fuehrer_id'] ? '★ ' : '')
. Web::e($m['callsign'] ?: $m['nachname']), $mitglieder);
$fuehrer = array_values(array_filter($mitglieder, fn($m) => (int) $m['id'] === (int) $s['fuehrer_id']));
$html .= '<tr><td>' . Web::e($s['name']) . '</td><td>' . Web::e($fuehrer[0]['callsign'] ?? '—') . '</td><td>'
. implode(', ', $namen) . '</td><td>' . self::datum($s['erstellt_am']) . '</td><td>'
. self::loeschLink('squad_aufloesen', (int) $s['id'], 'Auflösen …') . '</td></tr>';
}
Web::seite('Verwaltung', $html . '</table></div>', '1100px', self::navigation('squads'));
}
private static function seiteBestaetigen(): never
{
$aktion = (string) ($_GET['aktion'] ?? '');
$id = (int) ($_GET['id'] ?? 0);
$texte = [
'nutzer_loeschen' => ['nutzer', 'Nutzer endgültig löschen? Alle seine Charaktere werden mitgelöscht.',
fn() => DB::wert('SELECT benutzername FROM sm_nutzer WHERE id = ?', [$id])],
'charakter_loeschen' => ['charaktere', 'Charakter endgültig löschen? Führt er ein Squad, übernimmt das dienstälteste Mitglied.',
fn() => DB::wert("SELECT COALESCE(NULLIF(callsign, ''), nachname) FROM sm_charakter WHERE id = ?", [$id])],
'squad_aufloesen' => ['squads', 'Squad auflösen? Die Mitglieder bleiben erhalten, sind danach aber ohne Squad.',
fn() => DB::wert('SELECT name FROM sm_squad WHERE id = ?', [$id])],
];
if (!isset($texte[$aktion])) {
throw new SmFehler('aktion_unbekannt', 'Unbekannte Aktion.');
}
[$zurueck, $frage, $name] = $texte[$aktion];
$html = '<div class="karte"><h1>Bestätigen</h1><p><b>' . Web::e($name() ?? '?') . '</b></p><p>' . Web::e($frage) . '</p>'
. '<form method="post" action="./">' . self::csrfFeld() . '<input type="hidden" name="aktion" value="' . Web::e($aktion) . '">'
. '<input type="hidden" name="id" value="' . $id . '"><button class="gefahr">Ja, ausführen</button> '
. '<a class="knopf" style="background:transparent;color:var(--fg);border-color:var(--line)" href="./?seite=' . $zurueck . '">Abbrechen</a></form></div>';
Web::seite('Verwaltung', $html, '560px', self::navigation($zurueck));
}
private static function bild(int $id): never
{
$pfad = Charaktere::bildPfad($id);
if ($pfad === null) {
http_response_code(404);
exit;
}
header('Content-Type: image/png');
header('X-Content-Type-Options: nosniff');
header('Cache-Control: private, max-age=300');
readfile($pfad);
exit;
}
}

View file

@ -0,0 +1,110 @@
<?php
/*
* Gemeinsames Aussehen der Webseiten (Konto-Links, Verwaltung, Einrichtung)
* im Stil der Downloadseite, dazu die Sicherheitskoepfe.
*/
declare(strict_types=1);
final class Web
{
public static function e(mixed $text): string
{
return htmlspecialchars((string) $text, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
}
public static function sicherheitskoepfe(): void
{
header('Content-Type: text/html; charset=utf-8');
header('X-Content-Type-Options: nosniff');
header('X-Frame-Options: DENY');
// Links aus Mails tragen ein Token in der Adresse - nie an Dritte weiterreichen
header('Referrer-Policy: no-referrer');
header('Cache-Control: no-store');
header("Content-Security-Policy: default-src 'none'; style-src 'unsafe-inline'; img-src 'self';"
. " form-action 'self'; frame-ancestors 'none'; base-uri 'none'");
}
public static function hinweis(string $text, string $art = 'info'): string
{
return '<p class="hinweis ' . self::e($art) . '">' . $text . '</p>';
}
public static function seite(string $titel, string $inhalt, string $breite = '560px', string $navigation = ''): never
{
self::sicherheitskoepfe();
$titelE = self::e($titel);
$rechtliches = self::e(sm_config('rechtliches_url', 'https://tyrveil.com/rechtliches#impressum'));
echo <<<HTML
<!doctype html>
<html lang="de">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="robots" content="noindex">
<title>$titelE – Squad Manager</title>
<link rel="icon" href="/icon.png">
<style>
:root { --bg:#151814; --panel:#1e231b; --panel-hi:#2a3125; --line:#3d4634; --fg:#c9cec0;
--dim:#7f8874; --olive:#6e8b3d; --olive-hi:#8cb04d; --amber:#d9a441; --rot:#b4472f;
--mono: Consolas, "Cascadia Mono", monospace; }
* { box-sizing: border-box; }
body { margin:0; background:var(--bg); color:var(--fg); font:15px/1.55 "Segoe UI", system-ui, sans-serif; }
main { max-width:$breite; margin:0 auto; padding:40px 20px; }
.kopf { display:flex; align-items:center; gap:14px; margin-bottom:28px; }
.kopf img { width:44px; height:44px; }
.kopf b { font-size:20px; letter-spacing:.04em; display:block; }
.kopf span { color:var(--dim); font-size:13px; }
h1 { font:700 14px var(--mono); letter-spacing:.08em; color:var(--olive-hi); text-transform:uppercase;
border-bottom:1px solid var(--line); padding-bottom:6px; margin:0 0 18px; }
h2 { font:700 13px var(--mono); letter-spacing:.06em; color:var(--olive-hi); margin:26px 0 10px; }
.karte { background:var(--panel); border:1px solid var(--line); padding:22px 24px; margin-bottom:18px; }
a { color:var(--olive-hi); }
label { display:block; margin:12px 0 4px; color:var(--dim); font-size:13px; }
input[type=text], input[type=email], input[type=password], input[type=search] {
width:100%; padding:9px 10px; background:var(--bg); color:var(--fg); border:1px solid var(--line);
font:inherit; }
input:focus { outline:1px solid var(--olive); }
button, .knopf { display:inline-block; margin-top:14px; padding:9px 18px; background:var(--olive);
color:#10130d; border:1px solid var(--olive-hi); font:600 14px "Segoe UI", sans-serif; cursor:pointer;
text-decoration:none; }
button.leise { background:transparent; color:var(--fg); border-color:var(--line); margin-top:0; padding:4px 10px; font-weight:400; }
button.gefahr { background:var(--rot); border-color:#d0664c; color:#fff; }
button.leise.gefahr { background:transparent; color:#e08a74; border-color:#6b3528; }
.hinweis { padding:10px 14px; border-left:3px solid var(--olive); background:var(--panel-hi); }
.hinweis.fehler { border-color:var(--rot); color:#f0b3a3; }
.hinweis.warnung { border-color:var(--amber); color:var(--amber); }
table { width:100%; border-collapse:collapse; font-size:14px; }
th { text-align:left; font:700 12px var(--mono); color:var(--dim); letter-spacing:.05em; padding:6px 8px;
border-bottom:1px solid var(--line); white-space:nowrap; }
td { padding:7px 8px; border-bottom:1px solid var(--panel-hi); vertical-align:top; }
td form { display:inline; }
.tabelle { overflow-x:auto; }
.dim { color:var(--dim); }
.mono { font-family:var(--mono); }
nav { display:flex; flex-wrap:wrap; gap:4px 18px; margin:-10px 0 24px; font:13px var(--mono); }
nav a { text-decoration:none; color:var(--fg); }
nav a.aktiv { color:var(--olive-hi); }
.zahlen { display:grid; grid-template-columns:repeat(auto-fill, minmax(150px, 1fr)); gap:12px; }
.zahlen div { background:var(--panel); border:1px solid var(--line); padding:12px 14px; }
.zahlen b { display:block; font:700 26px var(--mono); color:var(--olive-hi); }
pre { white-space:pre-wrap; word-break:break-word; background:var(--bg); border:1px solid var(--line);
padding:12px; font:12px var(--mono); max-height:420px; overflow:auto; }
.suche { display:flex; gap:8px; margin-bottom:14px; }
.suche button { margin-top:0; }
footer { max-width:$breite; margin:0 auto; padding:0 20px 40px; font:12px var(--mono); color:var(--dim); }
footer a { color:var(--dim); }
</style>
</head>
<body>
<main>
<div class="kopf"><img src="/icon.png" alt=""><div><b>SQUAD MANAGER</b><span>$titelE</span></div></div>
$navigation
$inhalt
</main>
<footer><a href="$rechtliches">Impressum und Datenschutz</a></footer>
</body>
</html>
HTML;
exit;
}
}

View file

@ -0,0 +1,46 @@
<?php
/*
* Vorlage fuer die Einstellungen des Servers.
*
* Als config.php in denselben Ordner kopieren (sva-privat/config.php) und
* ausfuellen. config.php enthaelt das Datenbank-Passwort: Sie gehoert
* nicht ins Repository und nicht in den Web-Ordner.
*/
return [
'datenbank' => [
// Plesk: Datenbank und Benutzer heissen 214729_sva
'dsn' => 'mysql:host=localhost;dbname=214729_sva;charset=utf8mb4',
'benutzer' => '214729_sva',
'passwort' => '', // HIER das Datenbank-Passwort aus Plesk eintragen
],
'basis_url' => 'https://sva.tyrveil.com',
'rechtliches_url' => 'https://tyrveil.com/rechtliches#impressum',
// Diese Adresse bekommt beim Einrichten den Verwaltungszugang
'admin_email' => 'info@tyrveil.com',
'mail' => [
// php_mail: ueber den Mailserver von Plesk, kein Passwort noetig
// smtp: ueber ein Postfach, dann unten Zugang eintragen
// datei: nur fuer Tests, schreibt Mails nach daten/mails
'art' => 'php_mail',
'absender' => 'info@tyrveil.com',
'absender_name' => 'Squad Manager',
'smtp' => [
'host' => 'localhost',
'port' => 587,
'verschluesselung' => 'tls', // tls, ssl oder keine
'benutzer' => '',
'passwort' => '',
],
],
// Einmaliger Schluessel fuer einrichten.php. Vor dem Einrichten eine
// lange Zufallszeichenkette eintragen (mindestens 24 Zeichen), danach
// wieder leeren - dann ist einrichten.php abgeschaltet.
'einrichtungs_schluessel' => '',
'daten_ordner' => __DIR__ . '/daten',
'fehler_anzeigen' => false,
];

View file

@ -0,0 +1,24 @@
<?php
// Portraet eines Charakters, nur fuer angemeldete Programme (Kopf X-SM-Token).
require dirname(__DIR__, 2) . '/sva-privat/app/start.php';
header('X-Content-Type-Options: nosniff');
if (Sicherheit::sitzung((string) ($_SERVER['HTTP_X_SM_TOKEN'] ?? '')) === null) {
http_response_code(401);
exit;
}
$pfad = Charaktere::bildPfad((int) ($_GET['id'] ?? 0));
if ($pfad === null) {
http_response_code(404);
exit;
}
$etag = '"' . basename($pfad, '.png') . '"';
header('ETag: ' . $etag);
header('Cache-Control: private, max-age=300');
if (($_SERVER['HTTP_IF_NONE_MATCH'] ?? '') === $etag) {
http_response_code(304);
exit;
}
header('Content-Type: image/png');
header('Content-Length: ' . filesize($pfad));
readfile($pfad);

View file

@ -0,0 +1,5 @@
<?php
// Schnittstelle fuer das Programm. Die Logik liegt ausserhalb des Web-Ordners.
require dirname(__DIR__, 2) . '/sva-privat/app/start.php';
require SM_PRIVAT . '/app/api.php';
Api::behandeln();

View file

@ -0,0 +1,90 @@
<?php
/*
* Ersteinrichtung: legt die Tabellen an und den Verwaltungszugang fuer
* admin_email. Nur mit dem einrichtungs_schluessel aus config.php nutzbar;
* ist der Schluessel leer, ist diese Seite abgeschaltet. Mehrfach aufrufen
* schadet nicht - vorhandene Tabellen und Daten bleiben unberuehrt.
*/
require dirname(__DIR__) . '/sva-privat/app/start.php';
$schluessel = (string) sm_config('einrichtungs_schluessel', '');
if (strlen($schluessel) < 24) {
Web::seite('Einrichtung', '<div class="karte"><h1>Einrichtung abgeschaltet</h1>'
. '<p>Zum Einrichten in <span class="mono">sva-privat/config.php</span> einen '
. '<span class="mono">einrichtungs_schluessel</span> mit mindestens 24 Zeichen eintragen.</p></div>');
}
$form = '<form method="post" action="einrichten.php"><label for="schluessel">Einrichtungsschlüssel aus config.php</label>'
. '<input type="password" id="schluessel" name="schluessel" required><button type="submit">Einrichten</button></form>';
if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
Web::seite('Einrichtung', '<div class="karte"><h1>Einrichtung</h1>' . $form . '</div>');
}
if (!hash_equals($schluessel, (string) ($_POST['schluessel'] ?? ''))) {
sleep(2);
Web::seite('Einrichtung', '<div class="karte"><h1>Einrichtung</h1>'
. Web::hinweis('Der Schlüssel stimmt nicht.', 'fehler') . $form . '</div>');
}
$zeilen = [];
$ok = true;
$pruefen = function (string $text, bool $bestanden, string $hilfe = '') use (&$zeilen, &$ok) {
$ok = $ok && $bestanden;
$zeilen[] = '<tr><td>' . ($bestanden ? '✓' : '<b style="color:#e08a74">✗</b>') . '</td><td>' . Web::e($text)
. ($bestanden || $hilfe === '' ? '' : '<br><span class="dim">' . Web::e($hilfe) . '</span>') . '</td></tr>';
};
$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 <b>' . Web::e($email)
. '</b>. Es gilt nur der zuletzt verschickte Link. Falls die Mail nicht ankommt, kannst du ihn auch direkt hier öffnen:<br>'
. '<a class="mono" href="' . Web::e($link) . '">Passwort jetzt festlegen</a>', 'warnung');
} else {
$adminHinweis = Web::hinweis('Der Verwaltungszugang hat schon ein Passwort. Vergessen? '
. '<a href="/konto/vergessen.php">Neues anfordern</a>');
}
} 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', '<div class="karte"><h1>Einrichtung</h1><table>' . implode('', $zeilen) . '</table></div>'
. $adminHinweis
. ($ok ? Web::hinweis('Fertig. Trage in <span class="mono">config.php</span> den '
. '<span class="mono">einrichtungs_schluessel</span> 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')));

View file

@ -0,0 +1,14 @@
<?php
// Link aus der Bestaetigungsmail.
require dirname(__DIR__, 2) . '/sva-privat/app/start.php';
try {
$nutzer = Konten::bestaetigen((string) ($_GET['t'] ?? ''));
Web::seite('E-Mail bestätigt', '<div class="karte"><h1>E-Mail bestätigt</h1>'
. '<p>Danke, ' . Web::e($nutzer['benutzername']) . '. Deine Adresse ist bestätigt.</p>'
. '<p>Du kannst dich jetzt im Squad Manager anmelden.</p></div>');
} catch (SmFehler $fehler) {
Web::seite('E-Mail bestätigen', '<div class="karte"><h1>Link ungültig</h1>'
. Web::hinweis(Web::e($fehler->getMessage()), 'fehler')
. '<p>Im Programm kannst du dir beim Anmelden eine neue Bestätigungsmail schicken lassen.</p></div>');
}

View file

@ -0,0 +1,41 @@
<?php
// Neues Passwort festlegen - Link aus der Mail "Passwort vergessen" oder der Einrichtung.
// Das Formular kommt erst per GET, gesetzt wird per POST: Mailprogramme, die Links
// vorab aufrufen, verbrauchen den Link so nicht.
require dirname(__DIR__, 2) . '/sva-privat/app/start.php';
$token = (string) ($_POST['t'] ?? $_GET['t'] ?? '');
$fehler = '';
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
$passwort = (string) ($_POST['passwort'] ?? '');
if (!hash_equals($passwort, (string) ($_POST['wiederholung'] ?? ''))) {
$fehler = Web::hinweis('Die beiden Passwörter stimmen nicht überein.', 'fehler');
} else {
try {
$nutzer = Konten::passwortSetzen($token, $passwort);
$weiter = $nutzer['rolle'] === 'admin'
? '<p><a class="knopf" href="/verwaltung/">Zur Verwaltung</a></p>'
: '<p>Melde dich jetzt im Squad Manager mit dem neuen Passwort an. '
. 'Auf anderen Geräten wurdest du abgemeldet.</p>';
Web::seite('Passwort gespeichert', '<div class="karte"><h1>Passwort gespeichert</h1>' . $weiter . '</div>');
} catch (SmFehler $f) {
$fehler = Web::hinweis(Web::e($f->getMessage()), 'fehler');
}
}
}
if (Sicherheit::tokenFinden($token, 'passwort') === null) {
Web::seite('Passwort', '<div class="karte"><h1>Link ungültig</h1>'
. Web::hinweis('Dieser Link ist ungültig oder abgelaufen.', 'fehler')
. '<p><a href="/konto/vergessen.php">Neuen Link anfordern</a></p></div>');
}
Web::seite('Neues Passwort', '<div class="karte"><h1>Neues Passwort</h1>' . $fehler
. '<form method="post" action="passwort.php">'
. '<input type="hidden" name="t" value="' . Web::e($token) . '">'
. '<label for="passwort">Neues Passwort (mindestens ' . Sicherheit::PASSWORT_MIN . ' Zeichen)</label>'
. '<input type="password" id="passwort" name="passwort" autocomplete="new-password" required minlength="' . Sicherheit::PASSWORT_MIN . '">'
. '<label for="wiederholung">Wiederholen</label>'
. '<input type="password" id="wiederholung" name="wiederholung" autocomplete="new-password" required>'
. '<button type="submit">Passwort speichern</button></form></div>');

View file

@ -0,0 +1,17 @@
<?php
// Passwort vergessen - auch fuer die Verwaltung erreichbar.
require dirname(__DIR__, 2) . '/sva-privat/app/start.php';
$inhalt = '';
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
try {
Konten::passwortVergessen((string) ($_POST['email'] ?? ''));
$inhalt = Web::hinweis('Falls ein Konto zu dieser Adresse gehört, ist eine Mail mit einem Link unterwegs.');
} catch (SmFehler $f) {
$inhalt = Web::hinweis(Web::e($f->getMessage()), 'fehler');
}
}
Web::seite('Passwort vergessen', '<div class="karte"><h1>Passwort vergessen</h1>' . $inhalt
. '<form method="post" action="vergessen.php"><label for="email">E-Mail-Adresse deines Kontos</label>'
. '<input type="email" id="email" name="email" autocomplete="email" required>'
. '<button type="submit">Link schicken</button></form></div>');

View file

@ -0,0 +1,5 @@
<?php
// Verwaltung fuer den Admin-Zugang.
require dirname(__DIR__, 2) . '/sva-privat/app/start.php';
require SM_PRIVAT . '/app/verwaltung.php';
Verwaltung::behandeln();

1053
squad.py Normal file

File diff suppressed because it is too large Load diff

View file

@ -50,8 +50,25 @@ from tkinter import ttk, messagebox # noqa: E402
import numpy as np # noqa: E402
import sounddevice as sd # noqa: E402
from theme import ( # noqa: E402
BG, PANEL, PANEL_HI, LINE, FG, FG_DIM, OLIVE, OLIVE_HI, AMBER,
AMBER_HELL, AMBER_DUNKEL, RED, GREEN_TX,
FONT_UI, FONT_BOLD, FONT_TITLE, FONT_MONO, FONT_STATUS,
apply_tactical_theme, LevelMeter,
)
import akte # noqa: E402
import squad # noqa: E402
import update_helfer # noqa: E402
APP_NAME = "Squad Manager"
VERSION = "3.3"
VERSION = "1.7.0"
# Zaehlnummer fuer den Update-Vergleich, bei jedem Release um eins erhoehen.
# Seit 1.5.0 getrennt von der angezeigten Version: Die Anzeige sprang von
# 4.0 auf 1.5.0 zurueck, ein Vergleich der Anzeige haette danach nie wieder
# ein Update gefunden.
BUILD = 5
# Letzte Version aus der Zeit vor den Zaehlnummern
LETZTE_ALTE_VERSION = "4.0"
CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "config.json"
LOG_PATH = CONFIG_PATH.parent / "error.log"
# Bis Version 3.2 hiess das Programm "Squad Voice Activation"
@ -109,17 +126,28 @@ def pruefe_update(timeout=6):
except Exception:
return None
ziel = str(angaben.get("version", "")).strip()
# "anzeige" und "build" gibt es seit 1.5.0. "version" bleibt fuer die
# Programme bis 4.0 stehen, die nur dieses Feld kennen.
ziel = str(angaben.get("anzeige") or angaben.get("version", "")).strip()
datei = str(angaben.get("datei", "")).strip()
if not ziel or not datei.lower().startswith("https://"):
return None
if version_tupel(ziel) <= version_tupel(VERSION):
if "build" in angaben:
try:
neuer = int(angaben["build"]) > BUILD
except (TypeError, ValueError):
return None
else:
neuer = version_tupel(ziel) > version_tupel(LETZTE_ALTE_VERSION)
if not neuer:
return None
installer = str(angaben.get("installer", "")).strip()
return {
"version": ziel,
"datei": datei,
"sha256": str(angaben.get("sha256", "")).strip().lower(),
"hinweis": str(angaben.get("hinweis", "")).strip()[:200],
"installer": installer if installer.lower().startswith("https://") else "",
}
@ -153,19 +181,23 @@ def lade_update(angaben, ziel_pfad, fortschritt=None):
return ziel_pfad
def spiele_update_ein(zip_pfad, programm_ordner):
def spiele_update_ein(zip_pfad, programm_ordner, installer_url=""):
"""
Entpackt das Paket und startet einen Helfer, der die Dateien ersetzt.
Entpackt das Paket und startet den Update-Helfer.
Das laufende Programm kann seine eigenen Dateien nicht ueberschreiben.
Deshalb uebernimmt ein kleines Skript das Kopieren, nachdem sich das
Programm beendet hat, und startet es anschliessend neu.
Das laufende Programm ersetzt seine Dateien nicht selbst. Das erledigt
update_helfer.py als eigener Prozess, sobald das Programm beendet ist,
und startet es danach neu. Bevorzugt wird der Helfer aus dem *neuen*
Paket: Eine Verbesserung am Helfer wirkt so schon bei dem Update, das
sie ausliefert. Seine Aufrufparameter sind deshalb eine Schnittstelle
und muessen zwischen den Versionen gleich bleiben.
"""
import shutil
import subprocess
import tempfile
import zipfile
arbeit = Path(tempfile.mkdtemp(prefix="sva_update_"))
arbeit = Path(tempfile.mkdtemp(prefix="sm_update_"))
with zipfile.ZipFile(zip_pfad) as archiv:
archiv.extractall(arbeit)
@ -176,17 +208,17 @@ def spiele_update_ein(zip_pfad, programm_ordner):
raise ValueError("Im Paket wurde kein Programmordner gefunden.")
quelle = treffer[0].parent
helfer = arbeit / "einspielen.bat"
helfer.write_text(
"@echo off\r\n"
"ping -n 4 127.0.0.1 >nul\r\n"
f'xcopy /e /y /i /q "{quelle}\\*" "{programm_ordner}\\" >nul\r\n'
f'start "" "{sys.executable}" "{programm_ordner}\\start.pyw"\r\n'
"ping -n 2 127.0.0.1 >nul\r\n"
f'rmdir /s /q "{arbeit}"\r\n',
encoding="ascii")
kandidaten = (quelle / "update_helfer.py",
Path(__file__).resolve().parent / "update_helfer.py")
helfer = next((p for p in kandidaten if p.is_file()), None)
if helfer is None:
raise ValueError("Der Update-Helfer fehlt.")
# Ausserhalb von quelle, damit er beim Kopieren nicht mitten im Lauf liegt
ausfuehren = arbeit / "update_helfer.py"
shutil.copy2(helfer, ausfuehren)
subprocess.Popen(["cmd", "/c", str(helfer)],
subprocess.Popen([sys.executable, str(ausfuehren), str(quelle),
str(programm_ordner), str(os.getpid()), installer_url],
creationflags=0x08000000) # kein Konsolenfenster
return True
@ -432,166 +464,6 @@ def get_foreground_process_name():
kernel32.CloseHandle(handle)
# ---------------------------------------------------------------------------
# Erscheinungsbild - gedeckte Militaerfarben, dunkler Untergrund
# ---------------------------------------------------------------------------
BG = "#151814" # Fensterhintergrund, fast schwarz mit Gruenstich
PANEL = "#1e231b" # Flaechen, Eingabefelder
PANEL_HI = "#2a3125" # Hover, ausgewaehlter Reiter
LINE = "#3d4634" # Rahmen und Trennlinien
FG = "#c9cec0" # Standardtext, helles Khaki
FG_DIM = "#7f8874" # Nebentext
OLIVE = "#6e8b3d" # Akzent, Fortschritt
OLIVE_HI = "#8cb04d" # heller Akzent
AMBER = "#d9a441" # Hinweise, Schwellenmarke
AMBER_HELL = "#e8bb63" # Mauskontakt auf der Hinweisleiste
AMBER_DUNKEL = "#2b2416" # Untergrund der Hinweisleiste
RED = "#b4472f" # Sperre, Fehler
GREEN_TX = "#9ed23f" # Sendebereit
FONT_UI = ("Segoe UI", 9)
FONT_BOLD = ("Segoe UI Semibold", 9)
FONT_TITLE = ("Segoe UI", 17, "bold")
FONT_MONO = ("Consolas", 9)
FONT_STATUS = ("Consolas", 13, "bold")
def apply_tactical_theme(root):
"""Dunkles, gedecktes Farbschema im Stil der Spieloberflaeche."""
root.configure(bg=BG)
style = ttk.Style(root)
# "clam" ist das einzige mitgelieferte Thema, das sich durchgaengig
# umfaerben laesst - "vista" ignoriert die meisten Farbangaben.
style.theme_use("clam")
style.configure(".", background=BG, foreground=FG, font=FONT_UI,
bordercolor=LINE, darkcolor=PANEL, lightcolor=PANEL,
troughcolor=PANEL, focuscolor=OLIVE)
style.configure("TFrame", background=BG)
style.configure("TLabel", background=BG, foreground=FG)
style.configure("Dim.TLabel", foreground=FG_DIM)
style.configure("Mono.TLabel", font=FONT_MONO, foreground=FG)
style.configure("Title.TLabel", font=FONT_TITLE, foreground=FG)
style.configure("Sub.TLabel", foreground=FG_DIM)
style.configure("TLabelframe", background=BG, bordercolor=LINE,
relief="solid", borderwidth=1)
style.configure("TLabelframe.Label", background=BG, foreground=OLIVE_HI,
font=FONT_BOLD)
style.configure("TButton", background=PANEL, foreground=FG,
bordercolor=LINE, relief="solid", borderwidth=1,
padding=(12, 6), font=FONT_UI)
style.map("TButton",
background=[("pressed", OLIVE), ("active", PANEL_HI),
("disabled", PANEL)],
foreground=[("disabled", FG_DIM)],
bordercolor=[("active", OLIVE)])
style.configure("Accent.TButton", background=OLIVE, foreground="#12150f",
font=FONT_BOLD, bordercolor=OLIVE_HI)
style.map("Accent.TButton",
background=[("pressed", OLIVE), ("active", OLIVE_HI),
("disabled", PANEL)],
foreground=[("disabled", FG_DIM)])
for widget in ("TCombobox", "TSpinbox", "TEntry"):
style.configure(widget, fieldbackground=PANEL, background=PANEL,
foreground=FG, bordercolor=LINE, arrowcolor=OLIVE_HI,
insertcolor=FG, selectbackground=OLIVE,
selectforeground="#12150f", padding=4)
style.map(widget,
fieldbackground=[("readonly", PANEL), ("disabled", BG)],
foreground=[("disabled", FG_DIM)],
bordercolor=[("focus", OLIVE)])
# Die aufklappende Liste einer Combobox ist ein klassisches Tk-Widget
# und muss ueber die Optionsdatenbank eingefaerbt werden.
root.option_add("*TCombobox*Listbox.background", PANEL)
root.option_add("*TCombobox*Listbox.foreground", FG)
root.option_add("*TCombobox*Listbox.selectBackground", OLIVE)
root.option_add("*TCombobox*Listbox.selectForeground", "#12150f")
root.option_add("*TCombobox*Listbox.font", FONT_UI)
style.configure("TCheckbutton", background=BG, foreground=FG,
indicatorcolor=PANEL, indicatorrelief="solid")
style.map("TCheckbutton",
background=[("active", BG)],
indicatorcolor=[("selected", OLIVE_HI), ("active", PANEL_HI)],
foreground=[("disabled", FG_DIM)])
style.configure("TNotebook", background=BG, bordercolor=LINE,
tabmargins=(2, 4, 2, 0))
style.configure("TNotebook.Tab", background="#10120f", foreground=FG_DIM,
bordercolor=LINE, lightcolor="#10120f",
darkcolor="#10120f", padding=(20, 9), font=FONT_BOLD)
style.map("TNotebook.Tab",
background=[("selected", PANEL_HI), ("active", PANEL)],
lightcolor=[("selected", PANEL_HI)],
darkcolor=[("selected", PANEL_HI)],
foreground=[("selected", OLIVE_HI), ("active", FG)],
expand=[("selected", (0, 0, 0, 0))])
# Der Schieberegler von clam ist standardmaessig hell und wuerde aus
# dem Schema fallen.
style.configure("Horizontal.TScale", background=BG, troughcolor="#10120f",
bordercolor=LINE, lightcolor=OLIVE, darkcolor=OLIVE)
style.map("Horizontal.TScale",
background=[("active", BG)],
lightcolor=[("active", OLIVE_HI)],
darkcolor=[("active", OLIVE_HI)])
style.configure("TSeparator", background=LINE)
return style
class LevelMeter(tk.Canvas):
"""
Segmentierte Pegelanzeige mit Schwellenmarke.
Zeigt anders als eine gewoehnliche Fortschrittsleiste, wo die
Ausloeseschwelle relativ zum Pegel liegt - genau die Information,
die man zum Einstellen braucht.
"""
SEGMENTS = 40
MAXIMUM = 0.10
def __init__(self, master, width=320, height=26):
super().__init__(master, width=width, height=height, bg=PANEL,
highlightthickness=1, highlightbackground=LINE,
bd=0)
self._level = 0.0
self._threshold = 0.025
self._active = False
self.bind("<Configure>", lambda e: self._redraw())
def update_values(self, level, threshold, active):
self._level, self._threshold, self._active = level, threshold, active
self._redraw()
def _redraw(self):
self.delete("all")
w = self.winfo_width() or int(self["width"])
h = self.winfo_height() or int(self["height"])
pad = 3
seg_w = (w - 2 * pad) / self.SEGMENTS
filled = int(min(1.0, self._level / self.MAXIMUM) * self.SEGMENTS)
thr_seg = int(min(1.0, self._threshold / self.MAXIMUM) * self.SEGMENTS)
for i in range(self.SEGMENTS):
x0 = pad + i * seg_w
x1 = x0 + seg_w - 1.5
if i < filled:
colour = OLIVE_HI if self._active else OLIVE
if i >= thr_seg and not self._active:
colour = OLIVE_HI
else:
colour = "#252b1f"
self.create_rectangle(x0, pad, x1, h - pad, fill=colour, width=0)
# Schwellenmarke
x = pad + thr_seg * seg_w
self.create_line(x, 0, x, h, fill=AMBER, width=2)
def set_dark_titlebar(root):
"""
Faerbt die Fenstertitelleiste dunkel.
@ -840,8 +712,8 @@ class VoiceActivationApp:
def __init__(self, root):
self.root = root
self.root.title(f"{APP_NAME} {VERSION}")
self.root.geometry("700x780")
self.root.minsize(660, 480)
self.root.geometry("900x830")
self.root.minsize(780, 520)
set_window_icon(self.root)
set_dark_titlebar(self.root)
@ -908,7 +780,7 @@ class VoiceActivationApp:
ttk.Label(header, text="SQUAD MANAGER",
style="Title.TLabel").pack(anchor="w")
ttk.Label(header, style="Sub.TLabel",
text="Haelt die Sprechtaste, solange du redest.").pack(anchor="w")
text="Sprachaktivierung, Personalakten und Squads.").pack(anchor="w")
ttk.Separator(self.root, orient="horizontal").pack(
fill="x", padx=18, pady=(10, 0))
@ -918,9 +790,22 @@ class VoiceActivationApp:
self._build_statusbar()
self._build_update_banner()
nb = ttk.Notebook(self.root)
# Hauptreiter je Modul. Die Statusleiste bleibt darunter fuer alle
# Module sichtbar - die Sprachaktivierung laeuft weiter, waehrend man
# zum Beispiel an einer Akte schreibt.
haupt = ttk.Notebook(self.root, style="Haupt.TNotebook")
self.haupt_nb = haupt
haupt.pack(fill="both", expand=True, padx=16, pady=(4, 8))
seite_funk = ttk.Frame(haupt)
seite_akte = ttk.Frame(haupt)
seite_squad = ttk.Frame(haupt)
haupt.add(seite_funk, text="FUNK")
haupt.add(seite_akte, text="AKTE")
haupt.add(seite_squad, text="SQUAD")
nb = ttk.Notebook(seite_funk)
self.nb = nb
nb.pack(fill="both", expand=True, padx=16, pady=8)
nb.pack(fill="both", expand=True, pady=(6, 0))
tab_main = ttk.Frame(nb)
tab_keys = ttk.Frame(nb)
nb.add(tab_main, text=" Mikrofon ")
@ -929,6 +814,13 @@ class VoiceActivationApp:
self._build_main_tab(tab_main)
self._build_keys_tab(tab_keys)
self.akte = akte.AkteSeite(seite_akte)
self.akte.pack(fill="both", expand=True)
self.squad = squad.SquadSeite(seite_squad, self.akte, log_exception)
self.squad.pack(fill="both", expand=True)
haupt.bind("<<NotebookTabChanged>>", lambda e: self.squad.sichtbar()
if haupt.index("current") == 2 else None, add="+")
def _build_main_tab(self, parent):
f = ttk.Frame(parent)
f.pack(fill="both", expand=True, padx=12, pady=12)
@ -1130,6 +1022,7 @@ class VoiceActivationApp:
"squad_only": bool(self.squad_only_var.get()),
"pause_on_cursor": bool(self.pause_on_cursor_var.get()),
"beep": bool(self.beep_var.get()),
"modul": self.haupt_nb.index("current"),
}
def suche_update(self):
@ -1155,6 +1048,20 @@ class VoiceActivationApp:
def update_starten(self):
if not getattr(self, "update_angaben", None):
return
ordner = Path(__file__).resolve().parent
# Liegt das Programm unter C:\Program Files, darf es dort ohne
# Adminrechte nichts ersetzen. Bis 3.4 scheiterte das Update dann
# still und startete die alte Fassung neu.
if not update_helfer.beschreibbar(ordner) and not messagebox.askokcancel(
APP_NAME,
"Squad Manager liegt in einem geschuetzten Ordner:\n"
f"{ordner}\n\n"
"Zum Einspielen fragt Windows gleich nach Administratorrechten. "
"Das Programm selbst laeuft danach wieder mit normalen Rechten.\n\n"
"Dauerhaft beheben laesst sich das mit dem aktuellen Installer: "
"Er installiert in deinen Benutzerordner.",
icon="warning"):
return
self.update_btn.config(state="disabled", text="Lädt ...")
def arbeit():
@ -1168,7 +1075,6 @@ class VoiceActivationApp:
text=f"Lädt ... {anteil} %"))
lade_update(self.update_angaben, ziel, melden)
ordner = Path(__file__).resolve().parent
self.root.after(0, lambda: self.update_abschliessen(ziel, ordner))
except Exception as fehler:
log_exception(type(fehler), fehler, fehler.__traceback__)
@ -1186,11 +1092,16 @@ class VoiceActivationApp:
def update_abschliessen(self, zip_pfad, ordner):
self.update_btn.config(text="Wird eingespielt ...")
try:
spiele_update_ein(zip_pfad, ordner)
spiele_update_ein(zip_pfad, ordner,
self.update_angaben.get("installer", ""))
except Exception as fehler:
log_exception(type(fehler), fehler, fehler.__traceback__)
self.update_fehler(fehler)
return
try:
self.akte.speichern_sofort()
except Exception as e:
log_exception(type(e), e, e.__traceback__)
self.stop()
self.root.after(400, self.root.destroy)
@ -1213,6 +1124,8 @@ class VoiceActivationApp:
self.beep_var):
var.trace_add("write", self._on_setting_changed)
self._autosave_job = None
self.haupt_nb.bind("<<NotebookTabChanged>>", self._on_setting_changed,
add="+")
def _on_setting_changed(self, *_):
if getattr(self, "_autosave_job", None) is not None:
@ -1286,6 +1199,10 @@ class VoiceActivationApp:
if value in MODIFIERS:
var.set(value)
modul = cfg.get("modul")
if isinstance(modul, int) and 0 <= modul < len(self.haupt_nb.tabs()):
self.haupt_nb.select(modul)
self.save_hint.config(text="Einstellungen geladen.")
# -- Audio --------------------------------------------------------------
@ -1623,6 +1540,10 @@ class VoiceActivationApp:
self.root.after(80, self.ui_tick)
def on_close(self):
try:
self.akte.speichern_sofort()
except Exception as e:
log_exception(type(e), e, e.__traceback__)
try:
self.save_config()
except Exception:

View file

@ -26,7 +26,8 @@ from pathlib import Path
ORDNER = Path(__file__).resolve().parent
VENV_PYTHON = ORDNER / ".venv" / "Scripts" / "python.exe"
ANFORDERUNGEN = ORDNER / "requirements.txt"
EIGENE_MODULE = {"squad_manager", "theme", "akte"}
EIGENE_MODULE = {"squad_manager", "theme", "akte", "akte_modell", "akte_vorlagen",
"akte_karte", "konto", "abgleich", "hintergrund", "squad", "update_helfer"}
for pfad in (ORDNER / ".venv" / "Lib" / "site-packages", ORDNER):
if pfad.is_dir():

229
theme.py Normal file
View file

@ -0,0 +1,229 @@
"""
Erscheinungsbild von Squad Manager: Farben, Schriften, ttk-Stil und die
segmentierte Pegelanzeige.
Eigene Datei, damit mehrere Module (Funk, Akte) denselben Stil nutzen,
ohne sich gegenseitig zu importieren.
"""
import ctypes
import ctypes.wintypes as wintypes
import tkinter as tk
from tkinter import ttk
def dunkle_titelleiste(fenster):
"""
Dunkle Titelleiste fuer ein beliebiges Fenster, auch fuer Dialoge.
Windows zeichnet sie sonst hell. Attribut 20 gilt fuer aktuelle
Windows-Versionen, 19 fuer aeltere. Danach muss das Fenster einmal neu
gezeichnet werden, sonst bleibt die alte Farbe stehen.
"""
try:
fenster.update_idletasks()
hwnd = ctypes.windll.user32.GetParent(fenster.winfo_id()) or fenster.winfo_id()
an = ctypes.c_int(1)
for attribut in (20, 19):
if ctypes.windll.dwmapi.DwmSetWindowAttribute(
wintypes.HWND(hwnd), ctypes.c_uint(attribut),
ctypes.byref(an), ctypes.sizeof(an)) == 0:
fenster.withdraw()
fenster.deiconify()
return True
except Exception:
pass
return False
BG = "#151814" # Fensterhintergrund, fast schwarz mit Gruenstich
PANEL = "#1e231b" # Flaechen, Eingabefelder
PANEL_HI = "#2a3125" # Hover, ausgewaehlter Reiter
LINE = "#3d4634" # Rahmen und Trennlinien
FG = "#c9cec0" # Standardtext, helles Khaki
FG_DIM = "#7f8874" # Nebentext
OLIVE = "#6e8b3d" # Akzent, Fortschritt
OLIVE_HI = "#8cb04d" # heller Akzent
AMBER = "#d9a441" # Hinweise, Schwellenmarke
AMBER_HELL = "#e8bb63" # Mauskontakt auf der Hinweisleiste
AMBER_DUNKEL = "#2b2416" # Untergrund der Hinweisleiste
RED = "#b4472f" # Sperre, Fehler
GREEN_TX = "#9ed23f" # Sendebereit
FONT_UI = ("Segoe UI", 9)
FONT_BOLD = ("Segoe UI Semibold", 9)
FONT_TITLE = ("Segoe UI", 17, "bold")
FONT_MONO = ("Consolas", 9)
FONT_STATUS = ("Consolas", 13, "bold")
FONT_NAV = ("Segoe UI Semibold", 11)
def apply_tactical_theme(root):
"""Dunkles, gedecktes Farbschema im Stil der Spieloberflaeche."""
root.configure(bg=BG)
style = ttk.Style(root)
# "clam" ist das einzige mitgelieferte Thema, das sich durchgaengig
# umfaerben laesst - "vista" ignoriert die meisten Farbangaben.
style.theme_use("clam")
style.configure(".", background=BG, foreground=FG, font=FONT_UI,
bordercolor=LINE, darkcolor=PANEL, lightcolor=PANEL,
troughcolor=PANEL, focuscolor=OLIVE)
style.configure("TFrame", background=BG)
style.configure("TLabel", background=BG, foreground=FG)
style.configure("Dim.TLabel", foreground=FG_DIM)
style.configure("Mono.TLabel", font=FONT_MONO, foreground=FG)
style.configure("Title.TLabel", font=FONT_TITLE, foreground=FG)
style.configure("Sub.TLabel", foreground=FG_DIM)
style.configure("TLabelframe", background=BG, bordercolor=LINE,
relief="solid", borderwidth=1)
style.configure("TLabelframe.Label", background=BG, foreground=OLIVE_HI,
font=FONT_BOLD)
style.configure("TButton", background=PANEL, foreground=FG,
bordercolor=LINE, relief="solid", borderwidth=1,
padding=(12, 6), font=FONT_UI)
style.map("TButton",
background=[("pressed", OLIVE), ("active", PANEL_HI),
("disabled", PANEL)],
foreground=[("disabled", FG_DIM)],
bordercolor=[("active", OLIVE)])
style.configure("Accent.TButton", background=OLIVE, foreground="#12150f",
font=FONT_BOLD, bordercolor=OLIVE_HI)
style.map("Accent.TButton",
background=[("pressed", OLIVE), ("active", OLIVE_HI),
("disabled", PANEL)],
foreground=[("disabled", FG_DIM)])
for widget in ("TCombobox", "TSpinbox", "TEntry"):
style.configure(widget, fieldbackground=PANEL, background=PANEL,
foreground=FG, bordercolor=LINE, arrowcolor=OLIVE_HI,
insertcolor=FG, selectbackground=OLIVE,
selectforeground="#12150f", padding=4)
style.map(widget,
fieldbackground=[("readonly", PANEL), ("disabled", BG)],
foreground=[("disabled", FG_DIM)],
bordercolor=[("focus", OLIVE)])
# Die aufklappende Liste einer Combobox ist ein klassisches Tk-Widget
# und muss ueber die Optionsdatenbank eingefaerbt werden.
root.option_add("*TCombobox*Listbox.background", PANEL)
root.option_add("*TCombobox*Listbox.foreground", FG)
root.option_add("*TCombobox*Listbox.selectBackground", OLIVE)
root.option_add("*TCombobox*Listbox.selectForeground", "#12150f")
root.option_add("*TCombobox*Listbox.font", FONT_UI)
style.configure("TCheckbutton", background=BG, foreground=FG,
indicatorcolor=PANEL, indicatorrelief="solid")
style.map("TCheckbutton",
background=[("active", BG)],
indicatorcolor=[("selected", OLIVE_HI), ("active", PANEL_HI)],
foreground=[("disabled", FG_DIM)])
style.configure("TNotebook", background=BG, bordercolor=LINE,
tabmargins=(2, 4, 2, 0))
style.configure("TNotebook.Tab", background="#10120f", foreground=FG_DIM,
bordercolor=LINE, lightcolor="#10120f",
darkcolor="#10120f", padding=(20, 9), font=FONT_BOLD)
style.map("TNotebook.Tab",
background=[("selected", PANEL_HI), ("active", PANEL)],
lightcolor=[("selected", PANEL_HI)],
darkcolor=[("selected", PANEL_HI)],
foreground=[("selected", OLIVE_HI), ("active", FG)],
expand=[("selected", (0, 0, 0, 0))])
# Der Schieberegler von clam ist standardmaessig hell und wuerde aus
# dem Schema fallen.
style.configure("Horizontal.TScale", background=BG, troughcolor="#10120f",
bordercolor=LINE, lightcolor=OLIVE, darkcolor=OLIVE)
style.map("Horizontal.TScale",
background=[("active", BG)],
lightcolor=[("active", OLIVE_HI)],
darkcolor=[("active", OLIVE_HI)])
# Tabellen und Scrollbalken (Modul Akte)
style.configure("Treeview", background=PANEL, fieldbackground=PANEL,
foreground=FG, bordercolor=LINE, lightcolor=PANEL,
darkcolor=PANEL, rowheight=24, font=FONT_UI)
style.map("Treeview",
background=[("selected", OLIVE)],
foreground=[("selected", "#12150f")])
style.configure("Treeview.Heading", background=BG, foreground=FG_DIM,
bordercolor=LINE, lightcolor=BG, darkcolor=BG,
font=FONT_BOLD, relief="flat")
style.map("Treeview.Heading", background=[("active", PANEL_HI)])
style.configure("Vertical.TScrollbar", background=PANEL, troughcolor=BG,
bordercolor=LINE, arrowcolor=FG_DIM, lightcolor=PANEL,
darkcolor=PANEL)
style.map("Vertical.TScrollbar", background=[("active", PANEL_HI)])
# Hauptreiter (FUNK, AKTE): ohne Kasten, nur Schrift - so heben sie sich
# als uebergeordnete Ebene von den umrahmten Unterreitern ab.
style.configure("Haupt.TNotebook", background=BG, bordercolor=BG,
lightcolor=BG, darkcolor=BG, tabmargins=(0, 0, 0, 0))
style.configure("Haupt.TNotebook.Tab", background=BG, foreground=FG_DIM,
bordercolor=BG, lightcolor=BG, darkcolor=BG,
padding=(4, 6, 26, 6), font=FONT_NAV)
# clam gibt dem gewaehlten Reiter eine eigene Innenabstand-Regel. Ohne
# die padding-Zeile erbt dieser Stil sie, und die Schrift springt beim
# Umschalten um einige Pixel.
style.map("Haupt.TNotebook.Tab",
padding=[("selected", (4, 6, 26, 6))],
background=[("selected", BG), ("active", BG)],
lightcolor=[("selected", BG)],
darkcolor=[("selected", BG)],
bordercolor=[("selected", BG)],
foreground=[("selected", OLIVE_HI), ("active", FG)],
expand=[("selected", (0, 0, 0, 0))])
style.configure("TSeparator", background=LINE)
return style
class LevelMeter(tk.Canvas):
"""
Segmentierte Pegelanzeige mit Schwellenmarke.
Zeigt anders als eine gewoehnliche Fortschrittsleiste, wo die
Ausloeseschwelle relativ zum Pegel liegt - genau die Information,
die man zum Einstellen braucht.
"""
SEGMENTS = 40
MAXIMUM = 0.10
def __init__(self, master, width=320, height=26):
super().__init__(master, width=width, height=height, bg=PANEL,
highlightthickness=1, highlightbackground=LINE,
bd=0)
self._level = 0.0
self._threshold = 0.025
self._active = False
self.bind("<Configure>", lambda e: self._redraw())
def update_values(self, level, threshold, active):
self._level, self._threshold, self._active = level, threshold, active
self._redraw()
def _redraw(self):
self.delete("all")
w = self.winfo_width() or int(self["width"])
h = self.winfo_height() or int(self["height"])
pad = 3
seg_w = (w - 2 * pad) / self.SEGMENTS
filled = int(min(1.0, self._level / self.MAXIMUM) * self.SEGMENTS)
thr_seg = int(min(1.0, self._threshold / self.MAXIMUM) * self.SEGMENTS)
for i in range(self.SEGMENTS):
x0 = pad + i * seg_w
x1 = x0 + seg_w - 1.5
if i < filled:
colour = OLIVE_HI if self._active else OLIVE
if i >= thr_seg and not self._active:
colour = OLIVE_HI
else:
colour = "#252b1f"
self.create_rectangle(x0, pad, x1, h - pad, fill=colour, width=0)
# Schwellenmarke
x = pad + thr_seg * seg_w
self.create_line(x, 0, x, h, fill=AMBER, width=2)

209
update_helfer.py Normal file
View file

@ -0,0 +1,209 @@
"""
Spielt ein heruntergeladenes Update ein und startet das Programm neu.
Laeuft als eigener Prozess aus dem temporaeren Ordner des Updates, weil
das Programm seine Dateien nicht ersetzen soll, solange es selbst laeuft.
Verwendet nur die Standardbibliothek: Die Pakete der virtuellen Umgebung
liegen hier nicht im Suchpfad, und der Programmordner wird gerade
ueberschrieben.
Liegt das Programm in einem geschuetzten Ordner wie C:\\Program Files,
wird nur das Kopieren mit Administratorrechten wiederholt. Das Programm
selbst startet danach wieder mit normalen Rechten - mit Adminrechten
gestartet, laese es sonst unter Umstaenden die Einstellungen eines
anderen Benutzerkontos.
Aufruf: pythonw update_helfer.py <quelle> <ziel> <pid> [<installer-url>]
pythonw update_helfer.py --kopieren <quelle> <ziel>
"""
import ctypes
import ctypes.wintypes as wintypes
import os
import shutil
import subprocess
import sys
import time
import traceback
import webbrowser
from pathlib import Path
LOG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "error.log"
INSTALLER_SEITE = "https://sva.tyrveil.com"
ABGELEHNT = 1223 # ERROR_CANCELLED: Windows-Abfrage abgelehnt
KOPIEREN_GESCHEITERT = 2
kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
shell32 = ctypes.WinDLL("shell32", use_last_error=True)
user32 = ctypes.WinDLL("user32", use_last_error=True)
kernel32.OpenProcess.argtypes = (wintypes.DWORD, wintypes.BOOL, wintypes.DWORD)
kernel32.OpenProcess.restype = wintypes.HANDLE
kernel32.WaitForSingleObject.argtypes = (wintypes.HANDLE, wintypes.DWORD)
kernel32.WaitForSingleObject.restype = wintypes.DWORD
kernel32.GetExitCodeProcess.argtypes = (wintypes.HANDLE, ctypes.POINTER(wintypes.DWORD))
kernel32.GetExitCodeProcess.restype = wintypes.BOOL
kernel32.CloseHandle.argtypes = (wintypes.HANDLE,)
kernel32.CloseHandle.restype = wintypes.BOOL
user32.MessageBoxW.argtypes = (wintypes.HWND, wintypes.LPCWSTR, wintypes.LPCWSTR, wintypes.UINT)
user32.MessageBoxW.restype = ctypes.c_int
class SHELLEXECUTEINFOW(ctypes.Structure):
_fields_ = [("cbSize", wintypes.DWORD), ("fMask", wintypes.ULONG),
("hwnd", wintypes.HWND), ("lpVerb", wintypes.LPCWSTR),
("lpFile", wintypes.LPCWSTR), ("lpParameters", wintypes.LPCWSTR),
("lpDirectory", wintypes.LPCWSTR), ("nShow", ctypes.c_int),
("hInstApp", wintypes.HINSTANCE), ("lpIDList", ctypes.c_void_p),
("lpClass", wintypes.LPCWSTR), ("hkeyClass", wintypes.HKEY),
("dwHotKey", wintypes.DWORD), ("hIconOrMonitor", wintypes.HANDLE),
("hProcess", wintypes.HANDLE)]
shell32.ShellExecuteExW.argtypes = (ctypes.POINTER(SHELLEXECUTEINFOW),)
shell32.ShellExecuteExW.restype = wintypes.BOOL
def protokollieren(text):
try:
LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
with open(LOG_PATH, "a", encoding="utf-8") as datei:
datei.write(f"\n--- {time.strftime('%Y-%m-%d %H:%M:%S')} update_helfer ---\n{text}\n")
except Exception:
pass
def beschreibbar(ordner):
"""Probiert es aus. os.access kennt die Zugriffsrechte von Windows nicht."""
probe = Path(ordner) / f".schreibprobe_{os.getpid()}"
try:
with open(probe, "w") as datei:
datei.write("x")
probe.unlink()
return True
except OSError:
return False
def warten_auf_ende(pid, sekunden=20):
"""Wartet, bis das Programm beendet ist, statt eine feste Zeit zu raten."""
SYNCHRONIZE = 0x00100000
handle = kernel32.OpenProcess(SYNCHRONIZE, False, pid)
if not handle:
return # laeuft schon nicht mehr
try:
kernel32.WaitForSingleObject(handle, int(sekunden * 1000))
finally:
kernel32.CloseHandle(handle)
def kopieren(quelle, ziel):
quelle, ziel = Path(quelle), Path(ziel)
for datei in sorted(quelle.rglob("*")):
pfad = ziel / datei.relative_to(quelle)
if datei.is_dir():
pfad.mkdir(parents=True, exist_ok=True)
continue
pfad.parent.mkdir(parents=True, exist_ok=True)
# Ein Virenscanner haelt frisch geschriebene Dateien oft kurz fest
for versuch in range(6):
try:
shutil.copy2(datei, pfad)
break
except PermissionError:
if versuch == 5:
raise
time.sleep(0.5)
def mit_adminrechten_kopieren(quelle, ziel, verb="runas"):
"""
Startet diesen Helfer ein zweites Mal, nur zum Kopieren, mit Adminrechten.
Gibt den Rueckgabewert des zweiten Prozesses zurueck, ABGELEHNT wenn
die Windows-Abfrage verneint wurde.
"""
parameter = subprocess.list2cmdline(
[str(Path(__file__).resolve()), "--kopieren", str(quelle), str(ziel)])
info = SHELLEXECUTEINFOW()
info.cbSize = ctypes.sizeof(info)
info.fMask = 0x00000040 # SEE_MASK_NOCLOSEPROCESS
info.lpVerb = verb
info.lpFile = sys.executable
info.lpParameters = parameter
info.nShow = 0
if not shell32.ShellExecuteExW(ctypes.byref(info)):
return ctypes.get_last_error() or KOPIEREN_GESCHEITERT
try:
kernel32.WaitForSingleObject(info.hProcess, 5 * 60 * 1000)
code = wintypes.DWORD()
kernel32.GetExitCodeProcess(info.hProcess, ctypes.byref(code))
return code.value
finally:
kernel32.CloseHandle(info.hProcess)
def einspielen(quelle, ziel):
"""Gibt None zurueck, wenn alles kopiert ist, sonst eine Fehlerbeschreibung."""
try:
if beschreibbar(ziel):
kopieren(quelle, ziel)
return None
code = mit_adminrechten_kopieren(quelle, ziel)
except Exception:
protokollieren(traceback.format_exc())
return "Die neuen Dateien konnten nicht in den Programmordner kopiert werden."
if code == 0:
return None
if code == ABGELEHNT:
return ("Die Abfrage nach Administratorrechten wurde abgelehnt. Ohne sie "
"darf in den Programmordner nicht geschrieben werden.")
return f"Das Kopieren mit Administratorrechten ist gescheitert (Code {code})."
def melden(fehler, ziel, installer_url):
text = (f"Das Update konnte nicht eingespielt werden.\n\n{fehler}\n\n"
f"Programmordner:\n{ziel}\n\n"
"Squad Manager startet jetzt in der bisherigen Version. Abhilfe "
"schafft der aktuelle Installer: Er installiert in deinen "
"Benutzerordner, dort klappen kuenftige Updates ohne Rueckfrage.\n\n"
"Installer jetzt herunterladen?")
MB_YESNO, MB_ICONWARNING, MB_TOPMOST, IDYES = 0x4, 0x30, 0x40000, 6
antwort = user32.MessageBoxW(None, text, "Squad Manager - Update",
MB_YESNO | MB_ICONWARNING | MB_TOPMOST)
if antwort == IDYES:
webbrowser.open(installer_url or INSTALLER_SEITE)
def neu_starten(ziel):
start = Path(ziel) / "start.pyw"
if start.is_file():
subprocess.Popen([sys.executable, str(start)], cwd=str(ziel),
creationflags=0x08000000) # kein Konsolenfenster
def main(argumente):
if argumente[:1] == ["--kopieren"]:
try:
kopieren(argumente[1], argumente[2])
return 0
except Exception:
protokollieren(traceback.format_exc())
return KOPIEREN_GESCHEITERT
quelle, ziel, pid = Path(argumente[0]), Path(argumente[1]), int(argumente[2])
installer_url = argumente[3] if len(argumente) > 3 else ""
warten_auf_ende(pid)
fehler = einspielen(quelle, ziel)
if fehler:
protokollieren(f"{fehler}\nQuelle: {quelle}\nZiel: {ziel}")
melden(fehler, ziel, installer_url)
neu_starten(ziel)
# Der Arbeitsordner enthaelt auch diese Datei. Python hat sie beim
# Start vollstaendig gelesen, sie darf also mit weg.
shutil.rmtree(quelle.parent, ignore_errors=True)
return 1 if fehler else 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))

245
werkzeuge/abgleich_test.py Normal file
View file

@ -0,0 +1,245 @@
"""
Test des Akten-Abgleichs mit zwei simulierten Rechnern.
Startet den lokalen Testserver aus server_test.py. Jeder "Rechner" ist ein
eigener Python-Prozess mit eigenem %APPDATA% - so wie zwei echte PCs mit
demselben Konto. Beruehrt weder echte Akten noch den echten Server.
Aufruf: .venv\\Scripts\\python.exe werkzeuge\\abgleich_test.py
"""
import json
import os
import re
import subprocess
import sys
import tempfile
import urllib.parse
from pathlib import Path
WURZEL = Path(__file__).resolve().parent.parent
# SM_PROGRAMM=dist\paket\Programm prueft das gebaute Paket statt der Quelle
PROGRAMM = Path(os.environ.get("SM_PROGRAMM") or WURZEL)
sys.path.insert(0, str(Path(__file__).resolve().parent))
# -- Ein Rechner: wird als eigener Prozess mit "pc" aufgerufen ----------------
def rechner_befehl(aktion, parameter):
sys.path.insert(0, str(PROGRAMM))
import hashlib
from PIL import Image
import abgleich
import akte_modell as modell
import konto
def portraet_setzen(akte_id, farbe):
pfad = Path(tempfile.gettempdir()) / f"sm_test_{akte_id}.jpg"
Image.new("RGB", (400, 500), tuple(farbe)).save(pfad, "JPEG")
modell.portraet_setzen(akte_id, pfad)
pfad.unlink()
if aktion == "anmelden":
return konto.anmelden(parameter["login"], parameter["passwort"])
if aktion == "akte_anlegen":
akte = modell.neu_anlegen()
akte["personalien"]["callsign"] = parameter["callsign"]
akte["dienst"].update({"fraktion": "Bundeswehr", "teilstreitkraft": "Heer", "rang": "Feldwebel"})
modell.speichern(akte)
if parameter.get("farbe"):
portraet_setzen(akte["id"], parameter["farbe"])
return akte["id"]
if aktion == "rang":
akte = modell.laden(parameter["id"])
akte["dienst"]["rang"] = parameter["rang"]
modell.speichern(akte)
return True
if aktion == "portraet":
portraet_setzen(parameter["id"], parameter["farbe"])
return True
if aktion == "papierkorb":
abgleich.loeschen_vormerken(parameter["id"])
modell.in_papierkorb(parameter["id"])
return True
if aktion == "abgleichen":
ergebnis = abgleich.abgleichen()
return {**ergebnis, "geaendert": sorted(ergebnis["geaendert"])}
if aktion == "ausstehend":
return abgleich.ausstehend()
if aktion == "akten":
liste = []
for akte in modell.alle_akten():
pfad = modell.portraet_pfad(akte["id"])
ordner = modell.ordner_von(akte["id"])
liste.append({
"id": akte["id"], "aktennummer": akte["aktennummer"],
"callsign": akte["personalien"]["callsign"], "rang": akte["dienst"]["rang"],
"portraet": hashlib.sha256(pfad.read_bytes()).hexdigest() if pfad else "",
"konflikte": len(list(ordner.glob("konflikt-*.json"))),
"meta": abgleich.meta_laden(akte["id"]),
})
return liste
if aktion == "konto_datei":
return konto.KONTO_DATEI.read_text(encoding="utf-8")
raise ValueError(aktion)
class Rechner:
server = None
def __init__(self, name, basis):
self.name = name
self.appdata = tempfile.mkdtemp(prefix=f"sm_pc_{name}_")
self.basis = basis
def __call__(self, aktion, **parameter):
umgebung = dict(os.environ, APPDATA=self.appdata, SM_SERVER=self.basis, PYTHONIOENCODING="utf-8")
lauf = subprocess.run([sys.executable, __file__, "pc", aktion, json.dumps(parameter)],
capture_output=True, text=True, encoding="utf-8", env=umgebung, timeout=120)
zeilen = [z for z in lauf.stdout.splitlines() if z.startswith("ERGEBNIS ")]
if not zeilen:
raise RuntimeError(f"{self.name}.{aktion} gescheitert:\n{lauf.stdout}\n{lauf.stderr}")
antwort = json.loads(zeilen[-1][len("ERGEBNIS "):])
if "fehler" in antwort:
print(f" ({self.name}.{aktion}: {antwort['fehler']} - {antwort.get('meldung')})")
if antwort["fehler"] == "offline" and Rechner.server is not None and "127.0.0.1:9" not in self.basis:
print(f" (Testserver läuft noch: {Rechner.server.laeuft()})")
import time
print(f" (Zeit jetzt {time.strftime('%H:%M:%S')}, letzte Zeilen des PHP-Servers:)\n"
+ Rechner.server.php_protokoll(40))
return antwort
return antwort["wert"]
# -- Ablauf -------------------------------------------------------------------
def main():
import server_test as st
from server_test import pruefe
server = st.Server()
try:
ablauf(server, pruefe)
finally:
log = server.daten / "fehler.log"
inhalt = log.read_text(encoding="utf-8") if log.exists() else ""
pruefe("fehler.log des Servers leer", not inhalt.strip(), inhalt[-600:])
server.beenden()
print(f"\nERGEBNIS: {st.ergebnisse['ok']} bestanden, {st.ergebnisse['fehl']} fehlgeschlagen")
sys.exit(1 if st.ergebnisse["fehl"] else 0)
def ablauf(server, pruefe):
import server_test as st
print("Vorbereitung")
code, html, _ = server.roh("/einrichten.php", {"schluessel": st.SCHLUESSEL})
pruefe("Testserver eingerichtet", "Tabellen vorhanden" in html.decode(), html[-300:])
code, antwort = server.api("registrieren", benutzername="danny", email="danny@example.org",
passwort="dannypasswort1")
pruefe("Konto registriert", antwort.get("ok"), antwort)
link = server.link_aus_mail("danny@example.org")
teile = urllib.parse.urlparse(link)
code, html, _ = server.roh(teile.path + "?" + teile.query)
pruefe("E-Mail bestätigt", "bestätigt" in html.decode())
Rechner.server = server
a = Rechner("A", server.basis)
b = Rechner("B", server.basis)
print("Erstes Hochladen (Rechner A)")
nordlicht = a("akte_anlegen", callsign="Nordlicht", farbe=[60, 80, 50])
frost = a("akte_anlegen", callsign="Frost")
pruefe("ohne Anmeldung nichts ausstehend", a("ausstehend") is False)
pruefe("Anmeldung", a("anmelden", login="danny", passwort="dannypasswort1").get("benutzername") == "danny")
datei = a("konto_datei")
pruefe("Token nicht im Klartext gespeichert", not re.search(r"[0-9a-f]{64}", datei), datei[:120])
pruefe("vor dem Abgleich ausstehend", a("ausstehend") is True)
erg = a("abgleichen")
pruefe("zwei Akten hochgeladen", erg["hochgeladen"] == 2, erg)
akten_a = {x["callsign"]: x for x in a("akten")}
pruefe("Server-Nummern übernommen, Meta geschrieben",
all(x["meta"] and x["meta"]["server_id"] and re.fullmatch(r"SM-\d{4}-\d{4}", x["aktennummer"])
for x in akten_a.values()), akten_a)
pruefe("Porträt-Kennung gemerkt", akten_a["Nordlicht"]["meta"]["portraet_kennung"], akten_a["Nordlicht"]["meta"])
pruefe("danach nichts ausstehend", a("ausstehend") is False)
erg = a("abgleichen")
pruefe("zweiter Abgleich tut nichts", erg["hochgeladen"] == 0 and erg["heruntergeladen"] == 0, erg)
print("Zweiter Rechner (B)")
b("anmelden", login="danny@example.org", passwort="dannypasswort1")
erg = b("abgleichen")
pruefe("zwei Akten heruntergeladen", erg["heruntergeladen"] == 2 and len(erg["geaendert"]) == 2, erg)
akten_b = {x["callsign"]: x for x in b("akten")}
pruefe("gleiche IDs und Nummern wie auf A",
{k: (v["id"], v["aktennummer"]) for k, v in akten_b.items()}
== {k: (v["id"], v["aktennummer"]) for k, v in akten_a.items()}, akten_b)
pruefe("Porträt mit heruntergeladen", akten_b["Nordlicht"]["portraet"] != "" and akten_b["Frost"]["portraet"] == "")
erg = b("abgleichen")
pruefe("B: zweiter Abgleich tut nichts",
erg["hochgeladen"] == 0 and erg["heruntergeladen"] == 0 and not erg["geaendert"], erg)
print("Änderung wandert von B nach A")
b("rang", id=nordlicht, rang="Hauptfeldwebel")
erg = b("abgleichen")
pruefe("B hochgeladen", erg.get("hochgeladen") == 1, erg)
erg = a("abgleichen")
pruefe("A heruntergeladen", erg["heruntergeladen"] == 1 and nordlicht in erg["geaendert"], erg)
pruefe("A hat den neuen Rang", {x["id"]: x["rang"] for x in a("akten")}[nordlicht] == "Hauptfeldwebel")
print("Konflikt: beide ändern dieselbe Akte")
a("rang", id=frost, rang="Stabsfeldwebel")
b("rang", id=frost, rang="Oberstabsfeldwebel")
erg = a("abgleichen")
pruefe("A lädt zuerst hoch", erg.get("hochgeladen") == 1, erg)
erg = b("abgleichen")
pruefe("B erkennt Konflikt", erg["konflikte"] == 1 and erg["hochgeladen"] == 1, erg)
frost_b = {x["id"]: x for x in b("akten")}[frost]
pruefe("B behält eigene Fassung, Serverfassung gesichert",
frost_b["rang"] == "Oberstabsfeldwebel" and frost_b["konflikte"] == 1, frost_b)
a("abgleichen")
pruefe("A übernimmt Bs Fassung", {x["id"]: x["rang"] for x in a("akten")}[frost] == "Oberstabsfeldwebel")
print("Porträt geändert")
b("portraet", id=frost, farbe=[150, 40, 40])
pruefe("B lädt Porträt hoch", b("abgleichen") is not None)
erg = a("abgleichen")
pruefe("A lädt neues Porträt", frost in erg.get("geaendert", []) and {x["id"]: x["portraet"] for x in a("akten")}[frost], erg)
erg = a("abgleichen")
pruefe("A: Porträt nicht erneut hochgeladen", erg["hochgeladen"] == 0 and not erg["geaendert"], erg)
erg = b("abgleichen")
pruefe("B: nichts mehr zu tun", erg["hochgeladen"] == 0 and erg["heruntergeladen"] == 0 and not erg["geaendert"], erg)
print("Löschen")
a("papierkorb", id=nordlicht)
pruefe("A: Löschung ausstehend", a("ausstehend") is True)
a("abgleichen")
pruefe("A: danach nichts ausstehend", a("ausstehend") is False)
code, antwort = server.api("anmelden", login="danny", passwort="dannypasswort1")
code, antwort = server.api("charaktere_eigene", token=antwort["token"])
pruefe("auf dem Server gelöscht", [c["lokale_id"] for c in antwort["charaktere"]] == [frost], antwort)
erg = b("abgleichen")
pruefe("B verschiebt sie in den Papierkorb", erg["entfernt"] == 1, erg)
pruefe("B hat nur noch Frost", [x["id"] for x in b("akten")] == [frost])
print("Ohne Server")
offline = Rechner("C", "http://127.0.0.1:9")
antwort = offline("anmelden", login="danny", passwort="dannypasswort1")
pruefe("keine Verbindung: verständlicher Fehler", antwort.get("fehler") == "offline", antwort)
if __name__ == "__main__":
if len(sys.argv) >= 2 and sys.argv[1] == "pc":
sys.path.insert(0, str(PROGRAMM))
import konto
try:
wert = rechner_befehl(sys.argv[2], json.loads(sys.argv[3]))
print("ERGEBNIS " + json.dumps({"wert": wert}, ensure_ascii=False, default=str))
except konto.ServerFehler as fehler:
ursache = f" [{type(fehler.__cause__).__name__}: {fehler.__cause__}]" if fehler.__cause__ else ""
print("ERGEBNIS " + json.dumps({"fehler": fehler.code, "meldung": fehler.meldung + ursache},
ensure_ascii=False))
else:
main()

View file

@ -6,18 +6,21 @@ Ergebnis in dist/:
SquadManager-<v>.zip Paket fuer den Auto-Updater
SquadManager-Setup-<v>.exe
version.json Steuerdatei fuer den Server
server/ genau das, was hochgeladen wird
server/ Inhalt fuer /sva.tyrveil.com (Webseite, Updates, Schnittstelle)
sva-privat/ Logik des Servers, neben /sva.tyrveil.com - ohne config.php
Aufruf: .venv\\Scripts\\python.exe werkzeuge\\baue_release.py
"""
import hashlib
import html
import io
import json
import re
import shutil
import subprocess
import sys
import time
import tokenize
import zipfile
from pathlib import Path
@ -25,8 +28,15 @@ from pathlib import Path
WURZEL = Path(__file__).resolve().parent.parent
DIST = WURZEL / "dist"
BASIS_URL = "https://sva.tyrveil.com"
# Programme bis 4.0 vergleichen nur das Feld "version" mit ihrer eigenen
# Nummer. Es muss deshalb dauerhaft groesser als 4.0 bleiben - nie senken,
# sonst bekommen sie kein Update mehr. Neuere Programme lesen "build".
VERSION_FUER_ALTE_PROGRAMME = "4.1"
PYTHON_DATEIEN = ("squad_manager.py", "start.pyw", "make_icon.py")
PYTHON_DATEIEN = ("squad_manager.py", "theme.py", "akte.py", "akte_modell.py",
"akte_vorlagen.py", "akte_karte.py", "konto.py", "abgleich.py",
"hintergrund.py", "squad.py", "update_helfer.py", "start.pyw",
"make_icon.py")
MITKOPIEREN = ("requirements.txt", "icon.png", "icon.ico")
ISCC_KANDIDATEN = (
@ -69,15 +79,45 @@ UMLAUTE = [
("aelteren", "älteren"), ("massgeblich", "maßgeblich"),
("Pruefsumme", "Prüfsumme"), ("entschluesselt", "entschlüsselt"),
("unveraendert", "unverändert"), ("Netzwerkfehler", "Netzwerkfehler"),
("schuetz", "schütz"), ("kuenftig", "künftig"), ("Rueckfrage", "Rückfrage"),
]
def version_lesen():
text = (WURZEL / "squad_manager.py").read_text(encoding="utf-8")
treffer = re.search(r'^VERSION\s*=\s*"([^"]+)"', text, re.M)
if not treffer:
raise SystemExit("VERSION nicht gefunden")
return treffer.group(1)
build = re.search(r'^BUILD\s*=\s*(\d+)', text, re.M)
if not treffer or not build:
raise SystemExit("VERSION oder BUILD nicht gefunden")
return treffer.group(1), int(build.group(1))
def build_pruefen(build):
"""Warnt, wenn BUILD nicht hoeher ist als online - das Update kaeme sonst nirgends an."""
import urllib.request
try:
with urllib.request.urlopen(f"{BASIS_URL}/version.json", timeout=8) as antwort:
online = json.loads(antwort.read(65536).decode("utf-8"))
except Exception as fehler:
print(f" Server nicht erreichbar, Build nicht verglichen ({type(fehler).__name__})")
return
online_build = online.get("build")
if online_build is not None and int(online_build) >= build:
print(f" WARNUNG: Online liegt schon Build {online_build}. BUILD in "
"squad_manager.py erhoehen, sonst sieht niemand das Update.")
else:
print(f" Build {build} ist neuer als online ({online_build or online.get('version')})")
# Zeichenketten wie "charakter_loeschen" oder "server.json" sind Aktionsnamen,
# Schluessel und Dateinamen. Umlaute darin brechen die Verstaendigung mit dem
# Server - 1.6.0 schickte sonst "konto_löschen" an eine Schnittstelle, die
# "konto_loeschen" erwartet.
BEZEICHNER = re.compile(r"""^[rbuRBU]{0,2}(['"])[a-z0-9_.\-/]*\1$""")
def ist_bezeichner(zeichenkette):
return bool(BEZEICHNER.match(zeichenkette))
def aufbereiten(pfad: Path):
@ -98,7 +138,7 @@ def aufbereiten(pfad: Path):
tokens = []
for tok in tokenize.generate_tokens(io.StringIO(text).readline):
if tok.type == tokenize.STRING:
if tok.type == tokenize.STRING and not ist_bezeichner(tok.string):
neu = tok.string
for alt, ersatz in UMLAUTE:
neu = neu.replace(alt, ersatz)
@ -181,7 +221,51 @@ def installer_bauen(version):
return DIST / f"SquadManager-Setup-{version}.exe"
def server_bauen(version, zip_pfad, setup_pfad):
def seite_bauen(server, version, setup_pfad):
"""
Downloadseite index.html aus installer/downloadseite.html.
Die Seite liest beim Aufruf version.json und zeigt dann ohnehin die
Version vom Server. Die hier eingesetzten Werte greifen, wenn das nicht
klappt, und liefern Groesse und Datum der gebauten Fassung.
"""
vorlage = WURZEL / "installer" / "downloadseite.html"
if not vorlage.is_file():
return
groesse = ""
if setup_pfad and setup_pfad.exists():
groesse = f"{setup_pfad.stat().st_size / 1048576:.1f} MB".replace(".", ",")
werte = {
"__VERSION__": version,
"__INSTALLER__": setup_pfad.name if setup_pfad else "",
"__GROESSE__": groesse,
"__DATUM__": time.strftime("%d.%m.%Y"),
}
text = vorlage.read_text(encoding="utf-8")
for platzhalter, wert in werte.items():
text = text.replace(platzhalter, html.escape(wert))
(server / "index.html").write_text(text, encoding="utf-8", newline="\n")
shutil.copy2(WURZEL / "icon.png", server / "icon.png")
def server_dateien_bauen(server):
"""
Oeffentliche PHP-Dateien nach server/, die Logik nach sva-privat/.
config.php und der Datenordner kommen nie mit: Die config.php auf dem
Server enthaelt das Datenbank-Passwort und darf beim Hochladen nicht
ueberschrieben werden.
"""
quelle = WURZEL / "server"
shutil.copytree(quelle / "sva.tyrveil.com", server, dirs_exist_ok=True)
privat = DIST / "sva-privat"
if privat.exists():
shutil.rmtree(privat)
shutil.copytree(quelle / "sva-privat", privat,
ignore=shutil.ignore_patterns("config.php", "daten", "*.sqlite"))
def server_bauen(version, build, zip_pfad, setup_pfad):
server = DIST / "server"
if server.exists():
shutil.rmtree(server)
@ -192,14 +276,21 @@ def server_bauen(version, zip_pfad, setup_pfad):
shutil.copy2(setup_pfad, server / setup_pfad.name)
anleitung = WURZEL / "installer" / "HOCHLADEN.txt"
if anleitung.is_file():
shutil.copy2(anleitung, server / anleitung.name)
text = anleitung.read_text(encoding="utf-8").replace("__VERSION__", version)
(server / anleitung.name).write_text(text, encoding="utf-8", newline="\r\n")
seite_bauen(server, version, setup_pfad)
server_dateien_bauen(server)
pruefsumme = hashlib.sha256(zip_pfad.read_bytes()).hexdigest()
angaben = {
"version": version,
"version": VERSION_FUER_ALTE_PROGRAMME,
"anzeige": version,
"build": build,
"datei": f"{BASIS_URL}/{zip_pfad.name}",
"sha256": pruefsumme,
"hinweis": "",
# Ab 4.0: Ziel fuer den Hinweis, wenn ein Update nicht einspielbar ist
"installer": f"{BASIS_URL}/SquadManager-Setup-{version}.exe",
}
(server / "version.json").write_text(
json.dumps(angaben, indent=2, ensure_ascii=False) + "\n",
@ -208,9 +299,10 @@ def server_bauen(version, zip_pfad, setup_pfad):
def main():
version = version_lesen()
version, build = version_lesen()
DIST.mkdir(exist_ok=True)
print(f"Version {version}")
print(f"Version {version} (Build {build})")
build_pruefen(build)
paket = paket_bauen(version)
print(" Programmdateien aufbereitet")
@ -222,7 +314,7 @@ def main():
if setup_pfad:
print(f" {setup_pfad.name} ({setup_pfad.stat().st_size // 1024} KB)")
server, pruefsumme = server_bauen(version, zip_pfad, setup_pfad)
server, pruefsumme = server_bauen(version, build, zip_pfad, setup_pfad)
print(f" server/ vorbereitet, SHA256 {pruefsumme[:16]}...")
print()
print(f"Zum Hochladen bereit: {server}")

View file

@ -0,0 +1,302 @@
"""
Test des Squad-Reiters im laufenden Programm gegen den lokalen Testserver.
Legt zwei Konten an, startet das Programm mit eigenem %APPDATA%, meldet
sich ueber die Eingabefelder an, wartet den Abgleich ab, nimmt eine
Einladung an und oeffnet eine fremde Akte. Bildschirmfotos landen im
Ordner, der als erstes Argument uebergeben wird (Standard: Temp).
Aufruf: .venv\\Scripts\\python.exe werkzeuge\\oberflaeche_test.py [bildordner]
"""
import ctypes
import ctypes.wintypes as wintypes
import os
import subprocess
import sys
import tempfile
import time
import urllib.parse
from pathlib import Path
WURZEL = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(Path(__file__).resolve().parent))
import server_test as st # noqa: E402
BILDER = Path(sys.argv[1]) if len(sys.argv) > 1 else Path(tempfile.gettempdir())
server = st.Server()
os.environ["SM_SERVER"] = server.basis
os.environ["APPDATA"] = tempfile.mkdtemp(prefix="sm_ui_")
# SM_PROGRAMM=dist\paket\Programm prueft das gebaute Paket statt der Quelle
sys.path.insert(0, os.environ.get("SM_PROGRAMM") or str(WURZEL))
import tkinter as tk # noqa: E402
from PIL import Image # noqa: E402
import akte_modell as modell # noqa: E402
import konto # noqa: E402
import squad_manager as sm # noqa: E402
pruefe = st.pruefe
def konto_anlegen(name, email, passwort):
server.api("registrieren", benutzername=name, email=email, passwort=passwort)
teile = urllib.parse.urlparse(server.link_aus_mail(email))
server.roh(teile.path + "?" + teile.query)
return server.api("anmelden", login=name, passwort=passwort)[1]["token"]
# -- Vorbereitung auf dem Server und lokal ---------------------------------------
server.roh("/einrichten.php", {"schluessel": st.SCHLUESSEL})
kamerad = konto_anlegen("kamerad", "kamerad@example.org", "kameradpasswort1")
rook_akte = {"schema": 1, "id": "ab" * 16, "personalien": {"vorname": "Dale", "nachname": "Hutchins", "callsign": "Rook"},
"dienst": {"fraktion": "US Marine Corps", "teilstreitkraft": "Marineinfanterie",
"rang": "Corporal (Cpl)", "verwendung": "Automatic Rifleman", "status": "gefallen"},
"beschreibung": "Gefallen bei der Verteidigung von Point Alpha.", "auszeichnungen": [],
"einsaetze": [], "vermerke": ""}
rook = server.api("charakter_speichern", token=kamerad, lokale_id=rook_akte["id"], daten=rook_akte)[1]["charakter"]
hawk_akte = dict(rook_akte, id="cd" * 16, personalien={"vorname": "Mia", "nachname": "Lindqvist", "callsign": "Hawk"},
dienst={"fraktion": "Schweden – Försvarsmakten", "teilstreitkraft": "Amphibienkorps (Amfibiekåren)",
"rang": "Sergeant", "verwendung": "Squad Leader", "status": "aktiv"})
hawk = server.api("charakter_speichern", token=kamerad, lokale_id=hawk_akte["id"], daten=hawk_akte)[1]["charakter"]
squad = server.api("squad_gruenden", token=kamerad, charakter_id=hawk["id"], name="Nordwind",
beschreibung="Amphibische Aufklärung, Schären vor Stockholm.")[1]["squad"]
server.api("squad_einladen", token=kamerad, squad_id=squad["id"], charakter_id=rook["id"])
server.api("einladung_beantworten", token=kamerad,
einladung_id=server.api("einladungen", token=kamerad)[1]["eingang"][0]["id"], annehmen=True)
nordlicht = modell.neu_anlegen()
nordlicht["personalien"].update({"vorname": "Erik", "nachname": "Brandt", "callsign": "Nordlicht"})
nordlicht["dienst"].update({"fraktion": "Bundeswehr", "teilstreitkraft": "Heer", "rang": "Oberfeldwebel",
"verwendung": "Squad Leader"})
modell.speichern(nordlicht)
bild = Path(os.environ["APPDATA"]) / "portraet.jpg"
Image.new("RGB", (400, 500), (58, 70, 46)).save(bild, "JPEG")
modell.portraet_setzen(nordlicht["id"], bild)
lokale_nummer = nordlicht["aktennummer"]
# -- Programm ---------------------------------------------------------------------
class RECT(ctypes.Structure):
_fields_ = [("l", wintypes.LONG), ("t", wintypes.LONG), ("r", wintypes.LONG), ("b", wintypes.LONG)]
def foto(fenster, name):
fenster.update_idletasks()
fenster.update()
hwnd = ctypes.windll.user32.GetParent(fenster.winfo_id()) or fenster.winfo_id()
r = RECT()
ctypes.windll.user32.GetWindowRect(wintypes.HWND(hwnd), ctypes.byref(r))
ziel = BILDER / name
ps = ("Add-Type -AssemblyName System.Drawing;"
f"$b = New-Object System.Drawing.Bitmap {r.r - r.l},{r.b - r.t};"
"$g = [System.Drawing.Graphics]::FromImage($b);"
f"$g.CopyFromScreen({r.l},{r.t},0,0,$b.Size);$b.Save('{ziel}')")
subprocess.run(["powershell", "-NoProfile", "-Command", ps], capture_output=True)
fehler = []
root = tk.Tk()
sm.apply_tactical_theme(root)
app = sm.VoiceActivationApp(root)
root.report_callback_exception = lambda *a: fehler.append(a)
root.attributes("-topmost", True)
seite = app.squad
def warte(bedingung, dann, grenze=60.0, name=""):
start = time.time()
def pruefen():
if bedingung():
dann()
elif time.time() - start > grenze:
pruefe(f"Zeitlimit: {name}", False)
ende()
else:
root.after(150, pruefen)
root.after(150, pruefen)
def schritt_anmeldung():
app.haupt_nb.select(2)
root.update()
pruefe("ohne Mitmachen: Einstiegsseite", seite.anmeldung.winfo_ismapped())
pruefe("vor dem Mitmachen nichts hochgeladen", "Nur auf diesem PC" in app.akte.abgleich_var.get(),
app.akte.abgleich_var.get())
foto(root, "ui_1_mitmachen.png")
seite.anmeldung.spielername_var.set("danny")
seite.anmeldung.mitmachen()
warte(lambda: konto.angemeldet() and seite.inhalt.winfo_ismapped(), schritt_abgleich, name="Mitmachen")
def schritt_abgleich():
root.update()
pruefe("mitgemacht ohne Konto", seite.nutzer_var.get() == "Spieler: danny"
and not konto.gesichert(), seite.nutzer_var.get())
pruefe("Hinweis 'Konto sichern' sichtbar", seite.sichern_zeile.winfo_ismapped()
and "Konto sichern" in seite.sichern_text.cget("text"))
seite._konto_menue_fuellen()
eintraege = [seite.konto_menue.entrycget(i, "label") for i in range(seite.konto_menue.index("end") + 1)
if seite.konto_menue.type(i) == "command"]
pruefe("Menü: Konto sichern statt Abmelden", "Konto sichern …" in eintraege and "Abmelden" not in eintraege,
eintraege)
warte(lambda: "abgeglichen" in app.akte.abgleich_var.get(), schritt_liste, name="Abgleich")
def schritt_liste():
geladen = modell.laden(nordlicht["id"])
pruefe("Aktennummer vom Server übernommen", geladen["aktennummer"] != lokale_nummer
or geladen["aktennummer"].startswith("SM-"), (lokale_nummer, geladen["aktennummer"]))
pruefe("AKTE-Reiter zeigt Abgleich", "abgeglichen" in app.akte.abgleich_var.get(), app.akte.abgleich_var.get())
seite._zuletzt_geladen = 0
seite._laedt = False
seite.aktualisieren()
warte(lambda: len(seite.charaktere) == 3 and len(seite.einladungen["eingang"]) == 0, schritt_einladung,
name="Liste laden")
def schritt_einladung():
namen = {c["callsign"]: c for c in seite.charaktere}
pruefe("drei Charaktere, eigener markiert", set(namen) == {"Nordlicht", "Rook", "Hawk"} and namen["Nordlicht"]["eigener"])
pruefe("Zustand KIA in der Liste", seite.liste.item(str(namen["Rook"]["id"]))["values"][2] == "KIA · gefallen",
seite.liste.item(str(namen["Rook"]["id"]))["values"])
seite.liste.selection_set(str(namen["Rook"]["id"]))
root.update()
pruefe("Einladen gesperrt ohne eigenes Squad", str(seite.knopf_einladen["state"]) == "disabled",
seite.einladen_hinweis.cget("text"))
# Das Portraet hat nur Nordlicht - hochgeladen vom Abgleich
seite.liste.selection_set(str(namen["Nordlicht"]["id"]))
root.update()
def konto_menue_foto():
foto(root, "ui_2_charaktere.png")
knopf = next(w for w in seite.inhalt.winfo_children()[0].winfo_children() if isinstance(w, tk.Menubutton)
or w.winfo_class() == "TMenubutton")
pruefe("Konto-Knopf vorhanden", knopf.cget("text") == "Konto")
schritt_einladen()
warte(lambda: seite.bild.cget("text") == "", konto_menue_foto, grenze=15, name="Porträt laden")
def schritt_einladen():
server.api("squad_einladen", token=kamerad, squad_id=squad["id"],
charakter_id=next(c["id"] for c in seite.charaktere if c["callsign"] == "Nordlicht"))
seite.aktualisieren()
warte(lambda: len(seite.einladungen["eingang"]) == 1, schritt_annehmen, name="Einladung laden")
def schritt_annehmen():
seite.nb.select(2)
pruefe("Reiter zeigt Anzahl", seite.nb.tab(seite.einladungen_seite, "text") == "Einladungen (1)")
seite.eingang.selection_set(seite.eingang.get_children()[0])
root.update()
foto(root, "ui_3_einladungen.png")
seite.einladung_beantworten(True)
warte(lambda: any(c["callsign"] == "Nordlicht" and c.get("squad") for c in seite.charaktere)
and not seite.einladungen["eingang"], schritt_squad, name="Annehmen")
def schritt_squad():
pruefe("Nordlicht ist jetzt in Nordwind", next(c for c in seite.charaktere
if c["callsign"] == "Nordlicht")["squad"]["name"] == "Nordwind")
seite.nb.select(1)
seite.squad_liste.selection_set(seite.squad_liste.get_children()[0])
root.update()
pruefe("drei Mitglieder, Führer mit Stern", len(seite.mitglieder.get_children()) == 3
and str(seite.mitglieder.item(seite.mitglieder.get_children()[0])["values"][0]).startswith("★"))
pruefe("Nicht-Führer: Auflösen gesperrt, Verlassen möglich",
str(seite.knopf_aufloesen["state"]) == "disabled" and str(seite.knopf_verlassen["state"]) == "normal")
foto(root, "ui_4_squads.png")
seite.nb.select(0)
seite.liste.selection_set(str(next(c["id"] for c in seite.charaktere if c["callsign"] == "Rook")))
root.update()
vorher = set(fenster_alle(root))
seite.akte_ansehen()
warte(lambda: set(fenster_alle(root)) - vorher, lambda: schritt_fenster(vorher), name="Akte ansehen")
def fenster_alle(widget):
"""Alle Toplevel-Fenster im Baum - das Aktenfenster haengt am Squad-Reiter, nicht an root."""
for kind in widget.winfo_children():
if isinstance(kind, tk.Toplevel):
yield kind
yield from fenster_alle(kind)
def schritt_fenster(vorher):
fenster = next(iter(set(fenster_alle(root)) - vorher))
fenster.attributes("-topmost", True)
root.after(600, lambda: (foto(fenster, "ui_5_fremde_akte.png"), fenster.destroy(), schritt_akte()))
def schritt_akte():
app.haupt_nb.select(1)
root.after(500, lambda: (foto(root, "ui_6_akte_status.png"), schritt_sichern()))
def schritt_sichern():
app.haupt_nb.select(2)
seite.hintergrund.starten(lambda: konto.konto_sichern("danny@example.org", "dannypasswort1"),
lambda _: seite._kopf_aktualisieren(), lambda f: fehler.append((type(f), f, None)))
warte(lambda: konto.gesichert(), schritt_bestaetigen, name="Konto sichern")
def schritt_bestaetigen():
root.update()
pruefe("nach dem Sichern: Hinweis auf Bestätigung", "nicht bestätigt" in seite.sichern_text.cget("text"),
seite.sichern_text.cget("text"))
teile = urllib.parse.urlparse(server.link_aus_mail("danny@example.org"))
server.roh(teile.path + "?" + teile.query)
seite._laedt = False
seite.aktualisieren()
warte(lambda: (konto.nutzer() or {}).get("bestaetigt") and not seite.sichern_zeile.winfo_ismapped(),
schritt_nach_bestaetigung, name="Bestätigung übernehmen")
def schritt_nach_bestaetigung():
seite._konto_menue_fuellen()
eintraege = [seite.konto_menue.entrycget(i, "label") for i in range(seite.konto_menue.index("end") + 1)
if seite.konto_menue.type(i) == "command"]
pruefe("gesichert und bestätigt: Hinweis weg, Menü mit Abmelden", "Abmelden" in eintraege, eintraege)
code, antwort = server.api("anmelden", login="danny@example.org", passwort="dannypasswort1")
pruefe("zweiter PC könnte sich jetzt anmelden", antwort.get("nutzer", {}).get("benutzername") == "danny", antwort)
schritt_konto_loeschen()
def schritt_konto_loeschen():
app.haupt_nb.select(2)
seite.nb.select(0)
root.update()
seite.konto_loeschen_ausfuehren("dannypasswort1", bestaetigen=False)
warte(lambda: not konto.angemeldet() and seite.anmeldung.winfo_ismapped(), schritt_nach_loeschen,
name="Konto löschen")
def schritt_nach_loeschen():
code, antwort = server.api("anmelden", login="danny", passwort="dannypasswort1")
pruefe("Konto auf dem Server gelöscht", antwort.get("fehler") == "anmeldung_falsch", antwort)
pruefe("lokale Akte bleibt erhalten", modell.laden(nordlicht["id"])["personalien"]["callsign"] == "Nordlicht")
pruefe("Abgleichstand der Akte entfernt", not (modell.ordner_von(nordlicht["id"]) / "server.json").exists())
squad_nachher = server.api("squad_ansehen", token=kamerad, squad_id=squad["id"])[1]["squad"]
pruefe("Nordlicht aus dem Squad verschwunden",
[m["callsign"] for m in squad_nachher["mitglieder"]] == ["Rook", "Hawk"]
or sorted(m["callsign"] for m in squad_nachher["mitglieder"]) == ["Hawk", "Rook"], squad_nachher)
ende()
def ende():
pruefe("keine Fehler in Tk-Rückrufen", not fehler, [str(f[1]) for f in fehler][:3])
app.stop()
root.destroy()
root.after(1500, schritt_anmeldung)
root.mainloop()
log = server.daten / "fehler.log"
inhalt = log.read_text(encoding="utf-8") if log.exists() else ""
pruefe("fehler.log des Servers leer", not inhalt.strip(), inhalt[-500:])
server.beenden()
print(f"\nERGEBNIS: {st.ergebnisse['ok']} bestanden, {st.ergebnisse['fehl']} fehlgeschlagen")

571
werkzeuge/server_test.py Normal file
View file

@ -0,0 +1,571 @@
"""
Gesamttest des Servers (server/) auf dem eigenen Rechner.
Kopiert server/ in einen temporaeren Ordner mit derselben Aufteilung wie auf
Plesk (sva.tyrveil.com neben sva-privat), schreibt eine Test-config.php mit
SQLite und Mails als Dateien, startet den PHP-Entwicklungsserver und spielt
alle Ablaeufe durch. Beruehrt weder den echten Server noch die echte
Datenbank.
Aufruf: .venv\\Scripts\\python.exe werkzeuge\\server_test.py
Braucht: php (8.1+) mit pdo_sqlite, gd, mbstring im Suchpfad.
"""
import base64
import http.cookiejar
import http.server
import io
import json
import os
import quopri
import re
import shutil
import socket
import subprocess
import sys
import tempfile
import threading
import time
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path
from PIL import Image
WURZEL = Path(__file__).resolve().parent.parent
SCHLUESSEL = "test-einrichtung-0123456789abcdef"
ergebnisse = {"ok": 0, "fehl": 0}
def pruefe(name, bedingung, info=""):
if bedingung:
ergebnisse["ok"] += 1
print(f" OK {name}")
else:
ergebnisse["fehl"] += 1
print(f" FEHL {name}" + (f" [{info}]" if info else ""))
class _CgiServer(http.server.ThreadingHTTPServer):
daemon_threads = True
class _CgiAnfrage(http.server.BaseHTTPRequestHandler):
"""Liefert statische Dateien selbst und reicht .php an php-cgi weiter."""
def log_message(self, format, *args):
with open(self.server.protokoll, "a", encoding="utf-8") as datei:
datei.write(time.strftime("[%H:%M:%S] ") + (format % args) + "\n")
def do_GET(self):
self._behandeln()
def do_POST(self):
self._behandeln()
def _antwort(self, status, kopf, inhalt):
self.send_response(status)
for name, wert in kopf:
self.send_header(name, wert)
self.send_header("Content-Length", str(len(inhalt)))
self.send_header("Connection", "close")
self.end_headers()
self.wfile.write(inhalt)
def _behandeln(self):
wurzel = self.server.dokumentenstamm
pfad, _, abfrage = self.path.partition("?")
ziel = (wurzel / urllib.parse.unquote(pfad).lstrip("/")).resolve()
if wurzel not in ziel.parents and ziel != wurzel:
return self._antwort(403, [], b"")
if ziel.is_dir():
ziel = ziel / "index.php"
if not ziel.is_file():
return self._antwort(404, [("Content-Type", "text/plain")], b"File not found.")
laenge = int(self.headers.get("Content-Length") or 0)
koerper = self.rfile.read(laenge) if laenge else b""
if ziel.suffix != ".php":
art = {".png": "image/png", ".html": "text/html", ".json": "application/json"}.get(ziel.suffix, "application/octet-stream")
return self._antwort(200, [("Content-Type", art)], ziel.read_bytes())
umgebung = {k: v for k, v in os.environ.items() if k.upper() in ("SYSTEMROOT", "PATH", "TEMP", "TMP", "WINDIR")}
umgebung.update({
"REDIRECT_STATUS": "200", "GATEWAY_INTERFACE": "CGI/1.1", "SERVER_PROTOCOL": "HTTP/1.1",
"SCRIPT_FILENAME": str(ziel), "SCRIPT_NAME": "/" + ziel.relative_to(wurzel).as_posix(),
"REQUEST_METHOD": self.command, "QUERY_STRING": abfrage, "REQUEST_URI": self.path,
"CONTENT_LENGTH": str(laenge), "CONTENT_TYPE": self.headers.get("Content-Type", ""),
"SERVER_NAME": "127.0.0.1", "SERVER_PORT": str(self.server.server_port),
"REMOTE_ADDR": self.client_address[0], "DOCUMENT_ROOT": str(wurzel),
})
for name, wert in self.headers.items():
if name.lower() not in ("content-length", "content-type"):
umgebung["HTTP_" + name.upper().replace("-", "_")] = wert
lauf = subprocess.run([self.server.php_cgi], input=koerper, capture_output=True, env=umgebung, timeout=60)
if lauf.stderr:
self.log_message("php-cgi: %s", lauf.stderr.decode("utf-8", "replace")[:500])
kopftext, _, inhalt = lauf.stdout.partition(b"\r\n\r\n")
status, kopf = 200, []
for zeile in kopftext.decode("latin-1").split("\r\n"):
name, _, wert = zeile.partition(":")
if name.lower() == "status":
status = int(wert.strip().split()[0])
elif name:
kopf.append((name, wert.strip()))
if status == 200 and any(n.lower() == "location" for n, _ in kopf):
status = 302
self._antwort(status, kopf, inhalt)
def freier_port():
with socket.socket() as s:
s.bind(("127.0.0.1", 0))
return s.getsockname()[1]
class Server:
def __init__(self):
self.ordner = Path(tempfile.mkdtemp(prefix="sm_servertest_"))
shutil.copytree(WURZEL / "server", self.ordner, dirs_exist_ok=True)
(self.ordner / "sva-privat" / "config.php").unlink(missing_ok=True)
shutil.rmtree(self.ordner / "sva-privat" / "daten", ignore_errors=True)
shutil.copy2(WURZEL / "icon.png", self.ordner / "sva.tyrveil.com" / "icon.png")
self.port = freier_port()
self.basis = f"http://127.0.0.1:{self.port}"
privat = self.ordner / "sva-privat"
dsn = "sqlite:" + (privat / "test.sqlite").as_posix()
(privat / "config.php").write_text(f"""<?php
return [
'datenbank' => ['dsn' => '{dsn}', 'benutzer' => '', 'passwort' => ''],
'basis_url' => '{self.basis}',
'rechtliches_url' => 'https://tyrveil.com/rechtliches#impressum',
'admin_email' => 'info@tyrveil.com',
'mail' => ['art' => 'datei', 'absender' => 'info@tyrveil.com', 'absender_name' => 'Squad Manager'],
'einrichtungs_schluessel' => '{SCHLUESSEL}',
'daten_ordner' => __DIR__ . '/daten',
'fehler_anzeigen' => false,
];
""", encoding="utf-8")
# Nicht "php -S": Der Entwicklungsserver nimmt unter Windows nach
# einigen hundert schnellen Verbindungen keine mehr an. Stattdessen
# startet ein Python-Server fuer jede Anfrage ein eigenes php-cgi -
# naeher an Plesk, wo PHP ebenfalls in eigenen Prozessen laeuft.
self.protokoll = self.ordner / "php-server.log"
self.webserver = _CgiServer(("127.0.0.1", self.port), _CgiAnfrage)
self.webserver.dokumentenstamm = (self.ordner / "sva.tyrveil.com").resolve()
self.webserver.protokoll = self.protokoll
self.webserver.php_cgi = str(Path(shutil.which("php")).with_name("php-cgi.exe"))
threading.Thread(target=self.webserver.serve_forever, daemon=True).start()
def laeuft(self):
return self.webserver is not None
def php_protokoll(self, zeilen=15):
text = self.protokoll.read_text(encoding="utf-8", errors="replace") if self.protokoll.exists() else ""
return "\n".join(text.splitlines()[-zeilen:])
def beenden(self):
self.webserver.shutdown()
self.webserver.server_close()
self.webserver = None
shutil.rmtree(self.ordner, ignore_errors=True)
@property
def daten(self):
return self.ordner / "sva-privat" / "daten"
def letzte_mail(self, an):
mails = sorted((self.daten / "mails").glob("*.eml"), key=lambda p: p.stat().st_mtime_ns)
for pfad in reversed(mails):
roh = pfad.read_bytes()
kopf, _, inhalt = roh.partition(b"\r\n\r\n")
if f"To: {an}".encode() in kopf:
return quopri.decodestring(inhalt).decode("utf-8")
return ""
def link_aus_mail(self, an):
treffer = re.search(r"http://127\.0\.0\.1:\d+/\S+", self.letzte_mail(an))
return treffer.group(0) if treffer else ""
# -- HTTP ---------------------------------------------------------------
def api(self, aktion, token=None, **felder):
anfrage = urllib.request.Request(
self.basis + "/api/", data=json.dumps({"aktion": aktion, **felder}).encode(),
headers={"Content-Type": "application/json", **({"X-SM-Token": token} if token else {})},
method="POST")
try:
with urllib.request.urlopen(anfrage, timeout=30) as antwort:
return antwort.status, json.loads(antwort.read())
except urllib.error.HTTPError as fehler:
text = fehler.read()
try:
return fehler.code, json.loads(text)
except ValueError:
return fehler.code, {"roh": text[:300]}
def roh(self, pfad, daten=None, token=None, oeffner=None, methode=None):
kodiert = urllib.parse.urlencode(daten).encode() if daten is not None else None
anfrage = urllib.request.Request(self.basis + pfad, data=kodiert, method=methode,
headers={"X-SM-Token": token} if token else {})
try:
with (oeffner or urllib.request.build_opener()).open(anfrage, timeout=30) as antwort:
return antwort.status, antwort.read(), dict(antwort.headers)
except urllib.error.HTTPError as fehler:
return fehler.code, fehler.read(), dict(fehler.headers)
def akte(lokale_id, callsign, nachname, rang="", status="aktiv"):
return {"schema": 1, "id": lokale_id, "aktennummer": "SM-2026-0001",
"personalien": {"vorname": "Test", "nachname": nachname, "callsign": callsign},
"dienst": {"fraktion": "Bundeswehr", "teilstreitkraft": "Heer", "rang": rang,
"verwendung": "Medic", "status": status},
"beschreibung": "", "auszeichnungen": [], "einsaetze": [], "vermerke": ""}
def png_base64(breite=900, hoehe=1200):
puffer = io.BytesIO()
Image.new("RGB", (breite, hoehe), (80, 90, 60)).save(puffer, "JPEG")
return base64.b64encode(puffer.getvalue()).decode()
def main():
s = Server()
try:
ablauf(s)
finally:
log = s.daten / "fehler.log"
inhalt = log.read_text(encoding="utf-8") if log.exists() else ""
pruefe("fehler.log des Servers leer", not inhalt.strip(), inhalt[-600:])
s.beenden()
print(f"\nERGEBNIS: {ergebnisse['ok']} bestanden, {ergebnisse['fehl']} fehlgeschlagen")
sys.exit(1 if ergebnisse["fehl"] else 0)
def ablauf(s):
print("Einrichtung")
code, html, kopf = s.roh("/einrichten.php")
pruefe("Formular erreichbar", code == 200 and b"Einrichtungsschl" in html, code)
pruefe("Sicherheitskopf Referrer-Policy", kopf.get("Referrer-Policy") == "no-referrer", kopf)
code, html, _ = s.roh("/einrichten.php", {"schluessel": "falsch"})
pruefe("falscher Schlüssel abgewiesen", "stimmt nicht" in html.decode())
code, html, _ = s.roh("/einrichten.php", {"schluessel": SCHLUESSEL})
text = html.decode()
pruefe("Tabellen angelegt", "7 Tabellen vorhanden" in text, text[-500:])
admin_link = s.link_aus_mail("info@tyrveil.com")
pruefe("Passwort-Mail an info@tyrveil.com", "/konto/passwort.php?t=" in admin_link, admin_link)
code, html, _ = s.roh("/einrichten.php", {"schluessel": SCHLUESSEL})
pruefe("zweiter Aufruf schadet nicht", "vorhanden" in html.decode())
erster_link, admin_link = admin_link, s.link_aus_mail("info@tyrveil.com")
pruefe("zweiter Aufruf schickt neuen Link", admin_link and admin_link != erster_link)
code, html, _ = s.roh(urllib.parse.urlparse(erster_link).path + "?" + urllib.parse.urlparse(erster_link).query)
pruefe("erster Link damit ungültig", "ungültig" in html.decode())
import sqlite3
datenbank = sqlite3.connect(s.ordner / "sva-privat" / "test.sqlite")
datenbank.execute("UPDATE sm_meta SET wert = '1' WHERE schluessel = 'schema'")
datenbank.commit()
(s.daten / "schema-2.ok").unlink()
s.api("status")
stand = datenbank.execute("SELECT wert FROM sm_meta WHERE schluessel = 'schema'").fetchone()[0]
pruefe("Datenbank-Update läuft bei der ersten Anfrage", stand == "2" and (s.daten / "schema-2.ok").exists(), stand)
datenbank.close()
print("Schnittstelle allgemein")
code, antwort = s.api("status")
pruefe("status", code == 200 and antwort.get("api") == 1, antwort)
code, _, _ = s.roh("/api/", methode="GET")
pruefe("GET wird abgewiesen (405)", code == 405, code)
code, antwort = s.api("charaktere_alle")
pruefe("ohne Token: nicht_angemeldet (401)", code == 401 and antwort["fehler"] == "nicht_angemeldet", antwort)
code, antwort = s.api("gibtsnicht", token="0" * 64)
pruefe("falsches Token: 401", code == 401, antwort)
print("Registrierung")
for name, email, pw, erwartet in (
("al", "al@example.org", "langespasswort1", "benutzername_ungueltig"),
("alice", "keine-mail", "langespasswort1", "email_ungueltig"),
("alice", "alice@example.org", "kurz", "passwort_zu_schwach")):
code, antwort = s.api("registrieren", benutzername=name, email=email, passwort=pw)
pruefe(f"abgewiesen: {erwartet}", antwort.get("fehler") == erwartet, antwort)
code, antwort = s.api("registrieren", benutzername="Alice", email="Alice@Example.org", passwort="alicepasswort1")
pruefe("Alice registriert", code == 200 and antwort["ok"], antwort)
code, antwort = s.api("registrieren", benutzername="bob", email="bob@example.org", passwort="bobpasswort12")
pruefe("Bob registriert", code == 200 and antwort["ok"], antwort)
code, antwort = s.api("registrieren", benutzername="ALICE", email="neu@example.org", passwort="alicepasswort1")
pruefe("Benutzername doppelt (Groß/klein egal)", antwort.get("fehler") == "benutzername_vergeben", antwort)
code, antwort = s.api("anmelden", login="alice", passwort="alicepasswort1")
pruefe("vor Bestätigung: nicht_bestaetigt", antwort.get("fehler") == "nicht_bestaetigt", antwort)
for wer in ("alice@example.org", "bob@example.org"):
link = s.link_aus_mail(wer)
code, html, _ = s.roh(urllib.parse.urlparse(link).path + "?" + urllib.parse.urlparse(link).query)
pruefe(f"Bestätigungslink {wer.split('@')[0]}", code == 200 and "bestätigt" in html.decode(), link)
code, html, _ = s.roh(urllib.parse.urlparse(link).path + "?" + urllib.parse.urlparse(link).query)
pruefe("Link nur einmal gültig", "ungültig" in html.decode())
print("Anmeldung")
code, antwort = s.api("anmelden", login="alice", passwort="falsch-falsch")
pruefe("falsches Passwort", antwort.get("fehler") == "anmeldung_falsch", antwort)
code, antwort = s.api("anmelden", login="ALICE@example.org", passwort="alicepasswort1", geraet="Test-PC")
alice = antwort.get("token")
pruefe("Alice per E-Mail angemeldet", code == 200 and alice and antwort["nutzer"]["benutzername"] == "Alice", antwort)
code, antwort = s.api("anmelden", login="bob", passwort="bobpasswort12")
bob = antwort.get("token")
pruefe("Bob angemeldet", bool(bob), antwort)
code, antwort = s.api("ich", token=alice)
pruefe("ich", antwort.get("nutzer", {}).get("email") == "alice@example.org", antwort)
print("Charaktere")
ids = {n: f"{i:032x}" for i, n in enumerate(("nordlicht", "rook", "frost"), start=11)}
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"],
daten=akte(ids["nordlicht"], "Nordlicht", "Brandt", "Oberfeldwebel"))
nordlicht = antwort.get("charakter", {})
pruefe("Akte gespeichert, Server vergibt Nummer",
code == 200 and re.fullmatch(r"SM-\d{4}-\d{4}", nordlicht.get("aktennummer") or "")
and nordlicht["daten"]["aktennummer"] == nordlicht["aktennummer"], antwort)
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["frost"],
daten=akte(ids["frost"], "Frost", "Sigurdsson"))
frost = antwort.get("charakter", {})
code, antwort = s.api("charakter_speichern", token=bob, lokale_id=ids["rook"],
daten=akte(ids["rook"], "Rook", "Hutchins", status="gefallen"))
rook = antwort.get("charakter", {})
nummern = {nordlicht.get("aktennummer"), frost.get("aktennummer"), rook.get("aktennummer")}
pruefe("Aktennummern eindeutig", len(nummern) == 3 and None not in nummern, nummern)
geaendert = akte(ids["nordlicht"], "Nordlicht", "Brandt", "Hauptfeldwebel")
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"], daten=geaendert,
basis_version=1)
pruefe("Änderung mit passender Version", antwort.get("charakter", {}).get("version") == 2, antwort)
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"], daten=geaendert,
basis_version=1)
pruefe("veraltete Version: konflikt (409) mit Serverstand",
code == 409 and antwort.get("charakter", {}).get("version") == 2, antwort)
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"], daten=geaendert,
basis_version=1, erzwingen=True)
pruefe("erzwingen überschreibt", antwort.get("charakter", {}).get("version") == 3, antwort)
code, antwort = s.api("charakter_speichern", token=alice, lokale_id="kaputt", daten={})
pruefe("ungültige Akten-ID", antwort.get("fehler") == "lokale_id_ungueltig", antwort)
code, antwort = s.api("portraet_hochladen", token=alice, lokale_id=ids["nordlicht"], bild=png_base64())
pruefe("Porträt hochgeladen", antwort.get("charakter", {}).get("portraet") is True, antwort)
code, bild, kopf = s.roh(f"/api/bild.php?id={nordlicht['id']}", token=bob)
groesse = Image.open(io.BytesIO(bild)).size if code == 200 else None
pruefe("Porträt für andere abrufbar, neu als PNG ≤ 512",
code == 200 and kopf.get("Content-Type") == "image/png" and max(groesse) == 512, (code, groesse))
code, _, _ = s.roh(f"/api/bild.php?id={nordlicht['id']}")
pruefe("Porträt ohne Token: 401", code == 401, code)
code, antwort = s.api("portraet_hochladen", token=alice, lokale_id=ids["nordlicht"],
bild=base64.b64encode(b"<?php echo 1; ?>").decode())
pruefe("keine Bilddatei: abgewiesen", antwort.get("fehler") == "bild_ungueltig", antwort)
code, antwort = s.api("portraet_hochladen", token=bob, lokale_id=ids["nordlicht"], bild=png_base64(10, 10))
pruefe("fremde Akte: nicht gefunden", antwort.get("fehler") == "charakter_nicht_gefunden", antwort)
code, antwort = s.api("charaktere_alle", token=bob)
liste = antwort.get("charaktere", [])
pruefe("Bob sieht alle 3 Charaktere mit Status",
len(liste) == 3 and {c["callsign"]: c["status"] for c in liste}.get("Rook") == "gefallen", liste)
pruefe("'eigener' richtig gesetzt", [c["callsign"] for c in liste if c["eigener"]] == ["Rook"], liste)
code, antwort = s.api("charaktere_alle", token=bob, suche="nord")
pruefe("Suche", [c["callsign"] for c in antwort.get("charaktere", [])] == ["Nordlicht"], antwort)
code, antwort = s.api("charaktere_alle", token=bob, suche="100%_")
pruefe("Suche mit Sonderzeichen", code == 200 and antwort.get("charaktere") == [], antwort)
code, antwort = s.api("charakter_ansehen", token=bob, id=nordlicht["id"])
pruefe("fremde Akte ansehen", antwort.get("charakter", {}).get("daten", {}).get("dienst", {}).get("rang")
== "Hauptfeldwebel", antwort)
print("Squads")
code, antwort = s.api("squad_gruenden", token=alice, charakter_id=nordlicht["id"], name=" Nordwind ")
squad = antwort.get("squad", {})
pruefe("Squad gegründet", squad.get("name") == "Nordwind" and squad.get("fuehrer_id") == nordlicht["id"], antwort)
code, antwort = s.api("squad_gruenden", token=bob, charakter_id=rook["id"], name="nordwind")
pruefe("Name doppelt", antwort.get("fehler") == "name_vergeben", antwort)
code, antwort = s.api("squad_gruenden", token=bob, charakter_id=nordlicht["id"], name="Fremd")
pruefe("fremder Charakter kann nicht gründen", antwort.get("fehler") == "charakter_nicht_gefunden", antwort)
code, antwort = s.api("squad_einladen", token=bob, squad_id=squad["id"], charakter_id=rook["id"])
pruefe("Nicht-Führer kann nicht einladen", antwort.get("fehler") == "kein_fuehrer", antwort)
code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=rook["id"])
einladung = antwort.get("einladung", {})
pruefe("Alice lädt Rook ein", einladung.get("status") == "offen", antwort)
code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=rook["id"])
pruefe("doppelte Einladung", antwort.get("fehler") == "schon_eingeladen", antwort)
code, antwort = s.api("einladungen", token=bob)
pruefe("Bob sieht Einladung im Eingang", [e["squad"]["name"] for e in antwort.get("eingang", [])] == ["Nordwind"], antwort)
code, antwort = s.api("einladungen", token=alice)
pruefe("Alice sieht sie im Ausgang", len(antwort.get("ausgang", [])) == 1, antwort)
code, antwort = s.api("einladung_beantworten", token=alice, einladung_id=einladung["id"], annehmen=True)
pruefe("Alice kann Bobs Einladung nicht annehmen", antwort.get("fehler") == "charakter_nicht_gefunden", antwort)
code, antwort = s.api("einladung_beantworten", token=bob, einladung_id=einladung["id"], annehmen=True)
pruefe("Bob nimmt an", code == 200 and antwort["ok"], antwort)
code, antwort = s.api("einladung_beantworten", token=bob, einladung_id=einladung["id"], annehmen=True)
pruefe("zweimal annehmen geht nicht", antwort.get("fehler") == "einladung_nicht_offen", antwort)
code, antwort = s.api("squad_gruenden", token=bob, charakter_id=rook["id"], name="Zweites")
pruefe("im Squad kein zweites gründen", antwort.get("fehler") == "bereits_im_squad", antwort)
code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=frost["id"])
frost_einladung = antwort.get("einladung", {})
code, antwort = s.api("einladung_zurueckziehen", token=alice, einladung_id=frost_einladung.get("id"))
pruefe("Einladung zurückgezogen", code == 200, antwort)
code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=frost["id"])
code, antwort = s.api("einladung_beantworten", token=alice, einladung_id=antwort["einladung"]["id"], annehmen=False)
pruefe("Einladung abgelehnt", code == 200, antwort)
code, antwort = s.api("squad_ansehen", token=bob, squad_id=squad["id"])
pruefe("Squad hat 2 Mitglieder", [m["callsign"] for m in antwort.get("squad", {}).get("mitglieder", [])]
== ["Nordlicht", "Rook"], antwort)
code, antwort = s.api("squad_verlassen", token=alice, charakter_id=nordlicht["id"])
pruefe("Führer mit Mitgliedern muss übergeben", antwort.get("fehler") == "fuehrer_muss_uebergeben", antwort)
code, antwort = s.api("squad_fuehrung_uebergeben", token=alice, squad_id=squad["id"], charakter_id=rook["id"])
pruefe("Führung an Rook übergeben", code == 200, antwort)
code, antwort = s.api("squad_entfernen", token=alice, squad_id=squad["id"], charakter_id=rook["id"])
pruefe("Ex-Führer kann nicht mehr entfernen", antwort.get("fehler") == "kein_fuehrer", antwort)
code, antwort = s.api("squad_verlassen", token=alice, charakter_id=nordlicht["id"])
pruefe("Nordlicht verlässt das Squad", code == 200, antwort)
code, antwort = s.api("squad_einladen", token=bob, squad_id=squad["id"], charakter_id=nordlicht["id"])
s.api("einladung_beantworten", token=alice, einladung_id=antwort["einladung"]["id"], annehmen=True)
code, antwort = s.api("charakter_loeschen", token=bob, lokale_id=ids["rook"])
pruefe("Führer gelöscht", code == 200, antwort)
code, antwort = s.api("squad_ansehen", token=alice, squad_id=squad["id"])
pruefe("dienstältestes Mitglied übernimmt", antwort.get("squad", {}).get("fuehrer_id") == nordlicht["id"], antwort)
code, antwort = s.api("squad_verlassen", token=alice, charakter_id=nordlicht["id"])
code, antwort = s.api("squads", token=alice)
pruefe("letztes Mitglied geht: Squad aufgelöst", antwort.get("squads") == [], antwort)
print("Passwort vergessen")
code, antwort = s.api("passwort_vergessen", email="gibtsnicht@example.org")
pruefe("unbekannte Adresse: gleiche Antwort", code == 200 and antwort["ok"], antwort)
code, antwort = s.api("passwort_vergessen", email="alice@example.org")
link = s.link_aus_mail("alice@example.org")
pfad = urllib.parse.urlparse(link).path + "?" + urllib.parse.urlparse(link).query
code, html, _ = s.roh(pfad)
pruefe("Formular per GET, Link noch nicht verbraucht", code == 200 and "Neues Passwort" in html.decode(), link)
token = urllib.parse.parse_qs(urllib.parse.urlparse(link).query)["t"][0]
code, html, _ = s.roh("/konto/passwort.php", {"t": token, "passwort": "neuespasswort1", "wiederholung": "anders"})
pruefe("Wiederholung falsch", "stimmen nicht" in html.decode())
code, html, _ = s.roh("/konto/passwort.php", {"t": token, "passwort": "neuespasswort1", "wiederholung": "neuespasswort1"})
pruefe("neues Passwort gespeichert", "Passwort gespeichert" in html.decode())
code, antwort = s.api("ich", token=alice)
pruefe("alte Sitzung abgemeldet", code == 401, antwort)
code, antwort = s.api("anmelden", login="alice", passwort="neuespasswort1")
alice = antwort.get("token")
pruefe("Anmeldung mit neuem Passwort", bool(alice), antwort)
print("Mitmachen ohne Konto")
code, antwort = s.api("mitmachen", spielername="x")
pruefe("Spielername zu kurz", antwort.get("fehler") == "benutzername_ungueltig", antwort)
code, antwort = s.api("mitmachen", spielername="Kiwi", geraet="PC-Kiwi")
kiwi, kiwi_nutzer = antwort.get("token"), antwort.get("nutzer", {})
pruefe("mitgemacht: Schlüssel ohne E-Mail",
kiwi and kiwi_nutzer.get("gesichert") is False and kiwi_nutzer.get("email") is None, antwort)
code, antwort = s.api("mitmachen", spielername="kiwi")
pruefe("Spielername doppelt (Groß/klein egal)", antwort.get("fehler") == "benutzername_vergeben", antwort)
code, antwort = s.api("mitmachen", spielername="Alice")
pruefe("Name eines E-Mail-Kontos ist auch vergeben", antwort.get("fehler") == "benutzername_vergeben", antwort)
kiwi_akte = "f" * 32
code, antwort = s.api("charakter_speichern", token=kiwi, lokale_id=kiwi_akte,
daten=akte(kiwi_akte, "Kiwi-1", "Tane"))
pruefe("mit Schlüssel Akte speichern", code == 200, antwort)
code, antwort = s.api("charaktere_alle", token=alice)
pruefe("andere sehen den Charakter mit Spielernamen",
any(c["callsign"] == "Kiwi-1" and c["spieler"] == "Kiwi" for c in antwort.get("charaktere", [])), antwort)
code, antwort = s.api("anmelden", login="Kiwi", passwort="irgendwas123")
pruefe("ohne gesichertes Konto keine Passwort-Anmeldung", antwort.get("fehler") == "anmeldung_falsch", antwort)
code, antwort = s.api("konto_sichern", token=kiwi, email="alice@example.org", passwort="kiwipasswort1")
pruefe("Sichern mit vergebener E-Mail abgewiesen", antwort.get("fehler") == "email_vergeben", antwort)
code, antwort = s.api("konto_sichern", token=kiwi, email="Kiwi@Example.org", passwort="kiwipasswort1")
pruefe("Konto gesichert, noch unbestätigt",
antwort.get("nutzer", {}).get("gesichert") is True and antwort["nutzer"]["bestaetigt"] is False, antwort)
code, antwort = s.api("konto_sichern", token=kiwi, email="kiwi2@example.org", passwort="kiwipasswort1")
pruefe("zweimal sichern geht nicht", antwort.get("fehler") == "schon_gesichert", antwort)
code, antwort = s.api("ich", token=kiwi)
pruefe("Schlüssel gilt nach dem Sichern weiter", code == 200, antwort)
teile = urllib.parse.urlparse(s.link_aus_mail("kiwi@example.org"))
s.roh(teile.path + "?" + teile.query)
code, antwort = s.api("anmelden", login="kiwi@example.org", passwort="kiwipasswort1")
zweiter_pc = antwort.get("token")
pruefe("zweiter PC: Anmeldung mit E-Mail, gleiches Konto",
zweiter_pc and antwort["nutzer"]["id"] == kiwi_nutzer.get("id"), antwort)
code, antwort = s.api("charaktere_eigene", token=zweiter_pc)
pruefe("zweiter PC sieht die Akte", [c["lokale_id"] for c in antwort.get("charaktere", [])] == [kiwi_akte], antwort)
code, antwort = s.api("mitmachen", spielername="Einweg")
einweg = antwort.get("token")
code, antwort = s.api("konto_loeschen", token=einweg, passwort="")
pruefe("Konto nur mit Schlüssel ohne Passwort löschbar", code == 200, antwort)
code, antwort = s.api("ich", token=einweg)
pruefe("Schlüssel danach ungültig", code == 401, antwort)
code, antwort = s.api("mitmachen", spielername="Stumm")
pruefe("weiteres Mitmachen", bool(antwort.get("token")), antwort)
print("Verwaltung")
jar = http.cookiejar.CookieJar()
oeffner = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar))
def csrf(html):
treffer = re.search(rb'name="csrf" value="([0-9a-f]+)"', html)
return treffer.group(1).decode() if treffer else ""
admin_token = urllib.parse.parse_qs(urllib.parse.urlparse(admin_link).query)["t"][0]
code, html, _ = s.roh("/konto/passwort.php", {"t": admin_token, "passwort": "adminpasswort99",
"wiederholung": "adminpasswort99"})
pruefe("Admin-Passwort über Einrichtungslink gesetzt", "Zur Verwaltung" in html.decode())
code, html, _ = s.roh("/verwaltung/", oeffner=oeffner)
pruefe("Verwaltung fordert Anmeldung", "Anmelden" in html.decode())
code, html, _ = s.roh("/verwaltung/", {"aktion": "anmelden", "email": "info@tyrveil.com", "passwort": "falsch",
"csrf": csrf(html)}, oeffner=oeffner)
pruefe("falsches Admin-Passwort", "stimmt nicht" in html.decode())
code, html, _ = s.roh("/verwaltung/", {"aktion": "anmelden", "email": "alice@example.org",
"passwort": "neuespasswort1", "csrf": csrf(html)}, oeffner=oeffner)
pruefe("normaler Nutzer kommt nicht in die Verwaltung", "stimmt nicht" in html.decode())
code, html, _ = s.roh("/verwaltung/", {"aktion": "anmelden", "email": "info@tyrveil.com",
"passwort": "adminpasswort99", "csrf": csrf(html)}, oeffner=oeffner)
pruefe("Admin angemeldet, Übersicht", code == 200 and "Offene Einladungen" in html.decode(), html[-300:])
for seite, erwartet in (("nutzer", "nur Schlüssel"), ("charaktere", "Nordlicht"), ("squads", "Squads"),
(f"charakter&id={nordlicht['id']}", "ROHDATEN")):
code, html, _ = s.roh(f"/verwaltung/?seite={seite}", oeffner=oeffner)
pruefe(f"Seite {seite.split('&')[0]}", code == 200 and erwartet in html.decode(), code)
code, bild, kopf = s.roh(f"/verwaltung/?seite=bild&id={nordlicht['id']}", oeffner=oeffner)
pruefe("Porträt in der Verwaltung", code == 200 and kopf.get("Content-Type") == "image/png", code)
code, html, _ = s.roh("/verwaltung/?seite=nutzer", oeffner=oeffner)
bob_id = s_nutzer_id(html, "bob@example.org")
code, html, _ = s.roh("/verwaltung/?seite=nutzer", {"aktion": "nutzer_sperren", "id": bob_id}, oeffner=oeffner)
pruefe("ohne CSRF-Token abgewiesen", "abgelaufen" in html.decode())
code, html, _ = s.roh("/verwaltung/?seite=nutzer", oeffner=oeffner)
code, html, _ = s.roh("/verwaltung/?seite=nutzer", {"aktion": "nutzer_sperren", "id": bob_id, "csrf": csrf(html)},
oeffner=oeffner)
pruefe("Bob gesperrt", "gesperrt und abgemeldet" in html.decode())
code, antwort = s.api("ich", token=bob)
pruefe("Bobs Sitzung ungültig", code == 401, antwort)
code, antwort = s.api("anmelden", login="bob", passwort="bobpasswort12")
pruefe("Bob kann sich nicht anmelden", antwort.get("fehler") == "gesperrt", antwort)
code, html, _ = s.roh(f"/verwaltung/?seite=bestaetigen&aktion=nutzer_loeschen&id={bob_id}", oeffner=oeffner)
pruefe("Löschen zeigt Bestätigungsseite", "Ja, ausführen" in html.decode() and "bob" in html.decode())
code, html, _ = s.roh("/verwaltung/?seite=nutzer", {"aktion": "nutzer_loeschen", "id": bob_id, "csrf": csrf(html)},
oeffner=oeffner)
pruefe("Bob gelöscht", "gelöscht" in html.decode() and "bob@example.org" not in html.decode())
print("Konto und Bremse")
code, antwort = s.api("konto_loeschen", token=alice, passwort="falsch")
pruefe("Konto löschen braucht Passwort", antwort.get("fehler") == "anmeldung_falsch", antwort)
code, antwort = s.api("konto_loeschen", token=alice, passwort="neuespasswort1")
pruefe("Alice löscht ihr Konto", code == 200, antwort)
portraets = list((s.daten / "portraets").glob("*.png"))
pruefe("Porträtdateien mitgelöscht", portraets == [], portraets)
antworten = [s.api("anmelden", login="niemand", passwort="falsch-falsch")[1].get("fehler") for _ in range(11)]
pruefe("nach 10 Fehlversuchen: zu_viele_versuche", antworten[-1] == "zu_viele_versuche", antworten)
def s_nutzer_id(html, email):
zeilen = html.decode().split("<tr>")
for zeile in zeilen:
if email in zeile:
treffer = re.search(r'name="id" value="(\d+)"', zeile)
if treffer:
return treffer.group(1)
return "0"
if __name__ == "__main__":
main()