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 # 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 Seit 3.2 wird über einen Inno-Setup-Installer und einen eingebauten
Auto-Updater verteilt (Server: https://sva.tyrveil.com), siehe Abschnitt 4. 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 Bereiche der Küstenwache, die Bundeswehr Heer, Luftwaffe und Marine mit
eigenen Marine-Dienstgraden. eigenen Marine-Dienstgraden.
**Squad-Reiter und Abgleich (seit 1.6.0):** Ohne Konto zeigt *SQUAD* die **Squad-Reiter und Abgleich (seit 1.6.0):** Solange ein PC nicht
Anmeldung und Registrierung; alles andere läuft ohne Konto wie vorher. 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, Angemeldet: Unterreiter *Charaktere* (alle Spieler, Zustand KIA/MIA/WIA,
Suche, Fraktionsfilter, fremde Akte als Dokument), *Squads* (gründen, Suche, Fraktionsfilter, fremde Akte als Dokument), *Squads* (gründen,
Mitglieder, Führung übergeben, verlassen, auflösen) und *Einladungen*. 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) ## Squad Manager (sva.tyrveil.com)
Der Squad Manager ist ein kostenloses Programm für die Spielgemeinschaft Der Squad Manager ist ein kostenloses Programm für die Spielgemeinschaft
rund um das Spiel Squad. Wer möchte, kann ein Konto anlegen, Personalakten rund um das Spiel Squad. Wer im Programm „Mitmachen" wählt, legt einen
seiner Rollenspiel-Charaktere auf dem Server speichern und mit anderen Spielernamen fest; die Personalakten seiner Rollenspiel-Charaktere werden
registrierten Nutzern Squads bilden. Ohne Konto werden keine Daten an uns dann auf dem Server gespeichert, und er kann mit anderen Squads bilden.
übertragen; das Programm prüft dann lediglich beim Start, ob eine neue 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. Version vorliegt.
**Verantwortlicher:** [wie im Impressum] **Verantwortlicher:** [wie im Impressum]
### Welche Daten wir verarbeiten ### Welche Daten wir verarbeiten
- **Kontodaten:** Benutzername, E-Mail-Adresse und das Passwort – dieses - **Beim Mitmachen:** der gewählte Spielername und der Zeitpunkt.
nur als nicht umkehrbarer Hash. Dazu Zeitpunkt der Registrierung, der - **Nur bei gesichertem Konto:** E-Mail-Adresse und Passwort – dieses nur
E-Mail-Bestätigung und der letzten Anmeldung. als nicht umkehrbarer Hash –, dazu Zeitpunkt der E-Mail-Bestätigung und
- **Anmeldung:** Beim Anmelden erzeugen wir ein zufälliges Sitzungs-Token. der letzten Anmeldung.
Auf unserem Server liegt davon nur ein Prüfwert, zusammen mit dem - **Schlüssel und Anmeldung:** Beim Mitmachen oder Anmelden erzeugen wir
Rechnernamen, den das Programm übermittelt, damit sich Sitzungen ein zufälliges Token, das dein PC als Schlüssel aufbewahrt. Auf unserem
unterscheiden lassen. 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 - **Charakterdaten:** alle Angaben, die du in einer Personalakte einträgst
(etwa Namen, Callsign, Dienstgrad, Fraktion, Beschreibung, (etwa Namen, Callsign, Dienstgrad, Fraktion, Beschreibung,
Auszeichnungen, Einsätze, Vermerke) und ein hochgeladenes Porträt. Auszeichnungen, Einsätze, Vermerke) und ein hochgeladenes Porträt.
@ -41,8 +44,8 @@ Version vorliegt.
### Wer die Daten sieht ### Wer die Daten sieht
Charakterdaten, Porträts, Squads und dein **Benutzername** sind für alle Charakterdaten, Porträts, Squads und dein **Spielername** sind für alle
angemeldeten Nutzer des Squad Managers sichtbar – das ist der Zweck der Nutzer des Squad Managers sichtbar, die ebenfalls mitmachen – das ist der Zweck der
Funktion. Deine E-Mail-Adresse sehen andere Nutzer nicht. Der Betreiber Funktion. Deine E-Mail-Adresse sehen andere Nutzer nicht. Der Betreiber
kann über eine Verwaltung Konten sperren oder löschen. kann über eine Verwaltung Konten sperren oder löschen.
@ -60,9 +63,11 @@ Dritte findet nicht statt.
### Speicherdauer und Löschung ### Speicherdauer und Löschung
Deine Daten bleiben gespeichert, solange dein Konto besteht. Du kannst Deine Daten bleiben gespeichert, solange dein Konto besteht – auch dann,
dein Konto jederzeit im Programm löschen (Reiter SQUAD → Konto → Konto wenn der Schlüssel auf deinem PC verloren geht und du kein gesichertes
löschen). Dabei werden das Konto, alle Charaktere, Porträts und 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 Sitzungen auf dem Server gelöscht. Führt einer deiner Charaktere ein
Squad, geht die Führung an ein anderes Mitglied über. Kopien deiner Squad, geht die Führung an ein anderes Mitglied über. Kopien deiner
Akten auf deinem eigenen PC bleiben davon unberührt. 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 Ä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. 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 Reihenfolge ist wichtig: version.json zuletzt. Solange sie noch auf
die alte Version zeigt, bekommt niemand einen Link auf eine Datei, die die alte Version zeigt, bekommt niemand einen Link auf eine Datei, die

View file

@ -2,7 +2,7 @@
; Uebersetzen mit: ISCC.exe setup.iss ; Uebersetzen mit: ISCC.exe setup.iss
#define Name "Squad Manager" #define Name "Squad Manager"
#define Version "1.6.1" #define Version "1.7.0"
#define Herausgeber "tyrveil.com" #define Herausgeber "tyrveil.com"
#define Website "https://sva.tyrveil.com" #define Website "https://sva.tyrveil.com"
@ -151,10 +151,11 @@ begin
SquadVoiceActivation bleibt stehen - eine Installation von 3.1 kann ihn SquadVoiceActivation bleibt stehen - eine Installation von 3.1 kann ihn
noch benutzen. } noch benutzen. }
{ Der Ordner enthaelt seit 3.4 auch die Akten - das muss in der Frage stehen } { 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 ' + Auswahl := SuppressibleMsgBox('Sollen auch die Einstellungen, die lokal gespeicherten Akten und ' +
'entfernt werden?' + #13#10#13#10 + 'der Squad-Schluessel dieses PCs entfernt werden?' + #13#10#13#10 +
'Akten, die mit einem Konto gesichert sind, bleiben auf dem Server ' + 'Ohne gesichertes Konto (E-Mail und Passwort) lassen sich deine ' +
'und kommen nach der naechsten Anmeldung zurueck.', 'Charaktere danach nicht mehr bearbeiten. Mit gesichertem Konto ' +
'kommen sie nach der naechsten Anmeldung zurueck.',
mbConfirmation, MB_YESNO, IDNO); mbConfirmation, MB_YESNO, IDNO);
if Auswahl = IDYES then if Auswahl = IDYES then
DelTree(ExpandConstant('{userappdata}\SquadManager'), True, True, True); DelTree(ExpandConstant('{userappdata}\SquadManager'), True, True, True);

View file

@ -167,6 +167,25 @@ def nutzer():
return stand["nutzer"] if stand else None 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): def registrieren(benutzername, email, passwort):
return anfrage("registrieren", benutzername=benutzername, email=email, passwort=passwort) return anfrage("registrieren", benutzername=benutzername, email=email, passwort=passwort)

View file

