Compare commits
15 commits
ae30f47ba5
...
a5da53d373
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
a5da53d373 | ||
|
|
c175e42546 | ||
|
|
4d9e30bc90 | ||
|
|
0c7aae5b93 | ||
|
|
fb318980a1 | ||
|
|
6e4d4afc1d | ||
|
|
58a3573fd6 | ||
|
|
9b6cbc7e4e | ||
|
|
cc1f1dba25 | ||
|
|
f89396e1b9 | ||
|
|
6ca9c48868 | ||
|
|
a200987237 | ||
|
|
dac2e85f6a | ||
|
|
8c0d364a8a | ||
|
|
f49e9a3ed0 |
45 changed files with 8460 additions and 262 deletions
12
.claude/launch.json
Normal file
12
.claude/launch.json
Normal 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
3
.gitattributes
vendored
|
|
@ -11,3 +11,6 @@
|
|||
|
||||
*.png binary
|
||||
*.ico binary
|
||||
|
||||
# Server-Dateien laufen unter Linux
|
||||
*.php text eol=lf
|
||||
|
|
|
|||
4
.gitignore
vendored
4
.gitignore
vendored
|
|
@ -9,3 +9,7 @@ __pycache__/
|
|||
# Editor
|
||||
.idea/
|
||||
.vscode/
|
||||
|
||||
# Server: Zugangsdaten und Nutzerdaten nie ins Repository
|
||||
server/sva-privat/config.php
|
||||
server/sva-privat/daten/
|
||||
|
|
|
|||
35
PLAN-AKTE.md
35
PLAN-AKTE.md
|
|
@ -1,6 +1,6 @@
|
|||
# Plan: Modul „Akte"
|
||||
|
||||
Stand: 10. September 2026 · Entwurf, noch nicht umgesetzt
|
||||
Stand: 11. September 2026 · Stufe 0 bis 3 umgesetzt · Stufe 2 online als 4.0, Stufe 3 folgt als 1.5.0 (neue Zählung, siehe Übergabe, Erkenntnis 20)
|
||||
|
||||
Eine Personalakte für den eigenen Squad-Charakter: Name, Callsign, Rang,
|
||||
Porträt, Nation, Teilstreitkraft, Einheit, Werdegang. Reines Rollenspiel —
|
||||
|
|
@ -81,7 +81,10 @@ riskant.
|
|||
```
|
||||
squad_manager.py Hauptfenster, Navigation, Funk-Modul (wie bisher)
|
||||
theme.py Farben, Schriften, apply_tactical_theme(), LevelMeter
|
||||
akte.py Datenmodell, Speicherung, Oberfläche der Akte
|
||||
akte.py Oberfläche der Akte
|
||||
akte_modell.py Datenmodell und Speicherung, ohne tkinter
|
||||
akte_vorlagen.py Fraktionen, Dienstgrade, Verwendungen
|
||||
akte_karte.py Akte als PNG-Karte zum Teilen
|
||||
```
|
||||
|
||||
Flach bleibt es, weil Installer, Update-Paket und `start.pyw` heute flache
|
||||
|
|
@ -147,9 +150,9 @@ Eine Akte ist ein Ordner mit JSON-Datei und Porträt:
|
|||
| Stufe | Inhalt | Umfang |
|
||||
|---|---|---|
|
||||
| **0** | Fehlende Pakete werden beim Start nachinstalliert — **erledigt in 3.3** | klein |
|
||||
| **1** | `theme.py` auslagern, Hauptreiter *Funk* / *Akte*, Akte noch leer — Version 3.4 | mittel |
|
||||
| **2** | Akte vollständig: Liste, Formular, Dokumentansicht, Porträt, Vorbelegungen — Version 4.0 | groß |
|
||||
| **3** | Teilen: Akte als PNG-Karte für Discord, Export/Import als `.akte`-Datei | mittel |
|
||||
| **1** | `theme.py` auslagern, Hauptreiter *Funk* / *Akte*, Akte noch leer — **erledigt in 3.4** | mittel |
|
||||
| **2** | Akte vollständig: Liste, Formular, Dokumentansicht, Porträt, Vorbelegungen — **umgesetzt**, online als 4.0 | groß |
|
||||
| **3** | Teilen: Akte als PNG-Karte für Discord — **umgesetzt**, kommt mit 1.5.0 (Export/Import als `.akte`-Datei entfällt, siehe Abschnitt 7) | mittel |
|
||||
|
||||
Jede Stufe endet mit einem Release über den Updater. Stufe 1 ist bewusst
|
||||
ohne neue Funktion: Wenn dabei etwas bricht, liegt es am Umbau und nicht an
|
||||
|
|
@ -181,17 +184,19 @@ erweitern, falls du dafür wieder Claude Design einsetzen willst.
|
|||
|
||||
---
|
||||
|
||||
## 7. Zu entscheiden
|
||||
## 7. Entscheidungen (10. September 2026)
|
||||
|
||||
Mit meiner Empfehlung, damit Stufe 2 ohne Rückfragen durchlaufen kann:
|
||||
|
||||
1. **Mehrere Akten pro Person?** — Ja.
|
||||
2. **Vorbelegungen für welche Nationen zuerst?** — Die Squad-Fraktionen.
|
||||
Wenn eure Gruppe eine bestimmte Armee spielt, etwa die Bundeswehr, die
|
||||
zusätzlich.
|
||||
3. **Teilen mit Freunden wichtig?** — Stufe 3 als PNG-Karte ist der
|
||||
einfachste Weg mit dem meisten Effekt, weil sie direkt in Discord landet.
|
||||
4. **Online-Akten?** — Erst einmal nicht, siehe oben.
|
||||
1. **Mehrere Akten pro Person** — ja.
|
||||
2. **Vorbelegungen für Fraktion und Rang:** alle Squad-Fraktionen, dazu
|
||||
Bundeswehr, Frankreich, Spanien, Italien und Island. Freitext bleibt
|
||||
überall möglich.
|
||||
*Island hat keine Armee*, nur Küstenwache (Landhelgisgæslan) und die
|
||||
Krisenreaktionseinheit. Vorbelegt werden die Dienstgrade der
|
||||
Küstenwache, sofern die Gruppe kein fiktives Island spielt.
|
||||
3. **Teilen:** PNG-Karte für Discord (Stufe 3). Keine Import-Datei.
|
||||
4. **Gestaltung:** im bestehenden Stil, ohne vorherigen Entwurf in Claude
|
||||
Design.
|
||||
5. **Online-Akten:** vorerst nicht.
|
||||
|
||||
---
|
||||
|
||||
|
|
|
|||
|
|
@ -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*
|
||||
|
|
|
|||
15
README.md
15
README.md
|
|
@ -11,11 +11,22 @@ Technische Dokumentation und alle bekannten Fallstricke:
|
|||
|
||||
| Pfad | Zweck |
|
||||
|---|---|
|
||||
| `squad_manager.py` | Hauptprogramm |
|
||||
| `squad_manager.py` | Hauptfenster, Funk-Modul, Updater |
|
||||
| `theme.py` | Farben, Schriften, Stil, Pegelanzeige |
|
||||
| `akte.py` | Modul Akte: Oberfläche |
|
||||
| `akte_modell.py` | Modul Akte: Datenmodell und Speicherung |
|
||||
| `akte_vorlagen.py` | Modul Akte: Fraktionen, Dienstgrade, Verwendungen |
|
||||
| `akte_karte.py` | Modul Akte: PNG-Karte zum Teilen |
|
||||
| `konto.py` | Verbindung zum Server, Anmeldung |
|
||||
| `abgleich.py` | Abgleich der Akten mit dem Server |
|
||||
| `hintergrund.py` | Netzwerkarbeit im Hintergrund-Thread |
|
||||
| `squad.py` | Hauptreiter SQUAD: Charaktere, Squads, Einladungen |
|
||||
| `server/` | PHP-Server für Konten und Squads auf sva.tyrveil.com |
|
||||
| `update_helfer.py` | spielt Updates ein, bei Bedarf mit Adminrechten |
|
||||
| `start.pyw` | Startskript ohne Konsolenfenster |
|
||||
| `make_icon.py` | erzeugt `icon.ico` aus `icon.png` |
|
||||
| `icon.png`, `icon.ico` | Programmsymbol |
|
||||
| `requirements.txt` | numpy, sounddevice |
|
||||
| `requirements.txt` | numpy, sounddevice, Pillow |
|
||||
| `installer/` | Inno-Setup-Skript, Einrichtung nach der Installation, Server-Anleitung |
|
||||
| `werkzeuge/` | Release-Bau und Testhilfen |
|
||||
| `Design-Briefing.md` | Auftrag für die Gestaltung |
|
||||
|
|
|
|||
285
abgleich.py
Normal file
285
abgleich.py
Normal 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
914
akte.py
Normal 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
291
akte_karte.py
Normal 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
241
akte_modell.py
Normal 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
362
akte_vorlagen.py
Normal 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
46
hintergrund.py
Normal 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
|
||||
80
installer/DATENSCHUTZ-BAUSTEIN.md
Normal file
80
installer/DATENSCHUTZ-BAUSTEIN.md
Normal 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].
|
||||
|
|
@ -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"
|
||||
|
||||
|
|
|
|||
200
installer/downloadseite.html
Normal file
200
installer/downloadseite.html
Normal 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>
|
||||
|
|
@ -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
249
konto.py
Normal 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
|
||||
|
|
@ -1,2 +1,3 @@
|
|||
numpy>=1.26
|
||||
sounddevice>=0.4.6
|
||||
Pillow>=10.4
|
||||
|
|
|
|||
174
server/sva-privat/app/api.php
Normal file
174
server/sva-privat/app/api.php
Normal 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);
|
||||
}
|
||||
}
|
||||
325
server/sva-privat/app/charaktere.php
Normal file
325
server/sva-privat/app/charaktere.php
Normal 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()];
|
||||
}
|
||||
}
|
||||
266
server/sva-privat/app/db.php
Normal file
266
server/sva-privat/app/db.php
Normal 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());
|
||||
}
|
||||
}
|
||||
292
server/sva-privat/app/konten.php
Normal file
292
server/sva-privat/app/konten.php
Normal 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]);
|
||||
});
|
||||
}
|
||||
}
|
||||
121
server/sva-privat/app/mail.php
Normal file
121
server/sva-privat/app/mail.php
Normal 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');
|
||||
}
|
||||
}
|
||||
145
server/sva-privat/app/sicherheit.php
Normal file
145
server/sva-privat/app/sicherheit.php
Normal 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()]);
|
||||
}
|
||||
}
|
||||
317
server/sva-privat/app/squads.php
Normal file
317
server/sva-privat/app/squads.php
Normal 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);
|
||||
}
|
||||
}
|
||||
75
server/sva-privat/app/start.php
Normal file
75
server/sva-privat/app/start.php
Normal 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);
|
||||
400
server/sva-privat/app/verwaltung.php
Normal file
400
server/sva-privat/app/verwaltung.php
Normal 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&aktion=' . Web::e($aktion) . '&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&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&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;
|
||||
}
|
||||
}
|
||||
110
server/sva-privat/app/web.php
Normal file
110
server/sva-privat/app/web.php
Normal 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;
|
||||
}
|
||||
}
|
||||
46
server/sva-privat/config.beispiel.php
Normal file
46
server/sva-privat/config.beispiel.php
Normal 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,
|
||||
];
|
||||
24
server/sva.tyrveil.com/api/bild.php
Normal file
24
server/sva.tyrveil.com/api/bild.php
Normal 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);
|
||||
5
server/sva.tyrveil.com/api/index.php
Normal file
5
server/sva.tyrveil.com/api/index.php
Normal 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();
|
||||
90
server/sva.tyrveil.com/einrichten.php
Normal file
90
server/sva.tyrveil.com/einrichten.php
Normal 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')));
|
||||
14
server/sva.tyrveil.com/konto/bestaetigen.php
Normal file
14
server/sva.tyrveil.com/konto/bestaetigen.php
Normal 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>');
|
||||
}
|
||||
41
server/sva.tyrveil.com/konto/passwort.php
Normal file
41
server/sva.tyrveil.com/konto/passwort.php
Normal 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>');
|
||||
17
server/sva.tyrveil.com/konto/vergessen.php
Normal file
17
server/sva.tyrveil.com/konto/vergessen.php
Normal 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>');
|
||||
5
server/sva.tyrveil.com/verwaltung/index.php
Normal file
5
server/sva.tyrveil.com/verwaltung/index.php
Normal 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();
|
||||
293
squad_manager.py
293
squad_manager.py
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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
229
theme.py
Normal 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
209
update_helfer.py
Normal 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
245
werkzeuge/abgleich_test.py
Normal 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()
|
||||
|
|
@ -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}")
|
||||
|
|
|
|||
302
werkzeuge/oberflaeche_test.py
Normal file
302
werkzeuge/oberflaeche_test.py
Normal 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
571
werkzeuge/server_test.py
Normal 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()
|
||||
Loading…
Add table
Add a link
Reference in a new issue