diff --git a/PROJEKT-UEBERGABE.md b/PROJEKT-UEBERGABE.md index 0bc43d4..6f76ddc 100644 --- a/PROJEKT-UEBERGABE.md +++ b/PROJEKT-UEBERGABE.md @@ -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*. diff --git a/installer/DATENSCHUTZ-BAUSTEIN.md b/installer/DATENSCHUTZ-BAUSTEIN.md index e136a5c..e2e63a0 100644 --- a/installer/DATENSCHUTZ-BAUSTEIN.md +++ b/installer/DATENSCHUTZ-BAUSTEIN.md @@ -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. diff --git a/installer/HOCHLADEN.txt b/installer/HOCHLADEN.txt index b52d70c..dd8d2ab 100644 --- a/installer/HOCHLADEN.txt +++ b/installer/HOCHLADEN.txt @@ -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 diff --git a/installer/setup.iss b/installer/setup.iss index 4112def..83a7c1f 100644 --- a/installer/setup.iss +++ b/installer/setup.iss @@ -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); diff --git a/konto.py b/konto.py index 95a19aa..6c76934 100644 --- a/konto.py +++ b/konto.py @@ -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) diff --git a/server/sva-privat/app/api.php b/server/sva-privat/app/api.php index 8817762..9cf0373 100644 --- a/server/sva-privat/app/api.php +++ b/server/sva-privat/app/api.php @@ -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)); diff --git a/server/sva-privat/app/db.php b/server/sva-privat/app/db.php index 3170a17..2a88fe1 100644 --- a/server/sva-privat/app/db.php +++ b/server/sva-privat/app/db.php @@ -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()); + } } diff --git a/server/sva-privat/app/konten.php b/server/sva-privat/app/konten.php index eff10f2..7d4c0f8 100644 --- a/server/sva-privat/app/konten.php +++ b/server/sva-privat/app/konten.php @@ -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') { diff --git a/server/sva-privat/app/sicherheit.php b/server/sva-privat/app/sicherheit.php index b87a054..40a3429 100644 --- a/server/sva-privat/app/sicherheit.php +++ b/server/sva-privat/app/sicherheit.php @@ -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; diff --git a/server/sva-privat/app/verwaltung.php b/server/sva-privat/app/verwaltung.php index 312416a..1b8fb12 100644 --- a/server/sva-privat/app/verwaltung.php +++ b/server/sva-privat/app/verwaltung.php @@ -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 .= '

NEUESTE KONTEN

'; foreach (DB::alle('SELECT benutzername, email, erstellt_am FROM sm_nutzer ORDER BY id DESC LIMIT 10') as $n) { - $html .= ''; + $html .= ''; } Web::seite('Verwaltung', $html . '
BenutzernameE-MailRegistriert
' . Web::e($n['benutzername']) . '' . Web::e($n['email']) . '' - . self::datum($n['erstellt_am']) . '
' . Web::e($n['benutzername']) . '' + . ($n['email'] === null ? 'nur Schlüssel' : Web::e($n['email'])) + . '' . self::datum($n['erstellt_am']) . '
', '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 .= '' . Web::e($n['benutzername']) . ($gesperrt ? ' gesperrt' : '') - . '' . Web::e($n['email']) . '' . Web::e($n['rolle']) . '' - . ($n['email_bestaetigt_am'] === null ? 'nein' : 'ja') + . '' . ($nurSchluessel ? 'nur Schlüssel' : Web::e($n['email'])) + . '' . Web::e($n['rolle']) . '' + . ($nurSchluessel ? '—' + : ($n['email_bestaetigt_am'] === null ? 'nein' : 'ja')) . '' . (int) $n['anzahl'] . '' . self::datum($n['erstellt_am']) . '' . self::datum($n['letzte_anmeldung_am']) . '' . $aktionen . ''; } diff --git a/squad.py b/squad.py index c4274cf..9185b13 100644 --- a/squad.py +++ b/squad.py @@ -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("", 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("", 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("", 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("", 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("", 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("", 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("", 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 · " diff --git a/squad_manager.py b/squad_manager.py index 52b5d23..2e2f96d 100644 --- a/squad_manager.py +++ b/squad_manager.py @@ -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" diff --git a/werkzeuge/oberflaeche_test.py b/werkzeuge/oberflaeche_test.py index e604d76..0975f77 100644 --- a/werkzeuge/oberflaeche_test.py +++ b/werkzeuge/oberflaeche_test.py @@ -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(): diff --git a/werkzeuge/server_test.py b/werkzeuge/server_test.py index 4918a71..1d350ac 100644 --- a/werkzeuge/server_test.py +++ b/werkzeuge/server_test.py @@ -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)