1.7.0: Mitmachen im Squad ohne Konto

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

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

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

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
danny 2026-09-15 06:35:54 +02:00
parent c175e42546
commit a5da53d373
14 changed files with 491 additions and 121 deletions

View file

@ -1,6 +1,6 @@
# Projektübergabe: Squad Manager
Stand: 15. September 2026 · Version 1.6.1 (Build 4) · 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.
@ -183,8 +183,20 @@ Dienst-Abschnitt — nicht still korrigieren. Island hat nur die vier
Bereiche der Küstenwache, die Bundeswehr Heer, Luftwaffe und Marine mit
eigenen Marine-Dienstgraden.
**Squad-Reiter und Abgleich (seit 1.6.0):** Ohne Konto zeigt *SQUAD* die
Anmeldung und Registrierung; alles andere läuft ohne Konto wie vorher.
**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*.

View file

@ -10,23 +10,26 @@ prüfen oder prüfen lassen, und die Stellen in [eckigen Klammern] ergänzen.
## Squad Manager (sva.tyrveil.com)
Der Squad Manager ist ein kostenloses Programm für die Spielgemeinschaft
rund um das Spiel Squad. Wer möchte, kann ein Konto anlegen, Personalakten
seiner Rollenspiel-Charaktere auf dem Server speichern und mit anderen
registrierten Nutzern Squads bilden. Ohne Konto werden keine Daten an uns
übertragen; das Programm prüft dann lediglich beim Start, ob eine neue
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
- **Kontodaten:** Benutzername, E-Mail-Adresse und das Passwort – dieses
nur als nicht umkehrbarer Hash. Dazu Zeitpunkt der Registrierung, der
E-Mail-Bestätigung und der letzten Anmeldung.
- **Anmeldung:** Beim Anmelden erzeugen wir ein zufälliges Sitzungs-Token.
Auf unserem Server liegt davon nur ein Prüfwert, zusammen mit dem
Rechnernamen, den das Programm übermittelt, damit sich Sitzungen
unterscheiden lassen.
- **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.
@ -41,8 +44,8 @@ Version vorliegt.
### Wer die Daten sieht
Charakterdaten, Porträts, Squads und dein **Benutzername** sind für alle
angemeldeten Nutzer des Squad Managers sichtbar – das ist der Zweck der
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.
@ -60,9 +63,11 @@ Dritte findet nicht statt.
### Speicherdauer und Löschung
Deine Daten bleiben gespeichert, solange dein Konto besteht. Du kannst
dein Konto jederzeit im Programm löschen (Reiter SQUAD → Konto → Konto
löschen). Dabei werden das Konto, alle Charaktere, Porträts und
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.

View file

@ -13,7 +13,9 @@ außer dieser Anleitung selbst:
Ä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.
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

View file

@ -2,7 +2,7 @@
; Uebersetzen mit: ISCC.exe setup.iss
#define Name "Squad Manager"
#define Version "1.6.1"
#define Version "1.7.0"
#define Herausgeber "tyrveil.com"
#define Website "https://sva.tyrveil.com"
@ -151,10 +151,11 @@ begin
SquadVoiceActivation bleibt stehen - eine Installation von 3.1 kann ihn
noch benutzen. }
{ Der Ordner enthaelt seit 3.4 auch die Akten - das muss in der Frage stehen }
Auswahl := SuppressibleMsgBox('Sollen auch die Einstellungen und die lokal gespeicherten Akten ' +
'entfernt werden?' + #13#10#13#10 +
'Akten, die mit einem Konto gesichert sind, bleiben auf dem Server ' +
'und kommen nach der naechsten Anmeldung zurueck.',
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);

View file

@ -167,6 +167,25 @@ def nutzer():
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)

View file

@ -11,7 +11,8 @@ declare(strict_types=1);
final class Api
{
private const OHNE_ANMELDUNG = ['status', 'registrieren', 'anmelden', 'bestaetigung_erneut', 'passwort_vergessen'];
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
@ -52,6 +53,7 @@ final class Api
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.');
@ -84,6 +86,12 @@ final class Api
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));

