squad-manager/server/sva-privat/app/db.php
danny 6e4d4afc1d Server fuer Konten, Akten und Squads
PHP 8 ohne Framework unter server/: oeffentliche Einstiege fuer
sva.tyrveil.com (Schnittstelle, Konto-Links, Verwaltung, Einrichtung) und
die Logik in sva-privat neben dem Dokumentenstamm.

- Konten mit E-Mail-Bestaetigung, Anmeldung per Token, Passwort
  vergessen, Konto loeschen
- Akten auf dem Server mit serververgebener Aktennummer und
  Versionspruefung; Portraets werden neu als PNG gespeichert
- Squads mit Einladungen, Fuehrung uebergeben, Aufloesen
- Verwaltung fuer info@tyrveil.com: Nutzer, Charaktere, Squads
- Bremsen gegen Durchprobieren, Token nur als Hash, CSRF-Schutz

werkzeuge/server_test.py prueft alles lokal mit SQLite (91 Faelle).
Der Release-Bau legt dist/server und dist/sva-privat an, ohne config.php.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-13 17:50:33 +02:00

236 lines
9.3 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) NOT 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)");
}
}
self::ausfuehren('DELETE FROM sm_meta WHERE schluessel = ?', ['schema']);
self::einfuegen('sm_meta', ['schluessel' => 'schema', 'wert' => '1']);
return array_keys($tabellen);
}
}