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>
236 lines
9.3 KiB
PHP
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);
|
|
}
|
|
}
|