View file

@ -133,7 +133,7 @@ final class DB
id $id,
benutzername VARCHAR(32) NOT NULL,
benutzername_klein VARCHAR(32) NOT NULL,
email VARCHAR(191) NOT NULL,
email VARCHAR(191) NULL,
passwort_hash VARCHAR(255) NULL,
rolle VARCHAR(16) NOT NULL DEFAULT 'nutzer',
email_bestaetigt_am DATETIME NULL,
@ -229,8 +229,38 @@ final class DB
}
}
self::ausfuehren('DELETE FROM sm_meta WHERE schluessel = ?', ['schema']);
self::einfuegen('sm_meta', ['schluessel' => 'schema', 'wert' => '1']);
if (self::wert("SELECT wert FROM sm_meta WHERE schluessel = 'schema'") === null) {
self::einfuegen('sm_meta', ['schluessel' => 'schema', 'wert' => (string) self::SCHEMA]);
}
self::migrieren();
return array_keys($tabellen);
}
public const SCHEMA = 2;
/**
* Bringt eine bestehende Datenbank auf den aktuellen Stand.
*
* Laeuft von selbst bei der ersten Anfrage nach einem Update - ohne
* einrichten.php, das nach der Ersteinrichtung geloescht sein soll. Eine
* Markerdatei im Datenordner erspart danach jede weitere Abfrage.
*
* Stand 2 (1.7.0): Konten ohne E-Mail - Mitmachen nur mit dem Schluessel
* des PCs.
*/
public static function migrieren(): void
{
$marke = sm_daten_ordner() . '/schema-' . self::SCHEMA . '.ok';
if (is_file($marke)) {
return;
}
$stand = (int) (self::wert("SELECT wert FROM sm_meta WHERE schluessel = 'schema'") ?? 1);
if ($stand < 2) {
if (!self::sqlite()) {
self::pdo()->exec('ALTER TABLE sm_nutzer MODIFY email VARCHAR(191) NULL');
}
self::ausfuehren("UPDATE sm_meta SET wert = '2' WHERE schluessel = 'schema'");
}
@file_put_contents($marke, self::jetzt());
}
}

View file

