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>
266 lines
10 KiB
PHP
266 lines
10 KiB
PHP
<?php
|
|
/*
|
|
* Datenbankzugriff ueber PDO.
|
|
*
|
|
* Auf dem Server MySQL/MariaDB, bei den lokalen Tests SQLite. Die Abfragen
|
|
* sind so geschrieben, dass sie auf beiden laufen; die wenigen Unterschiede
|
|
* (Tabellenanlage, Zeilensperren) stecken hier.
|
|
*/
|
|
declare(strict_types=1);
|
|
|
|
final class DB
|
|
{
|
|
private static ?PDO $pdo = null;
|
|
|
|
public static function pdo(): PDO
|
|
{
|
|
if (self::$pdo === null) {
|
|
self::$pdo = new PDO(
|
|
(string) sm_config('datenbank.dsn'),
|
|
(string) sm_config('datenbank.benutzer', ''),
|
|
(string) sm_config('datenbank.passwort', ''),
|
|
[
|
|
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
|
|
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
|
|
PDO::ATTR_EMULATE_PREPARES => false,
|
|
],
|
|
);
|
|
if (self::sqlite()) {
|
|
self::$pdo->exec('PRAGMA foreign_keys = ON');
|
|
self::$pdo->exec('PRAGMA busy_timeout = 5000');
|
|
}
|
|
}
|
|
return self::$pdo;
|
|
}
|
|
|
|
public static function sqlite(): bool
|
|
{
|
|
return str_starts_with((string) sm_config('datenbank.dsn'), 'sqlite:');
|
|
}
|
|
|
|
public static function jetzt(int $plusSekunden = 0): string
|
|
{
|
|
return gmdate('Y-m-d H:i:s', time() + $plusSekunden);
|
|
}
|
|
|
|
public static function alle(string $sql, array $werte = []): array
|
|
{
|
|
$abfrage = self::pdo()->prepare($sql);
|
|
$abfrage->execute($werte);
|
|
return $abfrage->fetchAll();
|
|
}
|
|
|
|
public static function eine(string $sql, array $werte = []): ?array
|
|
{
|
|
$abfrage = self::pdo()->prepare($sql);
|
|
$abfrage->execute($werte);
|
|
$zeile = $abfrage->fetch();
|
|
return $zeile === false ? null : $zeile;
|
|
}
|
|
|
|
public static function wert(string $sql, array $werte = []): mixed
|
|
{
|
|
$abfrage = self::pdo()->prepare($sql);
|
|
$abfrage->execute($werte);
|
|
$wert = $abfrage->fetchColumn();
|
|
return $wert === false ? null : $wert;
|
|
}
|
|
|
|
public static function ausfuehren(string $sql, array $werte = []): int
|
|
{
|
|
$abfrage = self::pdo()->prepare($sql);
|
|
$abfrage->execute($werte);
|
|
return $abfrage->rowCount();
|
|
}
|
|
|
|
public static function einfuegen(string $tabelle, array $werte): int
|
|
{
|
|
$spalten = array_keys($werte);
|
|
$sql = sprintf('INSERT INTO %s (%s) VALUES (%s)', $tabelle,
|
|
implode(', ', $spalten), implode(', ', array_fill(0, count($spalten), '?')));
|
|
self::ausfuehren($sql, array_values($werte));
|
|
return (int) self::pdo()->lastInsertId();
|
|
}
|
|
|
|
public static function aktualisieren(string $tabelle, array $werte, string $bedingung,
|
|
array $bedingungWerte): int
|
|
{
|
|
$teile = array_map(fn($spalte) => "$spalte = ?", array_keys($werte));
|
|
$sql = sprintf('UPDATE %s SET %s WHERE %s', $tabelle, implode(', ', $teile), $bedingung);
|
|
return self::ausfuehren($sql, [...array_values($werte), ...$bedingungWerte]);
|
|
}
|
|
|
|
/** Fuehrt $arbeit in einer Transaktion aus; bei einer Ausnahme wird alles zurueckgenommen. */
|
|
public static function transaktion(callable $arbeit): mixed
|
|
{
|
|
$pdo = self::pdo();
|
|
$pdo->beginTransaction();
|
|
try {
|
|
$ergebnis = $arbeit();
|
|
$pdo->commit();
|
|
return $ergebnis;
|
|
} catch (Throwable $fehler) {
|
|
$pdo->rollBack();
|
|
throw $fehler;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Zeilensperre fuer SELECT innerhalb einer Transaktion. Verhindert etwa,
|
|
* dass zwei gleichzeitige Einladungen denselben Charakter in zwei Squads
|
|
* bringen. SQLite sperrt ohnehin die ganze Datenbank beim Schreiben.
|
|
*/
|
|
public static function sperre(): string
|
|
{
|
|
return self::sqlite() ? '' : ' FOR UPDATE';
|
|
}
|
|
|
|
/** Legt fehlende Tabellen an. Gibt die Namen aller Tabellen zurueck. */
|
|
public static function schemaAnlegen(): array
|
|
{
|
|
$sqlite = self::sqlite();
|
|
$id = $sqlite ? 'INTEGER PRIMARY KEY AUTOINCREMENT' : 'INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY';
|
|
$ref = $sqlite ? 'INTEGER' : 'INT UNSIGNED';
|
|
$lang = $sqlite ? 'TEXT' : 'MEDIUMTEXT';
|
|
$ende = $sqlite ? ')' : ') ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci';
|
|
|
|
$tabellen = [
|
|
'sm_meta' => "CREATE TABLE IF NOT EXISTS sm_meta (
|
|
schluessel VARCHAR(64) NOT NULL PRIMARY KEY,
|
|
wert TEXT NULL
|
|
$ende",
|
|
'sm_nutzer' => "CREATE TABLE IF NOT EXISTS sm_nutzer (
|
|
id $id,
|
|
benutzername VARCHAR(32) NOT NULL,
|
|
benutzername_klein VARCHAR(32) NOT NULL,
|
|
email VARCHAR(191) NULL,
|
|
passwort_hash VARCHAR(255) NULL,
|
|
rolle VARCHAR(16) NOT NULL DEFAULT 'nutzer',
|
|
email_bestaetigt_am DATETIME NULL,
|
|
gesperrt TINYINT NOT NULL DEFAULT 0,
|
|
erstellt_am DATETIME NOT NULL,
|
|
letzte_anmeldung_am DATETIME NULL,
|
|
UNIQUE (benutzername_klein),
|
|
UNIQUE (email)
|
|
$ende",
|
|
'sm_token' => "CREATE TABLE IF NOT EXISTS sm_token (
|
|
id $id,
|
|
nutzer_id $ref NOT NULL,
|
|
art VARCHAR(16) NOT NULL,
|
|
token_hash CHAR(64) NOT NULL,
|
|
geraet VARCHAR(100) NULL,
|
|
erstellt_am DATETIME NOT NULL,
|
|
laeuft_ab_am DATETIME NOT NULL,
|
|
genutzt_am DATETIME NULL,
|
|
UNIQUE (token_hash),
|
|
FOREIGN KEY (nutzer_id) REFERENCES sm_nutzer (id) ON DELETE CASCADE
|
|
$ende",
|
|
'sm_squad' => "CREATE TABLE IF NOT EXISTS sm_squad (
|
|
id $id,
|
|
name VARCHAR(48) NOT NULL,
|
|
name_klein VARCHAR(48) NOT NULL,
|
|
beschreibung TEXT NULL,
|
|
fuehrer_id $ref NULL,
|
|
erstellt_am DATETIME NOT NULL,
|
|
UNIQUE (name_klein)
|
|
$ende",
|
|
'sm_charakter' => "CREATE TABLE IF NOT EXISTS sm_charakter (
|
|
id $id,
|
|
nutzer_id $ref NOT NULL,
|
|
lokale_id CHAR(32) NOT NULL,
|
|
aktennummer VARCHAR(24) NULL,
|
|
callsign VARCHAR(64) NOT NULL DEFAULT '',
|
|
vorname VARCHAR(64) NOT NULL DEFAULT '',
|
|
nachname VARCHAR(64) NOT NULL DEFAULT '',
|
|
fraktion VARCHAR(80) NOT NULL DEFAULT '',
|
|
teilstreitkraft VARCHAR(80) NOT NULL DEFAULT '',
|
|
rang VARCHAR(120) NOT NULL DEFAULT '',
|
|
verwendung VARCHAR(80) NOT NULL DEFAULT '',
|
|
status VARCHAR(20) NOT NULL DEFAULT 'aktiv',
|
|
daten $lang NOT NULL,
|
|
portraet VARCHAR(80) NULL,
|
|
squad_id $ref NULL,
|
|
squad_seit DATETIME NULL,
|
|
version INT NOT NULL DEFAULT 1,
|
|
erstellt_am DATETIME NOT NULL,
|
|
geaendert_am DATETIME NOT NULL,
|
|
UNIQUE (nutzer_id, lokale_id),
|
|
UNIQUE (aktennummer),
|
|
FOREIGN KEY (nutzer_id) REFERENCES sm_nutzer (id) ON DELETE CASCADE,
|
|
FOREIGN KEY (squad_id) REFERENCES sm_squad (id) ON DELETE SET NULL
|
|
$ende",
|
|
'sm_einladung' => "CREATE TABLE IF NOT EXISTS sm_einladung (
|
|
id $id,
|
|
squad_id $ref NOT NULL,
|
|
charakter_id $ref NOT NULL,
|
|
von_charakter_id $ref NULL,
|
|
status VARCHAR(16) NOT NULL DEFAULT 'offen',
|
|
erstellt_am DATETIME NOT NULL,
|
|
beantwortet_am DATETIME NULL,
|
|
FOREIGN KEY (squad_id) REFERENCES sm_squad (id) ON DELETE CASCADE,
|
|
FOREIGN KEY (charakter_id) REFERENCES sm_charakter (id) ON DELETE CASCADE
|
|
$ende",
|
|
'sm_versuch' => "CREATE TABLE IF NOT EXISTS sm_versuch (
|
|
id $id,
|
|
art VARCHAR(16) NOT NULL,
|
|
schluessel CHAR(64) NOT NULL,
|
|
zeit DATETIME NOT NULL
|
|
$ende",
|
|
];
|
|
foreach ($tabellen as $sql) {
|
|
self::pdo()->exec($sql);
|
|
}
|
|
|
|
// Nicht eindeutige Indizes: SQLite kennt IF NOT EXISTS, MySQL nicht
|
|
$indizes = [
|
|
['sm_charakter', 'ix_charakter_squad', 'squad_id'],
|
|
['sm_einladung', 'ix_einladung_charakter', 'charakter_id, status'],
|
|
['sm_einladung', 'ix_einladung_squad', 'squad_id, status'],
|
|
['sm_versuch', 'ix_versuch', 'art, schluessel, zeit'],
|
|
['sm_token', 'ix_token_nutzer', 'nutzer_id, art'],
|
|
];
|
|
foreach ($indizes as [$tabelle, $name, $spalten]) {
|
|
if ($sqlite) {
|
|
self::pdo()->exec("CREATE INDEX IF NOT EXISTS $name ON $tabelle ($spalten)");
|
|
} elseif (!self::wert("SELECT COUNT(*) FROM information_schema.statistics
|
|
WHERE table_schema = DATABASE() AND table_name = ? AND index_name = ?",
|
|
[$tabelle, $name])) {
|
|
self::pdo()->exec("CREATE INDEX $name ON $tabelle ($spalten)");
|
|
}
|
|
}
|
|
|
|
if (self::wert("SELECT wert FROM sm_meta WHERE schluessel = 'schema'") === null) {
|
|
self::einfuegen('sm_meta', ['schluessel' => 'schema', 'wert' => (string) self::SCHEMA]);
|
|
}
|
|
self::migrieren();
|
|
return array_keys($tabellen);
|
|
}
|
|
|
|
public const SCHEMA = 2;
|
|
|
|
/**
|
|
* Bringt eine bestehende Datenbank auf den aktuellen Stand.
|
|
*
|
|
* Laeuft von selbst bei der ersten Anfrage nach einem Update - ohne
|
|
* einrichten.php, das nach der Ersteinrichtung geloescht sein soll. Eine
|
|
* Markerdatei im Datenordner erspart danach jede weitere Abfrage.
|
|
*
|
|
* Stand 2 (1.7.0): Konten ohne E-Mail - Mitmachen nur mit dem Schluessel
|
|
* des PCs.
|
|
*/
|
|
public static function migrieren(): void
|
|
{
|
|
$marke = sm_daten_ordner() . '/schema-' . self::SCHEMA . '.ok';
|
|
if (is_file($marke)) {
|
|
return;
|
|
}
|
|
$stand = (int) (self::wert("SELECT wert FROM sm_meta WHERE schluessel = 'schema'") ?? 1);
|
|
if ($stand < 2) {
|
|
if (!self::sqlite()) {
|
|
self::pdo()->exec('ALTER TABLE sm_nutzer MODIFY email VARCHAR(191) NULL');
|
|
}
|
|
self::ausfuehren("UPDATE sm_meta SET wert = '2' WHERE schluessel = 'schema'");
|
|
}
|
|
@file_put_contents($marke, self::jetzt());
|
|
}
|
|
}
|