@ -11,7 +11,8 @@ declare(strict_types=1);
final class Api 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 const MAX_ANFRAGE_BYTES = 12 * 1024 * 1024;
private static function senden(array $daten, int $http = 200): never 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) { if ($roh === false || strlen($roh) > self::MAX_ANFRAGE_BYTES) {
throw new SmFehler('anfrage_zu_gross', 'Die Anfrage ist zu groß.', 413); throw new SmFehler('anfrage_zu_gross', 'Die Anfrage ist zu groß.', 413);
} }
DB::migrieren();
$anfrage = json_decode($roh, true); $anfrage = json_decode($roh, true);
if (!is_array($anfrage) || !is_string($anfrage['aktion'] ?? null)) { if (!is_array($anfrage) || !is_string($anfrage['aktion'] ?? null)) {
throw new SmFehler('anfrage_ungueltig', 'Ungültige Anfrage.'); throw new SmFehler('anfrage_ungueltig', 'Ungültige Anfrage.');
@ -84,6 +86,12 @@ final class Api
return ['api' => SM_API_VERSION, 'zeit' => DB::jetzt()]; return ['api' => SM_API_VERSION, 'zeit' => DB::jetzt()];
// -- Konto ------------------------------------------------------ // -- 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': case 'registrieren':
Konten::registrieren(self::text($a, 'benutzername', 64), self::text($a, 'email', 250), Konten::registrieren(self::text($a, 'benutzername', 64), self::text($a, 'email', 250),
self::text($a, 'passwort', 500)); self::text($a, 'passwort', 500));

View file

@ -133,7 +133,7 @@ final class DB
id $id, id $id,
benutzername VARCHAR(32) NOT NULL, benutzername VARCHAR(32) NOT NULL,
benutzername_klein VARCHAR(32) NOT NULL, benutzername_klein VARCHAR(32) NOT NULL,
email VARCHAR(191) NOT NULL, email VARCHAR(191) NULL,
passwort_hash VARCHAR(255) NULL, passwort_hash VARCHAR(255) NULL,
rolle VARCHAR(16) NOT NULL DEFAULT 'nutzer', rolle VARCHAR(16) NOT NULL DEFAULT 'nutzer',
email_bestaetigt_am DATETIME NULL, email_bestaetigt_am DATETIME NULL,
@ -229,8 +229,38 @@ final class DB
} }
} }
self::ausfuehren('DELETE FROM sm_meta WHERE schluessel = ?', ['schema']); if (self::wert("SELECT wert FROM sm_meta WHERE schluessel = 'schema'") === null) {
self::einfuegen('sm_meta', ['schluessel' => 'schema', 'wert' => '1']); self::einfuegen('sm_meta', ['schluessel' => 'schema', 'wert' => (string) self::SCHEMA]);
}
self::migrieren();
return array_keys($tabellen); 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 final class Konten
{ {
/** Laufzeit des Schluessels eines PCs ohne Konto: praktisch unbegrenzt. */
public const SCHLUESSEL_TAGE = 36500;
public static function oeffentlich(array $nutzer): array public static function oeffentlich(array $nutzer): array
{ {
return [ return [
@ -14,9 +17,88 @@ final class Konten
'benutzername' => $nutzer['benutzername'], 'benutzername' => $nutzer['benutzername'],
'email' => $nutzer['email'], 'email' => $nutzer['email'],
'rolle' => $nutzer['rolle'], '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 public static function link(string $pfad): string
{ {
return rtrim((string) sm_config('basis_url', 'https://sva.tyrveil.com'), '/') . $pfad; 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 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); throw new SmFehler('anmeldung_falsch', 'Das Passwort stimmt nicht.', 401);
} }
if ($nutzer['rolle'] === 'admin') { if ($nutzer['rolle'] === 'admin') {

View file

@ -73,8 +73,9 @@ final class Sicherheit
return null; return null;
} }
if ($zeile['genutzt_am'] === null || $zeile['genutzt_am'] < DB::jetzt(-86400)) { if ($zeile['genutzt_am'] === null || $zeile['genutzt_am'] < DB::jetzt(-86400)) {
DB::aktualisieren('sm_token', // Nie verkuerzen: Der Schluessel eines PCs ohne Konto laeuft gar nicht ab
['genutzt_am' => DB::jetzt(), 'laeuft_ab_am' => DB::jetzt(self::SITZUNG_TAGE * 86400)], $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']]); 'id = ?', [$zeile['token_id']]);
} }
return $zeile; return $zeile;

View file

@ -164,7 +164,7 @@ final class Verwaltung
self::weiter('nutzer', 'E-Mail-Adresse als bestätigt markiert.'); self::weiter('nutzer', 'E-Mail-Adresse als bestätigt markiert.');
case 'nutzer_passwortlink': case 'nutzer_passwortlink':
$nutzer = DB::eine('SELECT * FROM sm_nutzer WHERE id = ?', [$id]); $nutzer = DB::eine('SELECT * FROM sm_nutzer WHERE id = ?', [$id]);
if ($nutzer !== null) { if ($nutzer !== null && $nutzer['email'] !== null) {
Konten::passwortLinkSenden($nutzer, 86400, Konten::passwortLinkSenden($nutzer, 86400,
"über die Verwaltung wurde ein Link zum Festlegen eines neuen Passworts angefordert:\n\n" "über die Verwaltung wurde ein Link zum Festlegen eines neuen Passworts angefordert:\n\n"
. "%LINK%\n\nDer Link ist 24 Stunden gültig."); . "%LINK%\n\nDer Link ist 24 Stunden gültig.");
@ -237,7 +237,8 @@ final class Verwaltung
{ {
$zahlen = [ $zahlen = [
'Nutzer' => DB::wert('SELECT COUNT(*) FROM sm_nutzer'), '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'), 'Gesperrt' => DB::wert('SELECT COUNT(*) FROM sm_nutzer WHERE gesperrt = 1'),
'Charaktere' => DB::wert('SELECT COUNT(*) FROM sm_charakter'), 'Charaktere' => DB::wert('SELECT COUNT(*) FROM sm_charakter'),
'Squads' => DB::wert('SELECT COUNT(*) FROM sm_squad'), '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>'; $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) { 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>' $html .= '<tr><td>' . Web::e($n['benutzername']) . '</td><td>'
. self::datum($n['erstellt_am']) . '</td></tr>'; . ($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')); Web::seite('Verwaltung', $html . '</table></div>', '1100px', self::navigation('uebersicht'));
} }
@ -273,16 +275,21 @@ final class Verwaltung
$gesperrt = (int) $n['gesperrt'] === 1; $gesperrt = (int) $n['gesperrt'] === 1;
$aktionen = $gesperrt ? self::knopf('nutzer_entsperren', $id, 'Entsperren') $aktionen = $gesperrt ? self::knopf('nutzer_entsperren', $id, 'Entsperren')
: self::knopf('nutzer_sperren', $id, 'Sperren', true); : 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_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') { if ($n['rolle'] !== 'admin') {
$aktionen .= self::loeschLink('nutzer_loeschen', $id, 'Löschen …'); $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>' : '') $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>' . '</td><td>' . ($nurSchluessel ? '<span class="dim">nur Schlüssel</span>' : Web::e($n['email']))
. ($n['email_bestaetigt_am'] === null ? '<span style="color:var(--amber)">nein</span>' : 'ja') . '</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 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>'; . '</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. Hauptreiter SQUAD: Konto, alle Charaktere, Squads und Einladungen.
Ohne Anmeldung zeigt der Reiter die Anmeldung und Registrierung; alles Solange ein PC nicht mitmacht, zeigt der Reiter den Einstieg: Mitmachen mit
andere im Programm funktioniert auch ohne Konto. Angemeldet gibt es drei einem Spielernamen (der PC bekommt einen Schluessel, kein Konto noetig)
Unterreiter: 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 ...) Charaktere alle Charaktere aller Spieler mit Zustand (KIA, MIA ...)
Squads alle Squads, eigene verwalten, neues gruenden Squads alle Squads, eigene verwalten, neues gruenden
@ -92,8 +93,8 @@ class AbgleichSteuerung:
def melden(self, text=None, art="aus"): def melden(self, text=None, art="aus"):
if text is None: if text is None:
text, art = ("Angemeldet – Abgleich folgt", "aus") if konto.angemeldet() \ text, art = ("Abgleich folgt", "aus") if konto.angemeldet() \
else ("Nicht angemeldet – Akten liegen nur auf diesem PC", "aus") else ("Nur auf diesem PC – im Reiter SQUAD kannst du mitmachen", "aus")
for beobachter in self.beobachter: for beobachter in self.beobachter:
beobachter(text, art) beobachter(text, art)
@ -133,7 +134,8 @@ class AbgleichSteuerung:
def _fehler(self, fehler): def _fehler(self, fehler):
if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet": 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() self.bei_abmeldung()
elif isinstance(fehler, konto.ServerFehler) and fehler.code == "offline": elif isinstance(fehler, konto.ServerFehler) and fehler.code == "offline":
self.melden("Offline – Änderungen werden später hochgeladen", "offline") self.melden("Offline – Änderungen werden später hochgeladen", "offline")
@ -154,6 +156,12 @@ class AbgleichSteuerung:
# -- Anmeldung und Registrierung ------------------------------------------------------ # -- Anmeldung und Registrierung ------------------------------------------------------
class AnmeldeFlaeche(ttk.Frame): 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): def __init__(self, master, hintergrund, bei_anmeldung):
super().__init__(master) super().__init__(master)
self.hintergrund = hintergrund self.hintergrund = hintergrund
@ -163,30 +171,30 @@ class AnmeldeFlaeche(ttk.Frame):
mitte = ttk.Frame(self) mitte = ttk.Frame(self)
mitte.place(relx=0.5, rely=0.42, anchor="center") 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, text="SQUAD", font=("Segoe UI Semibold", 16)).pack(anchor="w")
ttk.Label(mitte, style="Dim.TLabel", justify="left", wraplength=420, text=( ttk.Label(mitte, style="Dim.TLabel", justify="left", wraplength=440, text=(
"Mit einem Konto liegen deine Akten sicher auf dem Server, du siehst die " "Mach mit, um die Charaktere der anderen Spieler zu sehen und Squads zu bilden. "
"Charaktere der anderen Spieler und kannst Squads bilden. Ohne Konto " "Deine Akten werden dann für alle sichtbar. Ein Konto brauchst du dafür nicht – "
"funktioniert alles andere wie bisher.")).pack(anchor="w", pady=(4, 14)) "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 = ttk.Notebook(mitte)
reiter.pack(fill="x") reiter.pack(fill="x")
self.reiter = reiter self.reiter = reiter
self._mitmachen_aufbauen(reiter)
self._anmelden_aufbauen(reiter) self._anmelden_aufbauen(reiter)
self._registrieren_aufbauen(reiter)
self.meldung_var = tk.StringVar() 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.meldung.pack(anchor="w", pady=(12, 0))
self.erneut_knopf = ttk.Button(mitte, text="Bestätigungsmail erneut senden", self.erneut_knopf = ttk.Button(mitte, text="Bestätigungsmail erneut senden",
command=self.bestaetigung_erneut) command=self.bestaetigung_erneut)
verweise = ttk.Frame(mitte) verweise = ttk.Frame(mitte)
verweise.pack(anchor="w", pady=(14, 0)) 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")): ("Impressum und Datenschutz", "https://tyrveil.com/rechtliches#impressum")):
verweis = ttk.Label(verweise, text=text, style="Dim.TLabel", cursor="hand2") verweis = ttk.Label(verweise, text=text, style="Dim.TLabel", cursor="hand2")
verweis.pack(side="left", padx=(0, 18)) 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)) verweis.bind("<Button-1>", lambda e, z=ziel: webbrowser.open(z))
@staticmethod @staticmethod
@ -197,29 +205,31 @@ class AnmeldeFlaeche(ttk.Frame):
eingabe.grid(row=zeile, column=1, sticky="ew", pady=5) eingabe.grid(row=zeile, column=1, sticky="ew", pady=5)
return var, eingabe 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): def _anmelden_aufbauen(self, reiter):
f = ttk.Frame(reiter, padding=16) 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.login_var, erstes = self._feld(f, 0, "Benutzername oder E-Mail")
self.passwort_var, pw = self._feld(f, 1, "Passwort", verdeckt=True) 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 = 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) self._knoepfe.append(knopf)
for eingabe in (erstes, pw): for eingabe in (erstes, pw):
eingabe.bind("<Return>", lambda e: self.anmelden()) 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"): def _zeigen(self, text, art="info"):
farben = {"info": FG, "ok": OLIVE_HI, "fehler": RED, "warnung": AMBER} farben = {"info": FG, "ok": OLIVE_HI, "fehler": RED, "warnung": AMBER}
@ -230,6 +240,25 @@ class AnmeldeFlaeche(ttk.Frame):
for knopf in self._knoepfe: for knopf in self._knoepfe:
knopf.configure(state="disabled" if ja else "normal") 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): def anmelden(self):
login, passwort = self.login_var.get().strip(), self.passwort_var.get() login, passwort = self.login_var.get().strip(), self.passwort_var.get()
if not login or not passwort: 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 antwort: self._zeigen(antwort.get("meldung", "Mail ist unterwegs."), "ok"),
lambda f: self._zeigen(fehlertext(f), "fehler")) 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 ---------------------------------------------------------------- # -- Fremde Akte ansehen ----------------------------------------------------------------
@ -381,8 +383,7 @@ class SquadSeite(ttk.Frame):
if konto.angemeldet(): if konto.angemeldet():
self.anmeldung.pack_forget() self.anmeldung.pack_forget()
self.inhalt.pack(fill="both", expand=True) self.inhalt.pack(fill="both", expand=True)
nutzer = konto.nutzer() or {} self._kopf_aktualisieren()
self.nutzer_var.set(f"Angemeldet als {nutzer.get('benutzername', '?')}")
else: else:
self.inhalt.pack_forget() self.inhalt.pack_forget()
self.anmeldung.pack(fill="both", expand=True) self.anmeldung.pack(fill="both", expand=True)
@ -410,6 +411,101 @@ class SquadSeite(ttk.Frame):
self.hintergrund.starten(konto.abmelden, lambda _: self._abgemeldet(), self.hintergrund.starten(konto.abmelden, lambda _: self._abgemeldet(),
lambda f: 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): def konto_loeschen(self):
"""Loescht das Konto samt Akten auf dem Server. Die lokalen Akten bleiben.""" """Loescht das Konto samt Akten auf dem Server. Die lokalen Akten bleiben."""
fenster = tk.Toplevel(self) fenster = tk.Toplevel(self)
@ -424,14 +520,17 @@ class SquadSeite(ttk.Frame):
"deiner Charaktere ein Squad, übernimmt das dienstälteste Mitglied.\n\n" "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.") "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") ).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() passwort = tk.StringVar()
eingabe = ttk.Entry(f, textvariable=passwort, show="•", width=28) mit_passwort = konto.gesichert()
eingabe.grid(row=1, column=1, sticky="ew", pady=(14, 0)) 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(): def loeschen():
wert = passwort.get() wert = passwort.get()
if wert: if wert or not mit_passwort:
fenster.destroy() fenster.destroy()
self.konto_loeschen_ausfuehren(wert) self.konto_loeschen_ausfuehren(wert)
@ -442,7 +541,8 @@ class SquadSeite(ttk.Frame):
fenster.bind("<Escape>", lambda e: fenster.destroy()) fenster.bind("<Escape>", lambda e: fenster.destroy())
dialog_zentrieren(fenster, self) dialog_zentrieren(fenster, self)
fenster.grab_set() fenster.grab_set()
eingabe.focus_set() if eingabe is not None:
eingabe.focus_set()
def konto_loeschen_ausfuehren(self, passwort, bestaetigen=True): def konto_loeschen_ausfuehren(self, passwort, bestaetigen=True):
def arbeit(): def arbeit():
@ -474,13 +574,18 @@ class SquadSeite(ttk.Frame):
self.nutzer_var = tk.StringVar() self.nutzer_var = tk.StringVar()
ttk.Label(kopf, textvariable=self.nutzer_var, font=FONT_BOLD).pack(side="left") ttk.Label(kopf, textvariable=self.nutzer_var, font=FONT_BOLD).pack(side="left")
konto_menue = ttk.Menubutton(kopf, text="Konto") konto_menue = ttk.Menubutton(kopf, text="Konto")
menue = tk.Menu(konto_menue, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE_HI, # Die Eintraege haengen davon ab, ob das Konto gesichert ist - beim Oeffnen neu fuellen
activeforeground="#12150f", font=FONT_UI) self.konto_menue = tk.Menu(konto_menue, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE_HI,
menue.add_command(label="Abmelden", command=self.abmelden) activeforeground="#12150f", font=FONT_UI,
menue.add_separator() postcommand=self._konto_menue_fuellen)
menue.add_command(label="Konto löschen …", command=self.konto_loeschen) konto_menue["menu"] = self.konto_menue
konto_menue["menu"] = menue
konto_menue.pack(side="right") 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)) ttk.Button(kopf, text="Aktualisieren", command=self.aktualisieren).pack(side="right", padx=(0, 6))
self.status_var = tk.StringVar() self.status_var = tk.StringVar()
self.status = ttk.Label(kopf, textvariable=self.status_var, style="Dim.TLabel") 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 = ttk.Notebook(self.inhalt)
nb.pack(fill="both", expand=True) nb.pack(fill="both", expand=True)
self.nb = nb self.nb = nb
self.sichern_zeile.pack(fill="x", pady=(0, 6), before=nb)
self._charaktere_aufbauen(nb) self._charaktere_aufbauen(nb)
self._squads_aufbauen(nb) self._squads_aufbauen(nb)
self._einladungen_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() fraktion = "" if self.fraktion_var.get() == ALLE_FRAKTIONEN else self.fraktion_var.get()
def arbeit(): def arbeit():
konto.pruefen() # frischer Kontostand, etwa ob die E-Mail inzwischen bestaetigt ist
return (konto.aufrufen("charaktere_alle", suche=suche, fraktion=fraktion)["charaktere"], return (konto.aufrufen("charaktere_alle", suche=suche, fraktion=fraktion)["charaktere"],
konto.aufrufen("squads")["squads"], konto.aufrufen("squads")["squads"],
konto.aufrufen("einladungen")) konto.aufrufen("einladungen"))
@ -632,6 +739,7 @@ class SquadSeite(ttk.Frame):
def _geladen(self, ergebnis): def _geladen(self, ergebnis):
self._laedt = False self._laedt = False
self._zuletzt_geladen = time.time() self._zuletzt_geladen = time.time()
self._kopf_aktualisieren()
self.charaktere, self.squads, einladungen = ergebnis self.charaktere, self.squads, einladungen = ergebnis
self.einladungen = {"eingang": einladungen.get("eingang", []), "ausgang": einladungen.get("ausgang", [])} self.einladungen = {"eingang": einladungen.get("eingang", []), "ausgang": einladungen.get("ausgang", [])}
self.status_var.set(f"{len(self.charaktere)} Charaktere · {len(self.squads)} Squads · " 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 import update_helfer # noqa: E402
APP_NAME = "Squad Manager" APP_NAME = "Squad Manager"
VERSION = "1.6.1" VERSION = "1.7.0"
# Zaehlnummer fuer den Update-Vergleich, bei jedem Release um eins erhoehen. # Zaehlnummer fuer den Update-Vergleich, bei jedem Release um eins erhoehen.
# Seit 1.5.0 getrennt von der angezeigten Version: Die Anzeige sprang von # 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 # 4.0 auf 1.5.0 zurueck, ein Vergleich der Anzeige haette danach nie wieder
# ein Update gefunden. # ein Update gefunden.
BUILD = 4 BUILD = 5
# Letzte Version aus der Zeit vor den Zaehlnummern # Letzte Version aus der Zeit vor den Zaehlnummern
LETZTE_ALTE_VERSION = "4.0" LETZTE_ALTE_VERSION = "4.0"
CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "config.json" 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 --------------------------------------- # -- Vorbereitung auf dem Server und lokal ---------------------------------------
server.roh("/einrichten.php", {"schluessel": st.SCHLUESSEL}) server.roh("/einrichten.php", {"schluessel": st.SCHLUESSEL})
konto_anlegen("danny", "danny@example.org", "dannypasswort1")
kamerad = konto_anlegen("kamerad", "kamerad@example.org", "kameradpasswort1") kamerad = konto_anlegen("kamerad", "kamerad@example.org", "kameradpasswort1")
rook_akte = {"schema": 1, "id": "ab" * 16, "personalien": {"vorname": "Dale", "nachname": "Hutchins", "callsign": "Rook"}, rook_akte = {"schema": 1, "id": "ab" * 16, "personalien": {"vorname": "Dale", "nachname": "Hutchins", "callsign": "Rook"},
"dienst": {"fraktion": "US Marine Corps", "teilstreitkraft": "Marineinfanterie", "dienst": {"fraktion": "US Marine Corps", "teilstreitkraft": "Marineinfanterie",
@ -124,16 +123,26 @@ def warte(bedingung, dann, grenze=60.0, name=""):
def schritt_anmeldung(): def schritt_anmeldung():
app.haupt_nb.select(2) app.haupt_nb.select(2)
root.update() root.update()
pruefe("ohne Anmeldung: Anmeldeseite", seite.anmeldung.winfo_ismapped()) pruefe("ohne Mitmachen: Einstiegsseite", seite.anmeldung.winfo_ismapped())
foto(root, "ui_1_anmeldung.png") pruefe("vor dem Mitmachen nichts hochgeladen", "Nur auf diesem PC" in app.akte.abgleich_var.get(),
seite.anmeldung.login_var.set("danny") app.akte.abgleich_var.get())
seite.anmeldung.passwort_var.set("dannypasswort1") foto(root, "ui_1_mitmachen.png")
seite.anmeldung.anmelden() seite.anmeldung.spielername_var.set("danny")
warte(lambda: konto.angemeldet() and seite.inhalt.winfo_ismapped(), schritt_abgleich, name="Anmeldung") seite.anmeldung.mitmachen()
warte(lambda: konto.angemeldet() and seite.inhalt.winfo_ismapped(), schritt_abgleich, name="Mitmachen")
def schritt_abgleich(): 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") warte(lambda: "abgeglichen" in app.akte.abgleich_var.get(), schritt_liste, name="Abgleich")
@ -225,7 +234,36 @@ def schritt_fenster(vorher):
def schritt_akte(): def schritt_akte():
app.haupt_nb.select(1) 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(): 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) 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()) 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") print("Schnittstelle allgemein")
code, antwort = s.api("status") code, antwort = s.api("status")
pruefe("status", code == 200 and antwort.get("api") == 1, antwort) pruefe("status", code == 200 and antwort.get("api") == 1, antwort)
@ -442,6 +452,52 @@ def ablauf(s):
alice = antwort.get("token") alice = antwort.get("token")
pruefe("Anmeldung mit neuem Passwort", bool(alice), antwort) 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") print("Verwaltung")
jar = http.cookiejar.CookieJar() jar = http.cookiejar.CookieJar()
oeffner = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar)) 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", code, html, _ = s.roh("/verwaltung/", {"aktion": "anmelden", "email": "info@tyrveil.com",
"passwort": "adminpasswort99", "csrf": csrf(html)}, oeffner=oeffner) "passwort": "adminpasswort99", "csrf": csrf(html)}, oeffner=oeffner)
pruefe("Admin angemeldet, Übersicht", code == 200 and "Offene Einladungen" in html.decode(), html[-300:]) 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")): (f"charakter&id={nordlicht['id']}", "ROHDATEN")):
code, html, _ = s.roh(f"/verwaltung/?seite={seite}", oeffner=oeffner) code, html, _ = s.roh(f"/verwaltung/?seite={seite}", oeffner=oeffner)
pruefe(f"Seite {seite.split('&')[0]}", code == 200 and erwartet in html.decode(), code) pruefe(f"Seite {seite.split('&')[0]}", code == 200 and erwartet in html.decode(), code)