@ -7,6 +7,9 @@ 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 [
@ -14,9 +17,88 @@ final class Konten
'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;
@ -189,7 +271,8 @@ final class Konten
public static function kontoLoeschen(array $nutzer, string $passwort): void
{
if ($nutzer['passwort_hash'] === null || !password_verify($passwort, $nutzer['passwort_hash'])) {
// 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') {

View file

@ -73,8 +73,9 @@ final class Sicherheit
return null;
}
if ($zeile['genutzt_am'] === null || $zeile['genutzt_am'] < DB::jetzt(-86400)) {
DB::aktualisieren('sm_token',
['genutzt_am' => DB::jetzt(), 'laeuft_ab_am' => DB::jetzt(self::SITZUNG_TAGE * 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;

View file

@ -164,7 +164,7 @@ final class Verwaltung
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) {
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.");
@ -237,7 +237,8 @@ final class Verwaltung
{
$zahlen = [
'Nutzer' => DB::wert('SELECT COUNT(*) FROM sm_nutzer'),
'Unbestätigt' => DB::wert('SELECT COUNT(*) FROM sm_nutzer WHERE email_bestaetigt_am IS NULL'),
'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'),
@ -249,8 +250,9 @@ final class Verwaltung
}
$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>' . Web::e($n['email']) . '</td><td>'
. self::datum($n['erstellt_am']) . '</td></tr>';
$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'));
}
@ -273,16 +275,21 @@ final class Verwaltung
$gesperrt = (int) $n['gesperrt'] === 1;
$aktionen = $gesperrt ? self::knopf('nutzer_entsperren', $id, 'Entsperren')
: self::knopf('nutzer_sperren', $id, 'Sperren', true);
if ($n['email_bestaetigt_am'] === null) {
$nurSchluessel = $n['email'] === null;
if (!$nurSchluessel && $n['email_bestaetigt_am'] === null) {
$aktionen .= self::knopf('nutzer_bestaetigen', $id, 'Bestätigen');
}
$aktionen .= self::knopf('nutzer_passwortlink', $id, 'Passwort-Link');
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>' . Web::e($n['email']) . '</td><td>' . Web::e($n['rolle']) . '</td><td>'
. ($n['email_bestaetigt_am'] === null ? '<span style="color:var(--amber)">nein</span>' : 'ja')
. '</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>';
}

246
squad.py
View file

@ -1,9 +1,10 @@
"""
Hauptreiter SQUAD: Konto, alle Charaktere, Squads und Einladungen.
Ohne Anmeldung zeigt der Reiter die Anmeldung und Registrierung; alles
andere im Programm funktioniert auch ohne Konto. Angemeldet gibt es drei
Unterreiter:
Solange ein PC nicht mitmacht, zeigt der Reiter den Einstieg: Mitmachen mit
einem Spielernamen (der PC bekommt einen Schluessel, kein Konto noetig)
oder Anmelden mit einem gesicherten Konto. Alles andere im Programm geht
auch ohne. Wer mitmacht, sieht drei Unterreiter:
Charaktere alle Charaktere aller Spieler mit Zustand (KIA, MIA ...)
Squads alle Squads, eigene verwalten, neues gruenden
@ -92,8 +93,8 @@ class AbgleichSteuerung:
def melden(self, text=None, art="aus"):
if text is None:
text, art = ("Angemeldet – Abgleich folgt", "aus") if konto.angemeldet() \
else ("Nicht angemeldet – Akten liegen nur auf diesem PC", "aus")
text, art = ("Abgleich folgt", "aus") if konto.angemeldet() \
else ("Nur auf diesem PC – im Reiter SQUAD kannst du mitmachen", "aus")
for beobachter in self.beobachter:
beobachter(text, art)
@ -133,7 +134,8 @@ class AbgleichSteuerung:
def _fehler(self, fehler):
if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet":
self.melden("Die Anmeldung ist abgelaufen – bitte neu anmelden", "fehler")
self.melden("Der Server kennt diesen PC nicht mehr – im Reiter SQUAD neu mitmachen "
"oder anmelden", "fehler")
self.bei_abmeldung()
elif isinstance(fehler, konto.ServerFehler) and fehler.code == "offline":
self.melden("Offline – Änderungen werden später hochgeladen", "offline")
@ -154,6 +156,12 @@ class AbgleichSteuerung:
# -- Anmeldung und Registrierung ------------------------------------------------------
class AnmeldeFlaeche(ttk.Frame):
"""
Einstieg in den Squad-Reiter. Mitmachen braucht nur einen Spielernamen -
der PC bekommt einen Schluessel. Anmelden gibt es fuer gesicherte Konten,
etwa auf einem zweiten PC.
"""
def __init__(self, master, hintergrund, bei_anmeldung):
super().__init__(master)
self.hintergrund = hintergrund
@ -163,30 +171,30 @@ class AnmeldeFlaeche(ttk.Frame):
mitte = ttk.Frame(self)
mitte.place(relx=0.5, rely=0.42, anchor="center")
ttk.Label(mitte, text="SQUAD", font=("Segoe UI Semibold", 16)).pack(anchor="w")
ttk.Label(mitte, style="Dim.TLabel", justify="left", wraplength=420, text=(
"Mit einem Konto liegen deine Akten sicher auf dem Server, du siehst die "
"Charaktere der anderen Spieler und kannst Squads bilden. Ohne Konto "
"funktioniert alles andere wie bisher.")).pack(anchor="w", pady=(4, 14))
ttk.Label(mitte, style="Dim.TLabel", justify="left", wraplength=440, text=(
"Mach mit, um die Charaktere der anderen Spieler zu sehen und Squads zu bilden. "
"Deine Akten werden dann für alle sichtbar. Ein Konto brauchst du dafür nicht – "
"dieser PC bekommt einen eigenen Schlüssel.\n\n"
"Ohne Mitmachen bleiben deine Akten nur auf diesem PC.")).pack(anchor="w", pady=(4, 14))
reiter = ttk.Notebook(mitte)
reiter.pack(fill="x")
self.reiter = reiter
self._mitmachen_aufbauen(reiter)
self._anmelden_aufbauen(reiter)
self._registrieren_aufbauen(reiter)
self.meldung_var = tk.StringVar()
self.meldung = ttk.Label(mitte, textvariable=self.meldung_var, wraplength=420, justify="left")
self.meldung = ttk.Label(mitte, textvariable=self.meldung_var, wraplength=440, justify="left")
self.meldung.pack(anchor="w", pady=(12, 0))
self.erneut_knopf = ttk.Button(mitte, text="Bestätigungsmail erneut senden",
command=self.bestaetigung_erneut)
verweise = ttk.Frame(mitte)
verweise.pack(anchor="w", pady=(14, 0))
for text, pfad in (("Passwort vergessen?", None),
for text, ziel in (("Passwort vergessen?", konto.webseite("/konto/vergessen.php")),
("Impressum und Datenschutz", "https://tyrveil.com/rechtliches#impressum")):
verweis = ttk.Label(verweise, text=text, style="Dim.TLabel", cursor="hand2")
verweis.pack(side="left", padx=(0, 18))
ziel = pfad or konto.webseite("/konto/vergessen.php")
verweis.bind("<Button-1>", lambda e, z=ziel: webbrowser.open(z))
@staticmethod
@ -197,29 +205,31 @@ class AnmeldeFlaeche(ttk.Frame):
eingabe.grid(row=zeile, column=1, sticky="ew", pady=5)
return var, eingabe
def _mitmachen_aufbauen(self, reiter):
f = ttk.Frame(reiter, padding=16)
reiter.add(f, text="Mitmachen")
self.spielername_var, eingabe = self._feld(f, 0, "Spielername")
eingabe.bind("<Return>", lambda e: self.mitmachen())
ttk.Label(f, style="Dim.TLabel", wraplength=380, justify="left",
text="3 bis 32 Zeichen, etwa dein Discord- oder Steam-Name. Für alle sichtbar.").grid(
row=1, column=0, columnspan=2, sticky="w")
knopf = ttk.Button(f, text="Mitmachen", style="Accent.TButton", command=self.mitmachen)
knopf.grid(row=2, column=1, sticky="e", pady=(10, 0))
self._knoepfe.append(knopf)
def _anmelden_aufbauen(self, reiter):
f = ttk.Frame(reiter, padding=16)
reiter.add(f, text="Anmelden")
reiter.add(f, text="Mit Konto anmelden")
self.login_var, erstes = self._feld(f, 0, "Benutzername oder E-Mail")
self.passwort_var, pw = self._feld(f, 1, "Passwort", verdeckt=True)
ttk.Label(f, style="Dim.TLabel", wraplength=380, justify="left",
text="Für Konten, die mit E-Mail und Passwort gesichert sind – etwa auf einem zweiten PC."
).grid(row=2, column=0, columnspan=2, sticky="w")
knopf = ttk.Button(f, text="Anmelden", style="Accent.TButton", command=self.anmelden)
knopf.grid(row=2, column=1, sticky="e", pady=(10, 0))
knopf.grid(row=3, column=1, sticky="e", pady=(10, 0))
self._knoepfe.append(knopf)
for eingabe in (erstes, pw):
eingabe.bind("<Return>", lambda e: self.anmelden())
self.erstes_feld = erstes
def _registrieren_aufbauen(self, reiter):
f = ttk.Frame(reiter, padding=16)
reiter.add(f, text="Registrieren")
self.neu_name_var, _ = self._feld(f, 0, "Benutzername")
self.neu_email_var, _ = self._feld(f, 1, "E-Mail")
self.neu_pw_var, _ = self._feld(f, 2, "Passwort (mind. 10 Zeichen)", verdeckt=True)
self.neu_pw2_var, letztes = self._feld(f, 3, "Passwort wiederholen", verdeckt=True)
letztes.bind("<Return>", lambda e: self.registrieren())
knopf = ttk.Button(f, text="Konto anlegen", style="Accent.TButton", command=self.registrieren)
knopf.grid(row=4, column=1, sticky="e", pady=(10, 0))
self._knoepfe.append(knopf)
def _zeigen(self, text, art="info"):
farben = {"info": FG, "ok": OLIVE_HI, "fehler": RED, "warnung": AMBER}
@ -230,6 +240,25 @@ class AnmeldeFlaeche(ttk.Frame):
for knopf in self._knoepfe:
knopf.configure(state="disabled" if ja else "normal")
def mitmachen(self):
name = self.spielername_var.get().strip()
if not name:
self._zeigen("Bitte einen Spielernamen eingeben.", "warnung")
return
self._beschaeftigt(True)
self._zeigen("Einen Moment …")
def fertig(nutzer):
self._beschaeftigt(False)
self._zeigen("")
self.bei_anmeldung(nutzer)
def fehler(f):
self._beschaeftigt(False)
self._zeigen(fehlertext(f), "fehler")
self.hintergrund.starten(lambda: konto.mitmachen(name), fertig, fehler)
def anmelden(self):
login, passwort = self.login_var.get().strip(), self.passwort_var.get()
if not login or not passwort:
@ -262,33 +291,6 @@ class AnmeldeFlaeche(ttk.Frame):
lambda antwort: self._zeigen(antwort.get("meldung", "Mail ist unterwegs."), "ok"),
lambda f: self._zeigen(fehlertext(f), "fehler"))
def registrieren(self):
name, email = self.neu_name_var.get().strip(), self.neu_email_var.get().strip()
pw, pw2 = self.neu_pw_var.get(), self.neu_pw2_var.get()
if not name or not email or not pw:
self._zeigen("Bitte alle Felder ausfüllen.", "warnung")
return
if pw != pw2:
self._zeigen("Die beiden Passwörter stimmen nicht überein.", "warnung")
return
self._beschaeftigt(True)
self._zeigen("Lege Konto an …")
def fertig(antwort):
self._beschaeftigt(False)
self.neu_pw_var.set("")
self.neu_pw2_var.set("")
self.login_var.set(email)
self.reiter.select(0)
self._zeigen("Konto angelegt. Bitte bestätige den Link in der Mail an "
f"{email} – danach kannst du dich hier anmelden.", "ok")
def fehler(f):
self._beschaeftigt(False)
self._zeigen(fehlertext(f), "fehler")
self.hintergrund.starten(lambda: konto.registrieren(name, email, pw), fertig, fehler)
# -- Fremde Akte ansehen ----------------------------------------------------------------
@ -381,8 +383,7 @@ class SquadSeite(ttk.Frame):
if konto.angemeldet():
self.anmeldung.pack_forget()
self.inhalt.pack(fill="both", expand=True)
nutzer = konto.nutzer() or {}
self.nutzer_var.set(f"Angemeldet als {nutzer.get('benutzername', '?')}")
self._kopf_aktualisieren()
else:
self.inhalt.pack_forget()
self.anmeldung.pack(fill="both", expand=True)
@ -410,6 +411,101 @@ class SquadSeite(ttk.Frame):
self.hintergrund.starten(konto.abmelden, lambda _: self._abgemeldet(),
lambda f: self._abgemeldet())
# -- Konto --------------------------------------------------------------------------
def _kopf_aktualisieren(self):
nutzer = konto.nutzer() or {}
self.nutzer_var.set(f"Spieler: {nutzer.get('benutzername', '?')}")
if not nutzer.get("gesichert", True):
text = ("Deine Charaktere hängen nur am Schlüssel dieses PCs. Nach einem Reset wären sie "
"nicht mehr bearbeitbar – Konto sichern …")
elif not nutzer.get("bestaetigt", True):
text = "E-Mail-Adresse noch nicht bestätigt – den Link in der Mail öffnen. Erneut senden …"
else:
text = ""
self.sichern_text.configure(text=text)
if text:
self.sichern_zeile.pack(fill="x", pady=(0, 6), before=self.nb)
else:
self.sichern_zeile.pack_forget()
def _hinweis_geklickt(self):
nutzer = konto.nutzer() or {}
if not nutzer.get("gesichert", True):
self.konto_sichern()
elif not nutzer.get("bestaetigt", True):
self._bestaetigung_erneut()
def _konto_menue_fuellen(self):
menue = self.konto_menue
menue.delete(0, "end")
nutzer = konto.nutzer() or {}
if nutzer.get("gesichert", True):
if not nutzer.get("bestaetigt", True):
menue.add_command(label="Bestätigungsmail erneut senden", command=self._bestaetigung_erneut)
menue.add_command(label="Abmelden", command=self.abmelden)
else:
# Kein Abmelden: Das loeschte den Schluessel, und die Charaktere waeren verwaist
menue.add_command(label="Konto sichern …", command=self.konto_sichern)
menue.add_separator()
menue.add_command(label="Konto löschen …", command=self.konto_loeschen)
def _bestaetigung_erneut(self):
email = (konto.nutzer() or {}).get("email")
if email:
self.hintergrund.starten(lambda: konto.bestaetigung_erneut(email),
lambda _: self.status_var.set(f"Bestätigungsmail an {email} ist unterwegs."),
lambda f: messagebox.showerror("Konto", fehlertext(f), parent=self))
def konto_sichern(self):
"""E-Mail und Passwort an den Schluessel haengen."""
fenster = tk.Toplevel(self)
fenster.title("Konto sichern")
fenster.configure(bg=BG)
fenster.resizable(False, False)
fenster.transient(self.winfo_toplevel())
f = ttk.Frame(fenster, padding=18)
f.pack(fill="both")
ttk.Label(f, wraplength=400, justify="left", text=(
"Mit E-Mail und Passwort überstehen deine Charaktere einen PC-Reset, und du kannst "
"dich auch auf einem zweiten PC anmelden. Dein Spielername bleibt gleich.")).grid(
row=0, column=0, columnspan=2, sticky="w", pady=(0, 10))
felder = {}
for zeile, (schluessel, text, verdeckt) in enumerate((("email", "E-Mail", False),
("pw", "Passwort (mind. 10 Zeichen)", True),
("pw2", "Passwort wiederholen", True)), start=1):
ttk.Label(f, text=text).grid(row=zeile, column=0, sticky="w", pady=5, padx=(0, 12))
felder[schluessel] = tk.StringVar()
ttk.Entry(f, textvariable=felder[schluessel], width=32, show="•" if verdeckt else "").grid(
row=zeile, column=1, sticky="ew", pady=5)
meldung = ttk.Label(f, text="", foreground=RED, wraplength=400, justify="left")
meldung.grid(row=4, column=0, columnspan=2, sticky="w", pady=(6, 0))
def sichern():
email, pw = felder["email"].get().strip(), felder["pw"].get()
if pw != felder["pw2"].get():
meldung.configure(text="Die beiden Passwörter stimmen nicht überein.")
return
meldung.configure(text="Einen Moment …", foreground=FG_DIM)
def fertig(_):
fenster.destroy()
self._kopf_aktualisieren()
messagebox.showinfo("Konto sichern", f"Fast geschafft: Bestätige den Link in der Mail an {email}. "
"Danach kannst du dich auch auf anderen PCs mit E-Mail und Passwort anmelden.",
parent=self)
self.hintergrund.starten(lambda: konto.konto_sichern(email, pw), fertig,
lambda fehler: meldung.configure(text=fehlertext(fehler), foreground=RED))
knoepfe = ttk.Frame(f)
knoepfe.grid(row=5, column=0, columnspan=2, sticky="e", pady=(12, 0))
ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right")
ttk.Button(knoepfe, text="Sichern", style="Accent.TButton", command=sichern).pack(side="right", padx=(0, 8))
fenster.bind("<Escape>", lambda e: fenster.destroy())
dialog_zentrieren(fenster, self)
fenster.grab_set()
def konto_loeschen(self):
"""Loescht das Konto samt Akten auf dem Server. Die lokalen Akten bleiben."""
fenster = tk.Toplevel(self)
@ -424,14 +520,17 @@ class SquadSeite(ttk.Frame):
"deiner Charaktere ein Squad, übernimmt das dienstälteste Mitglied.\n\n"
"Deine Akten auf diesem PC bleiben erhalten. Das lässt sich nicht rückgängig machen.")
).grid(row=0, column=0, columnspan=2, sticky="w")
ttk.Label(f, text="Passwort zur Bestätigung").grid(row=1, column=0, sticky="w", pady=(14, 0), padx=(0, 12))
passwort = tk.StringVar()
eingabe = ttk.Entry(f, textvariable=passwort, show="•", width=28)
eingabe.grid(row=1, column=1, sticky="ew", pady=(14, 0))
mit_passwort = konto.gesichert()
eingabe = None
if mit_passwort:
ttk.Label(f, text="Passwort zur Bestätigung").grid(row=1, column=0, sticky="w", pady=(14, 0), padx=(0, 12))
eingabe = ttk.Entry(f, textvariable=passwort, show="•", width=28)
eingabe.grid(row=1, column=1, sticky="ew", pady=(14, 0))
def loeschen():
wert = passwort.get()
if wert:
if wert or not mit_passwort:
fenster.destroy()
self.konto_loeschen_ausfuehren(wert)
@ -442,7 +541,8 @@ class SquadSeite(ttk.Frame):
fenster.bind("<Escape>", lambda e: fenster.destroy())
dialog_zentrieren(fenster, self)
fenster.grab_set()
eingabe.focus_set()
if eingabe is not None:
eingabe.focus_set()
def konto_loeschen_ausfuehren(self, passwort, bestaetigen=True):
def arbeit():
@ -474,13 +574,18 @@ class SquadSeite(ttk.Frame):
self.nutzer_var = tk.StringVar()
ttk.Label(kopf, textvariable=self.nutzer_var, font=FONT_BOLD).pack(side="left")
konto_menue = ttk.Menubutton(kopf, text="Konto")
menue = tk.Menu(konto_menue, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE_HI,
activeforeground="#12150f", font=FONT_UI)
menue.add_command(label="Abmelden", command=self.abmelden)
menue.add_separator()
menue.add_command(label="Konto löschen …", command=self.konto_loeschen)
konto_menue["menu"] = menue
# Die Eintraege haengen davon ab, ob das Konto gesichert ist - beim Oeffnen neu fuellen
self.konto_menue = tk.Menu(konto_menue, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE_HI,
activeforeground="#12150f", font=FONT_UI,
postcommand=self._konto_menue_fuellen)
konto_menue["menu"] = self.konto_menue
konto_menue.pack(side="right")
# Solange das Konto nur am Schluessel dieses PCs haengt, daran erinnern
self.sichern_zeile = ttk.Frame(self.inhalt)
self.sichern_text = ttk.Label(self.sichern_zeile, foreground=AMBER, cursor="hand2", wraplength=820)
self.sichern_text.pack(side="left")
self.sichern_text.bind("<Button-1>", lambda e: self._hinweis_geklickt())
ttk.Button(kopf, text="Aktualisieren", command=self.aktualisieren).pack(side="right", padx=(0, 6))
self.status_var = tk.StringVar()
self.status = ttk.Label(kopf, textvariable=self.status_var, style="Dim.TLabel")
@ -489,6 +594,7 @@ class SquadSeite(ttk.Frame):
nb = ttk.Notebook(self.inhalt)
nb.pack(fill="both", expand=True)
self.nb = nb
self.sichern_zeile.pack(fill="x", pady=(0, 6), before=nb)
self._charaktere_aufbauen(nb)
self._squads_aufbauen(nb)
self._einladungen_aufbauen(nb)
@ -616,6 +722,7 @@ class SquadSeite(ttk.Frame):
fraktion = "" if self.fraktion_var.get() == ALLE_FRAKTIONEN else self.fraktion_var.get()
def arbeit():
konto.pruefen() # frischer Kontostand, etwa ob die E-Mail inzwischen bestaetigt ist
return (konto.aufrufen("charaktere_alle", suche=suche, fraktion=fraktion)["charaktere"],
konto.aufrufen("squads")["squads"],
konto.aufrufen("einladungen"))
@ -632,6 +739,7 @@ class SquadSeite(ttk.Frame):
def _geladen(self, ergebnis):
self._laedt = False
self._zuletzt_geladen = time.time()
self._kopf_aktualisieren()
self.charaktere, self.squads, einladungen = ergebnis
self.einladungen = {"eingang": einladungen.get("eingang", []), "ausgang": einladungen.get("ausgang", [])}
self.status_var.set(f"{len(self.charaktere)} Charaktere · {len(self.squads)} Squads · "

View file

@ -61,12 +61,12 @@ import squad # noqa: E402
import update_helfer # noqa: E402
APP_NAME = "Squad Manager"
VERSION = "1.6.1"
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 = 4
BUILD = 5
# Letzte Version aus der Zeit vor den Zaehlnummern
LETZTE_ALTE_VERSION = "4.0"
CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "config.json"

View file

@ -50,7 +50,6 @@ def konto_anlegen(name, email, passwort):
# -- Vorbereitung auf dem Server und lokal ---------------------------------------
server.roh("/einrichten.php", {"schluessel": st.SCHLUESSEL})
konto_anlegen("danny", "danny@example.org", "dannypasswort1")
kamerad = konto_anlegen("kamerad", "kamerad@example.org", "kameradpasswort1")
rook_akte = {"schema": 1, "id": "ab" * 16, "personalien": {"vorname": "Dale", "nachname": "Hutchins", "callsign": "Rook"},
"dienst": {"fraktion": "US Marine Corps", "teilstreitkraft": "Marineinfanterie",
@ -124,16 +123,26 @@ def warte(bedingung, dann, grenze=60.0, name=""):
def schritt_anmeldung():
app.haupt_nb.select(2)
root.update()
pruefe("ohne Anmeldung: Anmeldeseite", seite.anmeldung.winfo_ismapped())
foto(root, "ui_1_anmeldung.png")
seite.anmeldung.login_var.set("danny")
seite.anmeldung.passwort_var.set("dannypasswort1")
seite.anmeldung.anmelden()
warte(lambda: konto.angemeldet() and seite.inhalt.winfo_ismapped(), schritt_abgleich, name="Anmeldung")
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():
pruefe("angemeldet, Inhalt sichtbar", seite.nutzer_var.get() == "Angemeldet als danny", seite.nutzer_var.get())
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")
@ -225,7 +234,36 @@ def schritt_fenster(vorher):
def schritt_akte():
app.haupt_nb.select(1)
root.after(500, lambda: (foto(root, "ui_6_akte_status.png"), schritt_konto_loeschen()))
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():

View file

@ -262,6 +262,16 @@ def ablauf(s):
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)
@ -442,6 +452,52 @@ def ablauf(s):
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))
@ -465,7 +521,7 @@ def ablauf(s):
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", "alice@example.org"), ("charaktere", "Nordlicht"), ("squads", "Squads"),
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)