squad-manager/server/sva-privat/app/charaktere.php
danny 0c7aae5b93 Abgleich der Akten mit dem Server (ohne Oberflaeche)
- konto.py: Aufrufe der Schnittstelle, Anmeldung; das Token liegt per
  DPAPI an das Windows-Konto gebunden in konto.json
- abgleich.py: gleicht lokale Akten und Server ab. server.json neben
  jeder Akte haelt den Stand des letzten Abgleichs (Pruefwert des Inhalts
  statt Zeitstempel, der nur sekundengenau ist). Konflikte sichern die
  Serverfassung als konflikt-<Zeit>.json; auf dem Server geloeschte Akten
  wandern lokal in den Papierkorb
- hintergrund.py: Netzwerkarbeit im Thread, Ergebnis im tkinter-Hauptthread
- akte_modell.speichern(zeit_setzen=False) fuer uebernommene Serverdaten
- Server liefert portraet_kennung, damit ein zweiter Rechner neue Bilder erkennt
- Tests: werkzeuge/abgleich_test.py mit zwei simulierten Rechnern (34
  Faelle); der Testserver nutzt php-cgi statt "php -S", das unter Windows
  nach vielen Verbindungen haengen bleibt

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

325 lines
14 KiB
PHP

<?php
/*
* Charaktere (Akten) auf dem Server.
*
* Die Akte selbst liegt als JSON in "daten", so wie das Programm sie
* speichert. Die Felder fuer Listen und Suche (Callsign, Rang, Status ...)
* werden beim Speichern daraus abgeleitet. Aktennummern vergibt der Server,
* damit sie ueber alle Spieler eindeutig sind.
*/
declare(strict_types=1);
final class Charaktere
{
public const MAX_JE_NUTZER = 50;
public const MAX_DATEN_BYTES = 262144;
public const MAX_BILD_BYTES = 8 * 1024 * 1024;
public const BILD_KANTE = 512;
private static function text(mixed $wert, int $max): string
{
return is_string($wert) ? mb_substr(trim($wert), 0, $max) : '';
}
/** Listenfelder aus der Akte. */
private static function felder(array $daten): array
{
$p = is_array($daten['personalien'] ?? null) ? $daten['personalien'] : [];
$d = is_array($daten['dienst'] ?? null) ? $daten['dienst'] : [];
return [
'callsign' => self::text($p['callsign'] ?? '', 64),
'vorname' => self::text($p['vorname'] ?? '', 64),
'nachname' => self::text($p['nachname'] ?? '', 64),
'fraktion' => self::text($d['fraktion'] ?? '', 80),
'teilstreitkraft' => self::text($d['teilstreitkraft'] ?? '', 80),
'rang' => self::text($d['rang'] ?? '', 120),
'verwendung' => self::text($d['verwendung'] ?? '', 80),
'status' => in_array($d['status'] ?? '', SM_STATUS, true) ? $d['status'] : 'aktiv',
];
}
private static function squadKurz(array $zeile): ?array
{
if ($zeile['squad_id'] === null) {
return null;
}
$squad = DB::eine('SELECT id, name, fuehrer_id FROM sm_squad WHERE id = ?', [$zeile['squad_id']]);
return $squad === null ? null : [
'id' => (int) $squad['id'],
'name' => $squad['name'],
'ist_fuehrer' => (int) $squad['fuehrer_id'] === (int) $zeile['id'],
];
}
/**
* Wechselt mit jedem neuen Portraet (der Dateiname ist zufaellig). Daran
* erkennt ein zweiter Rechner, dass er das Bild neu laden muss.
*/
private static function kennung(array $zeile): ?string
{
return $zeile['portraet'] === null ? null : basename((string) $zeile['portraet'], '.png');
}
/** Vollstaendige Sicht auf einen eigenen Charakter. */
public static function eigeneZeile(array $zeile): array
{
return [
'id' => (int) $zeile['id'],
'lokale_id' => $zeile['lokale_id'],
'aktennummer' => $zeile['aktennummer'],
'version' => (int) $zeile['version'],
'geaendert_am' => $zeile['geaendert_am'],
'portraet' => $zeile['portraet'] !== null,
'portraet_kennung' => self::kennung($zeile),
'squad' => self::squadKurz($zeile),
'daten' => json_decode($zeile['daten'], true) ?: new stdClass(),
];
}
/** Kurzfassung fuer die Liste aller Charaktere. $zeile braucht "spieler" aus sm_nutzer. */
public static function zusammenfassung(array $zeile, array $betrachter): array
{
return [
'id' => (int) $zeile['id'],
'aktennummer' => $zeile['aktennummer'],
'callsign' => $zeile['callsign'],
'vorname' => $zeile['vorname'],
'nachname' => $zeile['nachname'],
'rang' => $zeile['rang'],
'fraktion' => $zeile['fraktion'],
'teilstreitkraft' => $zeile['teilstreitkraft'],
'verwendung' => $zeile['verwendung'],
'status' => $zeile['status'],
'spieler' => $zeile['spieler'],
'eigener' => (int) $zeile['nutzer_id'] === (int) $betrachter['id'],
'portraet' => $zeile['portraet'] !== null,
'portraet_kennung' => self::kennung($zeile),
'squad' => self::squadKurz($zeile),
'geaendert_am' => $zeile['geaendert_am'],
];
}
public static function speichern(array $nutzer, string $lokaleId, mixed $daten,
?int $basisVersion, bool $erzwingen): array
{
if (!preg_match('/^[0-9a-f]{32}$/', $lokaleId)) {
throw new SmFehler('lokale_id_ungueltig', 'Ungültige Akten-ID.');
}
if (!is_array($daten)) {
throw new SmFehler('daten_ungueltig', 'Die Akte ist unvollständig.');
}
if (strlen((string) json_encode($daten)) > self::MAX_DATEN_BYTES) {
throw new SmFehler('akte_zu_gross', 'Die Akte ist zu groß.', 413);
}
$felder = self::felder($daten);
$nutzerId = (int) $nutzer['id'];
return DB::transaktion(function () use ($nutzerId, $lokaleId, $daten, $felder, $basisVersion, $erzwingen) {
$vorhanden = DB::eine('SELECT * FROM sm_charakter WHERE nutzer_id = ? AND lokale_id = ?'
. DB::sperre(), [$nutzerId, $lokaleId]);
if ($vorhanden !== null) {
if ($basisVersion !== null && $basisVersion !== (int) $vorhanden['version'] && !$erzwingen) {
throw new SmFehler('konflikt', 'Die Akte wurde inzwischen an anderer Stelle geändert.',
409, ['charakter' => self::eigeneZeile($vorhanden)]);
}
$id = (int) $vorhanden['id'];
$daten['aktennummer'] = $vorhanden['aktennummer'];
DB::aktualisieren('sm_charakter', $felder + [
'daten' => self::json($daten),
'version' => (int) $vorhanden['version'] + 1,
'geaendert_am' => DB::jetzt(),
], 'id = ?', [$id]);
} else {
$anzahl = (int) DB::wert('SELECT COUNT(*) FROM sm_charakter WHERE nutzer_id = ?', [$nutzerId]);
if ($anzahl >= self::MAX_JE_NUTZER) {
throw new SmFehler('zu_viele_charaktere',
'Mehr als ' . self::MAX_JE_NUTZER . ' Charaktere pro Konto sind nicht möglich.', 409);
}
$id = DB::einfuegen('sm_charakter', $felder + [
'nutzer_id' => $nutzerId,
'lokale_id' => $lokaleId,
'daten' => '{}',
'version' => 1,
'erstellt_am' => DB::jetzt(),
'geaendert_am' => DB::jetzt(),
]);
$daten['aktennummer'] = sprintf('SM-%s-%04d', gmdate('Y'), $id);
DB::aktualisieren('sm_charakter',
['aktennummer' => $daten['aktennummer'], 'daten' => self::json($daten)], 'id = ?', [$id]);
}
return self::eigeneZeile(DB::eine('SELECT * FROM sm_charakter WHERE id = ?', [$id]));
});
}
private static function json(array $daten): string
{
return json_encode($daten, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR);
}
public static function eigene(array $nutzer): array
{
$zeilen = DB::alle('SELECT * FROM sm_charakter WHERE nutzer_id = ? ORDER BY erstellt_am, id',
[$nutzer['id']]);
return array_map([self::class, 'eigeneZeile'], $zeilen);
}
private static function eigenerMitSperre(array $nutzer, string $lokaleId): array
{
$zeile = DB::eine('SELECT * FROM sm_charakter WHERE nutzer_id = ? AND lokale_id = ?' . DB::sperre(),
[$nutzer['id'], $lokaleId]);
if ($zeile === null) {
throw new SmFehler('charakter_nicht_gefunden', 'Diese Akte gibt es auf dem Server nicht.', 404);
}
return $zeile;
}
public static function loeschen(array $nutzer, string $lokaleId): void
{
DB::transaktion(function () use ($nutzer, $lokaleId) {
self::loeschenIntern(self::eigenerMitSperre($nutzer, $lokaleId));
});
}
/** Fuer die Verwaltung: Loeschen ohne Besitzpruefung. */
public static function loeschenNachId(int $id): void
{
DB::transaktion(function () use ($id) {
$zeile = DB::eine('SELECT * FROM sm_charakter WHERE id = ?' . DB::sperre(), [$id]);
if ($zeile !== null) {
self::loeschenIntern($zeile);
}
});
}
private static function loeschenIntern(array $zeile): void
{
Squads::beimLoeschen($zeile);
self::bildDateiLoeschen($zeile['portraet']);
DB::ausfuehren('DELETE FROM sm_charakter WHERE id = ?', [$zeile['id']]);
}
public static function alleVonNutzerLoeschen(int $nutzerId): void
{
foreach (DB::alle('SELECT * FROM sm_charakter WHERE nutzer_id = ?', [$nutzerId]) as $zeile) {
self::loeschenIntern($zeile);
}
}
// -- Portraets ---------------------------------------------------------
private static function bildDateiLoeschen(?string $datei): void
{
if ($datei !== null && preg_match('/^[0-9]+-[0-9a-f]{16}\.png$/', $datei)) {
@unlink(sm_daten_ordner('portraets') . '/' . $datei);
}
}
/**
* Nimmt ein Bild an und speichert es neu als PNG, hoechstens 512 Pixel.
* Das Neuzeichnen verwirft alles ausser den Bildpunkten - eingeschleuster
* Code in einer Bilddatei kommt so nicht auf den Server.
*/
public static function portraetSetzen(array $nutzer, string $lokaleId, string $base64): array
{
if (!function_exists('imagecreatefromstring')) {
throw new SmFehler('server_ohne_gd', 'Der Server kann gerade keine Bilder verarbeiten.', 500);
}
$roh = base64_decode($base64, true);
if ($roh === false || $roh === '') {
throw new SmFehler('bild_ungueltig', 'Das Bild konnte nicht gelesen werden.');
}
if (strlen($roh) > self::MAX_BILD_BYTES) {
throw new SmFehler('bild_zu_gross', 'Das Bild ist zu groß (höchstens 8 MB).', 413);
}
$info = @getimagesizefromstring($roh);
$erlaubt = [IMAGETYPE_JPEG, IMAGETYPE_PNG, IMAGETYPE_WEBP, IMAGETYPE_GIF];
if ($info === false || !in_array($info[2], $erlaubt, true)) {
throw new SmFehler('bild_ungueltig', 'Erlaubt sind JPG, PNG, WebP und GIF.');
}
if ($info[0] * $info[1] > 40_000_000) {
throw new SmFehler('bild_zu_gross', 'Das Bild hat zu viele Bildpunkte.', 413);
}
$quelle = @imagecreatefromstring($roh);
if ($quelle === false) {
throw new SmFehler('bild_ungueltig', 'Das Bild konnte nicht gelesen werden.');
}
[$breite, $hoehe] = [imagesx($quelle), imagesy($quelle)];
$faktor = min(1, self::BILD_KANTE / max($breite, $hoehe));
$nb = max(1, (int) round($breite * $faktor));
$nh = max(1, (int) round($hoehe * $faktor));
$ziel = imagecreatetruecolor($nb, $nh);
imagealphablending($ziel, false);
imagesavealpha($ziel, true);
imagefill($ziel, 0, 0, imagecolorallocatealpha($ziel, 0, 0, 0, 127));
imagecopyresampled($ziel, $quelle, 0, 0, 0, 0, $nb, $nh, $breite, $hoehe);
return DB::transaktion(function () use ($nutzer, $lokaleId, $ziel) {
$zeile = self::eigenerMitSperre($nutzer, $lokaleId);
$datei = $zeile['id'] . '-' . Sicherheit::zufall(8) . '.png';
if (!imagepng($ziel, sm_daten_ordner('portraets') . '/' . $datei, 6)) {
throw new SmFehler('bild_speichern', 'Das Bild konnte nicht gespeichert werden.', 500);
}
self::bildDateiLoeschen($zeile['portraet']);
DB::aktualisieren('sm_charakter', ['portraet' => $datei, 'geaendert_am' => DB::jetzt()],
'id = ?', [$zeile['id']]);
return self::eigeneZeile(DB::eine('SELECT * FROM sm_charakter WHERE id = ?', [$zeile['id']]));
});
}
public static function portraetEntfernen(array $nutzer, string $lokaleId): array
{
return DB::transaktion(function () use ($nutzer, $lokaleId) {
$zeile = self::eigenerMitSperre($nutzer, $lokaleId);
self::bildDateiLoeschen($zeile['portraet']);
DB::aktualisieren('sm_charakter', ['portraet' => null, 'geaendert_am' => DB::jetzt()],
'id = ?', [$zeile['id']]);
return self::eigeneZeile(DB::eine('SELECT * FROM sm_charakter WHERE id = ?', [$zeile['id']]));
});
}
/** Pfad zur Bilddatei eines Charakters oder null. */
public static function bildPfad(int $id): ?string
{
$datei = DB::wert('SELECT portraet FROM sm_charakter WHERE id = ?', [$id]);
if (!is_string($datei) || !preg_match('/^[0-9]+-[0-9a-f]{16}\.png$/', $datei)) {
return null;
}
$pfad = sm_daten_ordner('portraets') . '/' . $datei;
return is_file($pfad) ? $pfad : null;
}
// -- Fuer alle sichtbar -------------------------------------------------
private const LISTE_SQL = 'SELECT c.*, n.benutzername AS spieler
FROM sm_charakter c JOIN sm_nutzer n ON n.id = c.nutzer_id
WHERE n.gesperrt = 0';
public static function alle(array $nutzer, string $suche = '', string $fraktion = ''): array
{
$sql = self::LISTE_SQL;
$werte = [];
$suche = trim($suche);
if ($suche !== '') {
$muster = '%' . str_replace(['!', '%', '_'], ['!!', '!%', '!_'], mb_substr($suche, 0, 64)) . '%';
$sql .= " AND (c.callsign LIKE ? ESCAPE '!' OR c.vorname LIKE ? ESCAPE '!'"
. " OR c.nachname LIKE ? ESCAPE '!' OR n.benutzername LIKE ? ESCAPE '!')";
array_push($werte, $muster, $muster, $muster, $muster);
}
if (trim($fraktion) !== '') {
$sql .= ' AND c.fraktion = ?';
$werte[] = trim($fraktion);
}
$sql .= ' ORDER BY c.callsign, c.nachname, c.id LIMIT 500';
return array_map(fn($zeile) => self::zusammenfassung($zeile, $nutzer), DB::alle($sql, $werte));
}
public static function ansehen(array $nutzer, int $id): array
{
$zeile = DB::eine(self::LISTE_SQL . ' AND c.id = ?', [$id]);
if ($zeile === null) {
throw new SmFehler('charakter_nicht_gefunden', 'Diesen Charakter gibt es nicht.', 404);
}
return self::zusammenfassung($zeile, $nutzer)
+ ['daten' => json_decode($zeile['daten'], true) ?: new stdClass()];
}
}