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:
parent
c175e42546
commit
a5da53d373
14 changed files with 491 additions and 121 deletions
|
|
@ -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*.
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
19
konto.py
19
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)
|
||||
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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') {
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -164,7 +164,7 @@ final class Verwaltung
|
|||
self::weiter('nutzer', 'E-Mail-Adresse als bestätigt markiert.');
|
||||
case 'nutzer_passwortlink':
|
||||
$nutzer = DB::eine('SELECT * FROM sm_nutzer WHERE id = ?', [$id]);
|
||||
if ($nutzer !== null) {
|
||||
if ($nutzer !== null && $nutzer['email'] !== null) {
|
||||
Konten::passwortLinkSenden($nutzer, 86400,
|
||||
"über die Verwaltung wurde ein Link zum Festlegen eines neuen Passworts angefordert:\n\n"
|
||||
. "%LINK%\n\nDer Link ist 24 Stunden gültig.");
|
||||
|
|
@ -237,7 +237,8 @@ final class Verwaltung
|
|||
{
|
||||
$zahlen = [
|
||||
'Nutzer' => DB::wert('SELECT COUNT(*) FROM sm_nutzer'),
|
||||
'Unbestätigt' => DB::wert('SELECT COUNT(*) FROM sm_nutzer WHERE email_bestaetigt_am IS NULL'),
|
||||
'Nur Schlüssel' => DB::wert('SELECT COUNT(*) FROM sm_nutzer WHERE email IS NULL'),
|
||||
'Unbestätigt' => DB::wert('SELECT COUNT(*) FROM sm_nutzer WHERE email IS NOT NULL AND email_bestaetigt_am IS NULL'),
|
||||
'Gesperrt' => DB::wert('SELECT COUNT(*) FROM sm_nutzer WHERE gesperrt = 1'),
|
||||
'Charaktere' => DB::wert('SELECT COUNT(*) FROM sm_charakter'),
|
||||
'Squads' => DB::wert('SELECT COUNT(*) FROM sm_squad'),
|
||||
|
|
@ -249,8 +250,9 @@ final class Verwaltung
|
|||
}
|
||||
$html .= '</div><h2>NEUESTE KONTEN</h2><div class="tabelle"><table><tr><th>Benutzername</th><th>E-Mail</th><th>Registriert</th></tr>';
|
||||
foreach (DB::alle('SELECT benutzername, email, erstellt_am FROM sm_nutzer ORDER BY id DESC LIMIT 10') as $n) {
|
||||
$html .= '<tr><td>' . Web::e($n['benutzername']) . '</td><td>' . Web::e($n['email']) . '</td><td>'
|
||||
. self::datum($n['erstellt_am']) . '</td></tr>';
|
||||
$html .= '<tr><td>' . Web::e($n['benutzername']) . '</td><td>'
|
||||
. ($n['email'] === null ? '<span class="dim">nur Schlüssel</span>' : Web::e($n['email']))
|
||||
. '</td><td>' . self::datum($n['erstellt_am']) . '</td></tr>';
|
||||
}
|
||||
Web::seite('Verwaltung', $html . '</table></div>', '1100px', self::navigation('uebersicht'));
|
||||
}
|
||||
|
|
@ -273,16 +275,21 @@ final class Verwaltung
|
|||
$gesperrt = (int) $n['gesperrt'] === 1;
|
||||
$aktionen = $gesperrt ? self::knopf('nutzer_entsperren', $id, 'Entsperren')
|
||||
: self::knopf('nutzer_sperren', $id, 'Sperren', true);
|
||||
if ($n['email_bestaetigt_am'] === null) {
|
||||
$nurSchluessel = $n['email'] === null;
|
||||
if (!$nurSchluessel && $n['email_bestaetigt_am'] === null) {
|
||||
$aktionen .= self::knopf('nutzer_bestaetigen', $id, 'Bestätigen');
|
||||
}
|
||||
$aktionen .= self::knopf('nutzer_passwortlink', $id, 'Passwort-Link');
|
||||
if (!$nurSchluessel) {
|
||||
$aktionen .= self::knopf('nutzer_passwortlink', $id, 'Passwort-Link');
|
||||
}
|
||||
if ($n['rolle'] !== 'admin') {
|
||||
$aktionen .= self::loeschLink('nutzer_loeschen', $id, 'Löschen …');
|
||||
}
|
||||
$html .= '<tr><td>' . Web::e($n['benutzername']) . ($gesperrt ? ' <span class="hinweis fehler" style="padding:1px 6px">gesperrt</span>' : '')
|
||||
. '</td><td>' . Web::e($n['email']) . '</td><td>' . Web::e($n['rolle']) . '</td><td>'
|
||||
. ($n['email_bestaetigt_am'] === null ? '<span style="color:var(--amber)">nein</span>' : 'ja')
|
||||
. '</td><td>' . ($nurSchluessel ? '<span class="dim">nur Schlüssel</span>' : Web::e($n['email']))
|
||||
. '</td><td>' . Web::e($n['rolle']) . '</td><td>'
|
||||
. ($nurSchluessel ? '<span class="dim">—</span>'
|
||||
: ($n['email_bestaetigt_am'] === null ? '<span style="color:var(--amber)">nein</span>' : 'ja'))
|
||||
. '</td><td class="mono">' . (int) $n['anzahl'] . '</td><td>' . self::datum($n['erstellt_am'])
|
||||
. '</td><td>' . self::datum($n['letzte_anmeldung_am']) . '</td><td>' . $aktionen . '</td></tr>';
|
||||
}
|
||||
|
|
|
|||
246
squad.py
246
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("<Button-1>", lambda e, z=ziel: webbrowser.open(z))
|
||||
|
||||
@staticmethod
|
||||
|
|
@ -197,29 +205,31 @@ class AnmeldeFlaeche(ttk.Frame):
|
|||
eingabe.grid(row=zeile, column=1, sticky="ew", pady=5)
|
||||
return var, eingabe
|
||||
|
||||
def _mitmachen_aufbauen(self, reiter):
|
||||
f = ttk.Frame(reiter, padding=16)
|
||||
reiter.add(f, text="Mitmachen")
|
||||
self.spielername_var, eingabe = self._feld(f, 0, "Spielername")
|
||||
eingabe.bind("<Return>", lambda e: self.mitmachen())
|
||||
ttk.Label(f, style="Dim.TLabel", wraplength=380, justify="left",
|
||||
text="3 bis 32 Zeichen, etwa dein Discord- oder Steam-Name. Für alle sichtbar.").grid(
|
||||
row=1, column=0, columnspan=2, sticky="w")
|
||||
knopf = ttk.Button(f, text="Mitmachen", style="Accent.TButton", command=self.mitmachen)
|
||||
knopf.grid(row=2, column=1, sticky="e", pady=(10, 0))
|
||||
self._knoepfe.append(knopf)
|
||||
|
||||
def _anmelden_aufbauen(self, reiter):
|
||||
f = ttk.Frame(reiter, padding=16)
|
||||
reiter.add(f, text="Anmelden")
|
||||
reiter.add(f, text="Mit Konto anmelden")
|
||||
self.login_var, erstes = self._feld(f, 0, "Benutzername oder E-Mail")
|
||||
self.passwort_var, pw = self._feld(f, 1, "Passwort", verdeckt=True)
|
||||
ttk.Label(f, style="Dim.TLabel", wraplength=380, justify="left",
|
||||
text="Für Konten, die mit E-Mail und Passwort gesichert sind – etwa auf einem zweiten PC."
|
||||
).grid(row=2, column=0, columnspan=2, sticky="w")
|
||||
knopf = ttk.Button(f, text="Anmelden", style="Accent.TButton", command=self.anmelden)
|
||||
knopf.grid(row=2, column=1, sticky="e", pady=(10, 0))
|
||||
knopf.grid(row=3, column=1, sticky="e", pady=(10, 0))
|
||||
self._knoepfe.append(knopf)
|
||||
for eingabe in (erstes, pw):
|
||||
eingabe.bind("<Return>", lambda e: self.anmelden())
|
||||
self.erstes_feld = erstes
|
||||
|
||||
def _registrieren_aufbauen(self, reiter):
|
||||
f = ttk.Frame(reiter, padding=16)
|
||||
reiter.add(f, text="Registrieren")
|
||||
self.neu_name_var, _ = self._feld(f, 0, "Benutzername")
|
||||
self.neu_email_var, _ = self._feld(f, 1, "E-Mail")
|
||||
self.neu_pw_var, _ = self._feld(f, 2, "Passwort (mind. 10 Zeichen)", verdeckt=True)
|
||||
self.neu_pw2_var, letztes = self._feld(f, 3, "Passwort wiederholen", verdeckt=True)
|
||||
letztes.bind("<Return>", lambda e: self.registrieren())
|
||||
knopf = ttk.Button(f, text="Konto anlegen", style="Accent.TButton", command=self.registrieren)
|
||||
knopf.grid(row=4, column=1, sticky="e", pady=(10, 0))
|
||||
self._knoepfe.append(knopf)
|
||||
|
||||
def _zeigen(self, text, art="info"):
|
||||
farben = {"info": FG, "ok": OLIVE_HI, "fehler": RED, "warnung": AMBER}
|
||||
|
|
@ -230,6 +240,25 @@ class AnmeldeFlaeche(ttk.Frame):
|
|||
for knopf in self._knoepfe:
|
||||
knopf.configure(state="disabled" if ja else "normal")
|
||||
|
||||
def mitmachen(self):
|
||||
name = self.spielername_var.get().strip()
|
||||
if not name:
|
||||
self._zeigen("Bitte einen Spielernamen eingeben.", "warnung")
|
||||
return
|
||||
self._beschaeftigt(True)
|
||||
self._zeigen("Einen Moment …")
|
||||
|
||||
def fertig(nutzer):
|
||||
self._beschaeftigt(False)
|
||||
self._zeigen("")
|
||||
self.bei_anmeldung(nutzer)
|
||||
|
||||
def fehler(f):
|
||||
self._beschaeftigt(False)
|
||||
self._zeigen(fehlertext(f), "fehler")
|
||||
|
||||
self.hintergrund.starten(lambda: konto.mitmachen(name), fertig, fehler)
|
||||
|
||||
def anmelden(self):
|
||||
login, passwort = self.login_var.get().strip(), self.passwort_var.get()
|
||||
if not login or not passwort:
|
||||
|
|
@ -262,33 +291,6 @@ class AnmeldeFlaeche(ttk.Frame):
|
|||
lambda antwort: self._zeigen(antwort.get("meldung", "Mail ist unterwegs."), "ok"),
|
||||
lambda f: self._zeigen(fehlertext(f), "fehler"))
|
||||
|
||||
def registrieren(self):
|
||||
name, email = self.neu_name_var.get().strip(), self.neu_email_var.get().strip()
|
||||
pw, pw2 = self.neu_pw_var.get(), self.neu_pw2_var.get()
|
||||
if not name or not email or not pw:
|
||||
self._zeigen("Bitte alle Felder ausfüllen.", "warnung")
|
||||
return
|
||||
if pw != pw2:
|
||||
self._zeigen("Die beiden Passwörter stimmen nicht überein.", "warnung")
|
||||
return
|
||||
self._beschaeftigt(True)
|
||||
self._zeigen("Lege Konto an …")
|
||||
|
||||
def fertig(antwort):
|
||||
self._beschaeftigt(False)
|
||||
self.neu_pw_var.set("")
|
||||
self.neu_pw2_var.set("")
|
||||
self.login_var.set(email)
|
||||
self.reiter.select(0)
|
||||
self._zeigen("Konto angelegt. Bitte bestätige den Link in der Mail an "
|
||||
f"{email} – danach kannst du dich hier anmelden.", "ok")
|
||||
|
||||
def fehler(f):
|
||||
self._beschaeftigt(False)
|
||||
self._zeigen(fehlertext(f), "fehler")
|
||||
|
||||
self.hintergrund.starten(lambda: konto.registrieren(name, email, pw), fertig, fehler)
|
||||
|
||||
|
||||
# -- Fremde Akte ansehen ----------------------------------------------------------------
|
||||
|
||||
|
|
@ -381,8 +383,7 @@ class SquadSeite(ttk.Frame):
|
|||
if konto.angemeldet():
|
||||
self.anmeldung.pack_forget()
|
||||
self.inhalt.pack(fill="both", expand=True)
|
||||
nutzer = konto.nutzer() or {}
|
||||
self.nutzer_var.set(f"Angemeldet als {nutzer.get('benutzername', '?')}")
|
||||
self._kopf_aktualisieren()
|
||||
else:
|
||||
self.inhalt.pack_forget()
|
||||
self.anmeldung.pack(fill="both", expand=True)
|
||||
|
|
@ -410,6 +411,101 @@ class SquadSeite(ttk.Frame):
|
|||
self.hintergrund.starten(konto.abmelden, lambda _: self._abgemeldet(),
|
||||
lambda f: self._abgemeldet())
|
||||
|
||||
# -- Konto --------------------------------------------------------------------------
|
||||
|
||||
def _kopf_aktualisieren(self):
|
||||
nutzer = konto.nutzer() or {}
|
||||
self.nutzer_var.set(f"Spieler: {nutzer.get('benutzername', '?')}")
|
||||
if not nutzer.get("gesichert", True):
|
||||
text = ("Deine Charaktere hängen nur am Schlüssel dieses PCs. Nach einem Reset wären sie "
|
||||
"nicht mehr bearbeitbar – Konto sichern …")
|
||||
elif not nutzer.get("bestaetigt", True):
|
||||
text = "E-Mail-Adresse noch nicht bestätigt – den Link in der Mail öffnen. Erneut senden …"
|
||||
else:
|
||||
text = ""
|
||||
self.sichern_text.configure(text=text)
|
||||
if text:
|
||||
self.sichern_zeile.pack(fill="x", pady=(0, 6), before=self.nb)
|
||||
else:
|
||||
self.sichern_zeile.pack_forget()
|
||||
|
||||
def _hinweis_geklickt(self):
|
||||
nutzer = konto.nutzer() or {}
|
||||
if not nutzer.get("gesichert", True):
|
||||
self.konto_sichern()
|
||||
elif not nutzer.get("bestaetigt", True):
|
||||
self._bestaetigung_erneut()
|
||||
|
||||
def _konto_menue_fuellen(self):
|
||||
menue = self.konto_menue
|
||||
menue.delete(0, "end")
|
||||
nutzer = konto.nutzer() or {}
|
||||
if nutzer.get("gesichert", True):
|
||||
if not nutzer.get("bestaetigt", True):
|
||||
menue.add_command(label="Bestätigungsmail erneut senden", command=self._bestaetigung_erneut)
|
||||
menue.add_command(label="Abmelden", command=self.abmelden)
|
||||
else:
|
||||
# Kein Abmelden: Das loeschte den Schluessel, und die Charaktere waeren verwaist
|
||||
menue.add_command(label="Konto sichern …", command=self.konto_sichern)
|
||||
menue.add_separator()
|
||||
menue.add_command(label="Konto löschen …", command=self.konto_loeschen)
|
||||
|
||||
def _bestaetigung_erneut(self):
|
||||
email = (konto.nutzer() or {}).get("email")
|
||||
if email:
|
||||
self.hintergrund.starten(lambda: konto.bestaetigung_erneut(email),
|
||||
lambda _: self.status_var.set(f"Bestätigungsmail an {email} ist unterwegs."),
|
||||
lambda f: messagebox.showerror("Konto", fehlertext(f), parent=self))
|
||||
|
||||
def konto_sichern(self):
|
||||
"""E-Mail und Passwort an den Schluessel haengen."""
|
||||
fenster = tk.Toplevel(self)
|
||||
fenster.title("Konto sichern")
|
||||
fenster.configure(bg=BG)
|
||||
fenster.resizable(False, False)
|
||||
fenster.transient(self.winfo_toplevel())
|
||||
f = ttk.Frame(fenster, padding=18)
|
||||
f.pack(fill="both")
|
||||
ttk.Label(f, wraplength=400, justify="left", text=(
|
||||
"Mit E-Mail und Passwort überstehen deine Charaktere einen PC-Reset, und du kannst "
|
||||
"dich auch auf einem zweiten PC anmelden. Dein Spielername bleibt gleich.")).grid(
|
||||
row=0, column=0, columnspan=2, sticky="w", pady=(0, 10))
|
||||
felder = {}
|
||||
for zeile, (schluessel, text, verdeckt) in enumerate((("email", "E-Mail", False),
|
||||
("pw", "Passwort (mind. 10 Zeichen)", True),
|
||||
("pw2", "Passwort wiederholen", True)), start=1):
|
||||
ttk.Label(f, text=text).grid(row=zeile, column=0, sticky="w", pady=5, padx=(0, 12))
|
||||
felder[schluessel] = tk.StringVar()
|
||||
ttk.Entry(f, textvariable=felder[schluessel], width=32, show="•" if verdeckt else "").grid(
|
||||
row=zeile, column=1, sticky="ew", pady=5)
|
||||
meldung = ttk.Label(f, text="", foreground=RED, wraplength=400, justify="left")
|
||||
meldung.grid(row=4, column=0, columnspan=2, sticky="w", pady=(6, 0))
|
||||
|
||||
def sichern():
|
||||
email, pw = felder["email"].get().strip(), felder["pw"].get()
|
||||
if pw != felder["pw2"].get():
|
||||
meldung.configure(text="Die beiden Passwörter stimmen nicht überein.")
|
||||
return
|
||||
meldung.configure(text="Einen Moment …", foreground=FG_DIM)
|
||||
|
||||
def fertig(_):
|
||||
fenster.destroy()
|
||||
self._kopf_aktualisieren()
|
||||
messagebox.showinfo("Konto sichern", f"Fast geschafft: Bestätige den Link in der Mail an {email}. "
|
||||
"Danach kannst du dich auch auf anderen PCs mit E-Mail und Passwort anmelden.",
|
||||
parent=self)
|
||||
|
||||
self.hintergrund.starten(lambda: konto.konto_sichern(email, pw), fertig,
|
||||
lambda fehler: meldung.configure(text=fehlertext(fehler), foreground=RED))
|
||||
|
||||
knoepfe = ttk.Frame(f)
|
||||
knoepfe.grid(row=5, column=0, columnspan=2, sticky="e", pady=(12, 0))
|
||||
ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right")
|
||||
ttk.Button(knoepfe, text="Sichern", style="Accent.TButton", command=sichern).pack(side="right", padx=(0, 8))
|
||||
fenster.bind("<Escape>", lambda e: fenster.destroy())
|
||||
dialog_zentrieren(fenster, self)
|
||||
fenster.grab_set()
|
||||
|
||||
def konto_loeschen(self):
|
||||
"""Loescht das Konto samt Akten auf dem Server. Die lokalen Akten bleiben."""
|
||||
fenster = tk.Toplevel(self)
|
||||
|
|
@ -424,14 +520,17 @@ class SquadSeite(ttk.Frame):
|
|||
"deiner Charaktere ein Squad, übernimmt das dienstälteste Mitglied.\n\n"
|
||||
"Deine Akten auf diesem PC bleiben erhalten. Das lässt sich nicht rückgängig machen.")
|
||||
).grid(row=0, column=0, columnspan=2, sticky="w")
|
||||
ttk.Label(f, text="Passwort zur Bestätigung").grid(row=1, column=0, sticky="w", pady=(14, 0), padx=(0, 12))
|
||||
passwort = tk.StringVar()
|
||||
eingabe = ttk.Entry(f, textvariable=passwort, show="•", width=28)
|
||||
eingabe.grid(row=1, column=1, sticky="ew", pady=(14, 0))
|
||||
mit_passwort = konto.gesichert()
|
||||
eingabe = None
|
||||
if mit_passwort:
|
||||
ttk.Label(f, text="Passwort zur Bestätigung").grid(row=1, column=0, sticky="w", pady=(14, 0), padx=(0, 12))
|
||||
eingabe = ttk.Entry(f, textvariable=passwort, show="•", width=28)
|
||||
eingabe.grid(row=1, column=1, sticky="ew", pady=(14, 0))
|
||||
|
||||
def loeschen():
|
||||
wert = passwort.get()
|
||||
if wert:
|
||||
if wert or not mit_passwort:
|
||||
fenster.destroy()
|
||||
self.konto_loeschen_ausfuehren(wert)
|
||||
|
||||
|
|
@ -442,7 +541,8 @@ class SquadSeite(ttk.Frame):
|
|||
fenster.bind("<Escape>", lambda e: fenster.destroy())
|
||||
dialog_zentrieren(fenster, self)
|
||||
fenster.grab_set()
|
||||
eingabe.focus_set()
|
||||
if eingabe is not None:
|
||||
eingabe.focus_set()
|
||||
|
||||
def konto_loeschen_ausfuehren(self, passwort, bestaetigen=True):
|
||||
def arbeit():
|
||||
|
|
@ -474,13 +574,18 @@ class SquadSeite(ttk.Frame):
|
|||
self.nutzer_var = tk.StringVar()
|
||||
ttk.Label(kopf, textvariable=self.nutzer_var, font=FONT_BOLD).pack(side="left")
|
||||
konto_menue = ttk.Menubutton(kopf, text="Konto")
|
||||
menue = tk.Menu(konto_menue, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE_HI,
|
||||
activeforeground="#12150f", font=FONT_UI)
|
||||
menue.add_command(label="Abmelden", command=self.abmelden)
|
||||
menue.add_separator()
|
||||
menue.add_command(label="Konto löschen …", command=self.konto_loeschen)
|
||||
konto_menue["menu"] = menue
|
||||
# Die Eintraege haengen davon ab, ob das Konto gesichert ist - beim Oeffnen neu fuellen
|
||||
self.konto_menue = tk.Menu(konto_menue, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE_HI,
|
||||
activeforeground="#12150f", font=FONT_UI,
|
||||
postcommand=self._konto_menue_fuellen)
|
||||
konto_menue["menu"] = self.konto_menue
|
||||
konto_menue.pack(side="right")
|
||||
|
||||
# Solange das Konto nur am Schluessel dieses PCs haengt, daran erinnern
|
||||
self.sichern_zeile = ttk.Frame(self.inhalt)
|
||||
self.sichern_text = ttk.Label(self.sichern_zeile, foreground=AMBER, cursor="hand2", wraplength=820)
|
||||
self.sichern_text.pack(side="left")
|
||||
self.sichern_text.bind("<Button-1>", lambda e: self._hinweis_geklickt())
|
||||
ttk.Button(kopf, text="Aktualisieren", command=self.aktualisieren).pack(side="right", padx=(0, 6))
|
||||
self.status_var = tk.StringVar()
|
||||
self.status = ttk.Label(kopf, textvariable=self.status_var, style="Dim.TLabel")
|
||||
|
|
@ -489,6 +594,7 @@ class SquadSeite(ttk.Frame):
|
|||
nb = ttk.Notebook(self.inhalt)
|
||||
nb.pack(fill="both", expand=True)
|
||||
self.nb = nb
|
||||
self.sichern_zeile.pack(fill="x", pady=(0, 6), before=nb)
|
||||
self._charaktere_aufbauen(nb)
|
||||
self._squads_aufbauen(nb)
|
||||
self._einladungen_aufbauen(nb)
|
||||
|
|
@ -616,6 +722,7 @@ class SquadSeite(ttk.Frame):
|
|||
fraktion = "" if self.fraktion_var.get() == ALLE_FRAKTIONEN else self.fraktion_var.get()
|
||||
|
||||
def arbeit():
|
||||
konto.pruefen() # frischer Kontostand, etwa ob die E-Mail inzwischen bestaetigt ist
|
||||
return (konto.aufrufen("charaktere_alle", suche=suche, fraktion=fraktion)["charaktere"],
|
||||
konto.aufrufen("squads")["squads"],
|
||||
konto.aufrufen("einladungen"))
|
||||
|
|
@ -632,6 +739,7 @@ class SquadSeite(ttk.Frame):
|
|||
def _geladen(self, ergebnis):
|
||||
self._laedt = False
|
||||
self._zuletzt_geladen = time.time()
|
||||
self._kopf_aktualisieren()
|
||||
self.charaktere, self.squads, einladungen = ergebnis
|
||||
self.einladungen = {"eingang": einladungen.get("eingang", []), "ausgang": einladungen.get("ausgang", [])}
|
||||
self.status_var.set(f"{len(self.charaktere)} Charaktere · {len(self.squads)} Squads · "
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -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():
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue