DogFatherGit/dogfather-universe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Unterweisungen mit beidseitiger Bestaetigung - und einer echten Sperre

Browse Source 
Der Wunsch: "jeder Scout, Manager oder DogFather muss mit seinen
Creatorn die PDFs durchgehen, und beide druecken dann auf verifiziert,
so dass wir den Beweis haben -- und das ist danach auch nicht mehr zu
aendern."

Das ist kein Haekchen, das ist ein NACHWEIS. Wer so etwas baut, muss
drei Fragen beantworten, sonst ist er wertlos:

WER hat bestaetigt? Beide Seiten getrennt, mit Name, Zeitpunkt und IP.
Eine einzelne Bestaetigung reicht nicht -- "ich habe es ihm gezeigt" und
"er hat es mir gezeigt" sind zwei verschiedene Aussagen, und erst
zusammen ergeben sie einen Beweis. Bestaetigt nur einer, steht die
Unterweisung sichtbar als HALB da, in einer eigenen warnenden Farbe.
Diese Zwischenstufe sichtbar zu machen ist der Punkt: Ein Nachweis, bei
dem nur einer unterschrieben hat, sieht sonst aus wie fertig -- und man
merkt es erst, wenn jemand danach fragt.

WORAUF genau? Nicht auf "die Regeln", sondern auf eine bestimmte Datei.
Beim Bestaetigen wird der SHA-256 der PDF-Datei mitgespeichert. Tauscht
spaeter jemand die Datei aus, passt der Fingerabdruck nicht mehr, und
die Seite sagt das auch ("Das Dokument wurde seit der Bestaetigung
ausgetauscht"). Ohne diesen Wert waere die Bestaetigung ein Zettel ohne
Bezug.

IST ES UNVERAENDERT? Eine abgeschlossene Bestaetigung laesst sich nicht
mehr aendern und nicht loeschen -- und zwar nicht, weil der Code es
nicht anbietet, sondern weil die DATENBANK es ablehnt. Zwei Trigger mit
RAISE(ABORT). Ein Schutz, der nur im Code steht, ist beim naechsten
neuen Weg zur Datenbank wieder weg.

DER VOLLZUG WURDE DURCHGESPIELT. Aus RunOne stammt die Lehre, dass ein
Weg, den man nicht rueckgaengig machen kann, tagelang live sein und NIE
gelaufen sein kann. Die Pruefung bestaetigt deshalb wirklich, schliesst
ab, und versucht dann eine Aenderung -- ueber die Schnittstelle UND
direkt auf der Datenbank. Beide werden abgelehnt.

Und die GEGENPROBE dazu: Der Trigger wird entfernt, dieselbe Aenderung
versucht -- sie geht durch -- und der Trigger wieder gesetzt. Eine
Sperre, die man nicht hat scheitern sehen, ist keine Sperre.

Der Server entscheidet anhand der ROLLE, welche Seite gesetzt wird --
nicht der Absender. Sonst koennte ein Creator die Bestaetigung seines
Betreuers eintragen, und der ganze Nachweis waere wertlos. Eine bereits
gesetzte Seite wird nie ueberschrieben; ein Datum laesst sich also auch
nicht nachtraeglich verschieben.

Die Dokumente kommen aus der Wissens-Bibliothek, es gibt keinen zweiten
Upload-Weg. Sonst gaebe es Dateien, die nur hier existieren -- und
niemand wuesste, welche Fassung die richtige ist. Eine Unterweisung wird
nie geloescht, nur abgeschaltet: Die Nachweise haengen daran.

EIN EIGENER FEHLER, VON DER BROWSERPRUEFUNG GEFUNDEN: Der Aufruf der
Zusatzbloecke stand NACH einem return. laden() steigt frueh aus, wenn
die Liste leer ist -- und dann wurden Vorlagen und Unterweisungen nie
gebaut. Also ausgerechnet auf der leeren Seite, fuer die sie gedacht
sind. Jetzt stehen sie in einem finally.

Co-Authored-By: Claude Opus 5 <[email protected]>
This commit is contained in:
DogFatherGit
2026-09-01 16:39:00 +02:00
co-authored by Claude Opus 5
parent ca10479909
commit 5960f6e3c4
24 changed files with 1287 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/workspace-schulung.js
+412
View File
@@ -0,0 +1,412 @@
/* =====================================================================
workspace-schulung.js — Unterweisungen mit beidseitiger Bestätigung.
Der Wunsch vom 01.09.2026: "jeder Scout, Manager oder DogFather muss
mit seinen Creatorn die PDFs durchgehen, und beide drücken dann auf
verifiziert, so dass wir den Beweis haben – und das ist danach auch
nicht mehr zu ändern."
Das ist kein Häkchen, das ist ein NACHWEIS. Wer so etwas baut, muss
drei Fragen beantworten, sonst ist er wertlos:
1. WER hat bestätigt?
Beide Seiten getrennt, mit Name, Zeitpunkt und IP. Eine einzelne
Bestätigung reicht nicht: "Ich habe es ihm gezeigt" und "Er hat es
mir gezeigt" sind zwei verschiedene Aussagen, und erst zusammen
ergeben sie einen Beweis. Bestätigt nur einer, steht die
Unterweisung als OFFEN da -- halbe Nachweise gibt es nicht.
2. WORAUF genau?
Nicht auf "die Regeln", sondern auf eine bestimmte Datei. Deshalb
wird beim Bestätigen der SHA-256 der PDF-Datei mitgespeichert.
Tauscht später jemand die Datei aus, passt der Fingerabdruck nicht
mehr -- und die Seite sagt das auch. Ohne diesen Wert wäre die
Bestätigung ein Zettel ohne Bezug.
3. IST ES UNVERÄNDERT?
Eine abgeschlossene Bestätigung lässt sich nicht mehr ändern und
nicht löschen -- und zwar nicht, weil der Code es nicht anbietet,
sondern weil die DATENBANK es ablehnt. Zwei Trigger sorgen dafür.
Ein Schutz, der nur im Code steht, ist beim nächsten neuen Weg zur
Datenbank wieder weg.
Erfahrung aus RunOne (01.09.2026): Dort war die Festschreibung tagelang
live und NIE gelaufen -- null festgeschriebene Buchungen. Der zentrale
Weg war unerprobt, ausgerechnet der einzige, den man nicht rückgängig
machen kann. Deshalb prüft pruef-schulung.mjs hier ausdrücklich den
Vollzug: bestätigen, dann Änderung versuchen, und die Ablehnung
nachweisen.
===================================================================== */
import express from "express";
import { createHash } from "node:crypto";
import { join } from "node:path";
import { readFileSync, existsSync } from "node:fs";
import {
db, sitzungLesen, istLeitung, istDogFather, darfCreator, betreuteIds,
protokolliere, echteIp, DATEN_ORDNER,
} from "./workspace.js";
export const schulungRouter = express.Router();
const jetzt = () => new Date().toISOString();
const TITEL_MAX = 160;
/* ---------- Tabellen ------------------------------------------------------
Werden beim ersten Zugriff angelegt. Die Trigger stehen bewusst hier
und nicht in einer Umstellung: Sie gehören zur Tabelle wie ihre
Spalten. */
let bereit = false;
function tabellen() {
if (bereit) return;
db().exec(`
/* Eine Unterweisung: ein Dokument, das durchgegangen werden muss. */
CREATE TABLE IF NOT EXISTS schulungen (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titel TEXT NOT NULL,
beschreibung TEXT,
wissen_id INTEGER REFERENCES wissen(id) ON DELETE SET NULL,
pflicht INTEGER NOT NULL DEFAULT 1,
aktiv INTEGER NOT NULL DEFAULT 1,
erstellt TEXT NOT NULL,
erstellt_von INTEGER REFERENCES personen(id) ON DELETE SET NULL
);
/* Eine Bestätigung je Creator und Unterweisung.
Zwei Seiten, zwei Zeitpunkte. Erst wenn beide stehen, gilt sie --
abgeschlossen = 1 setzt der Server, nicht der Absender. */
CREATE TABLE IF NOT EXISTS schulung_bestaetigt (
id INTEGER PRIMARY KEY AUTOINCREMENT,
schulung_id INTEGER NOT NULL REFERENCES schulungen(id) ON DELETE CASCADE,
creator_id INTEGER NOT NULL REFERENCES personen(id) ON DELETE CASCADE,
betreuer_id INTEGER REFERENCES personen(id) ON DELETE SET NULL,
creator_am TEXT,
creator_ip TEXT,
betreuer_am TEXT,
betreuer_ip TEXT,
/* Fingerabdruck der Datei zum Zeitpunkt der Bestätigung. */
datei_hash TEXT,
/* Wie die Datei damals hiess -- fuer den Fall, dass sie spaeter
umbenannt oder ersetzt wird. */
datei_name TEXT,
abgeschlossen INTEGER NOT NULL DEFAULT 0,
abgeschlossen_am TEXT,
UNIQUE (schulung_id, creator_id)
);
CREATE INDEX IF NOT EXISTS idx_schulung_creator
ON schulung_bestaetigt (creator_id);
/* DIE SPERRE.
Eine abgeschlossene Bestätigung ist ein Nachweis. Sie zu ändern
hiesse, den Nachweis zu fälschen -- also lehnt die Datenbank es
ab, ganz gleich, wer es versucht und über welchen Weg.
RAISE(ABORT) bricht die Anweisung ab und gibt den Text zurück.
Das gilt auch für ein sqlite3 auf der Kommandozeile. */
CREATE TRIGGER IF NOT EXISTS schulung_nicht_aendern
BEFORE UPDATE ON schulung_bestaetigt
FOR EACH ROW WHEN OLD.abgeschlossen = 1
BEGIN
SELECT RAISE(ABORT, 'Abgeschlossene Bestaetigung kann nicht geaendert werden');
END;
CREATE TRIGGER IF NOT EXISTS schulung_nicht_loeschen
BEFORE DELETE ON schulung_bestaetigt
FOR EACH ROW WHEN OLD.abgeschlossen = 1
BEGIN
SELECT RAISE(ABORT, 'Abgeschlossene Bestaetigung kann nicht geloescht werden');
END;
`);
bereit = true;
}
/* ---------- Fingerabdruck der Datei -------------------------------------- */
function dateiHash(wissenId) {
if (!wissenId) return { hash: null, name: null };
try {
const w = db().prepare("SELECT name_datei, name_original FROM wissen WHERE id = ?").get(wissenId);
if (!w) return { hash: null, name: null };
const pfad = join(DATEN_ORDNER, "wissen", w.name_datei);
if (!existsSync(pfad)) return { hash: null, name: w.name_original };
return {
hash: createHash("sha256").update(readFileSync(pfad)).digest("hex"),
name: w.name_original,
};
} catch {
return { hash: null, name: null };
}
}
/* ---------- Schranken ----------------------------------------------------- */
function angemeldet(req, res, next) {
const person = sitzungLesen(req);
if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
req.person = person;
try { tabellen(); } catch (f) {
console.error("[workspace] Schulungstabellen:", f?.message);
return res.status(503).json({ fehler: "nicht_verfuegbar" });
}
next();
}
schulungRouter.use("/workspace/api/schulung", angemeldet);
function gleicheHerkunft(req, res, next) {
const herkunft = req.get("origin");
if (!herkunft) return next();
let erlaubt;
try { erlaubt = new URL(herkunft).host === req.get("host"); } catch { erlaubt = false; }
if (!erlaubt) return res.status(403).json({ fehler: "fremde_herkunft" });
next();
}
/* ---------- Lesen ---------------------------------------------------------
Ein Creator sieht SEINEN Stand. Ein Betreuer sieht den Stand der
Creator, die er betreut. Die Leitung sieht alles. */
schulungRouter.get("/workspace/api/schulung", (req, res) => {
try {
const schulungen = db().prepare(`
SELECT s.*, w.name_original AS datei, w.id AS wissen,
p.name AS von
FROM schulungen s
LEFT JOIN wissen w ON w.id = s.wissen_id
LEFT JOIN personen p ON p.id = s.erstellt_von
WHERE s.aktiv = 1
ORDER BY s.pflicht DESC, s.id`).all();
/* Fuer welche Creator wird der Stand gebraucht? */
let creatorIds;
if (req.person.rolle === "creator") creatorIds = [req.person.id];
else if (istLeitung(req.person)) {
creatorIds = db().prepare(
"SELECT id FROM personen WHERE rolle = 'creator' AND aktiv = 1").all().map((z) => z.id);
} else creatorIds = betreuteIds(req.person);
const stand = creatorIds.length
? db().prepare(`
SELECT b.*, pc.name AS creator_name, pb.name AS betreuer_name
FROM schulung_bestaetigt b
LEFT JOIN personen pc ON pc.id = b.creator_id
LEFT JOIN personen pb ON pb.id = b.betreuer_id
WHERE b.creator_id IN (${creatorIds.map(() => "?").join(",")})`).all(...creatorIds)
: [];
/* Stimmt die Datei noch mit dem ueberein, was bestaetigt wurde?
Diese Frage stellt sonst niemand -- und sie ist der Unterschied
zwischen einem Nachweis und einem Zettel. */
for (const b of stand) {
if (!b.abgeschlossen || !b.datei_hash) { b.datei_stimmt = null; continue; }
const s = schulungen.find((x) => x.id === b.schulung_id);
const aktuell = dateiHash(s?.wissen_id);
b.datei_stimmt = aktuell.hash ? aktuell.hash === b.datei_hash : null;
}
const creatoren = creatorIds.length
? db().prepare(`SELECT id, name FROM personen
WHERE id IN (${creatorIds.map(() => "?").join(",")}) ORDER BY name`).all(...creatorIds)
: [];
res.json({
schulungen, stand, creatoren,
ich: { id: req.person.id, rolle: req.person.rolle },
darf_anlegen: istLeitung(req.person),
});
} catch (fehler) {
console.error("[workspace] Schulungen lesen:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* ---------- Anlegen (nur Leitung) ----------------------------------------- */
schulungRouter.post("/workspace/api/schulung", gleicheHerkunft,
express.json({ limit: "16kb" }), (req, res) => {
if (!istLeitung(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
try {
const titel = String(req.body.titel ?? "").trim();
if (titel.length < 3 || titel.length > TITEL_MAX) {
return res.status(400).json({ fehler: "Titel fehlt oder ist zu lang." });
}
const wissenId = Number(req.body.wissen_id) || null;
/* Ohne Dokument keine Unterweisung: Man kann nichts bestaetigen,
was man nicht gelesen hat. */
if (!wissenId) return res.status(400).json({ fehler: "Bitte ein Dokument auswählen." });
const da = db().prepare("SELECT id FROM wissen WHERE id = ?").get(wissenId);
if (!da) return res.status(400).json({ fehler: "Dieses Dokument gibt es nicht." });
db().prepare(`INSERT INTO schulungen
(titel, beschreibung, wissen_id, pflicht, erstellt, erstellt_von)
VALUES (?,?,?,?,?,?)`)
.run(titel, String(req.body.beschreibung ?? "").trim().slice(0, 2000) || null,
wissenId, req.body.pflicht === false ? 0 : 1, jetzt(), req.person.id);
protokolliere("schulung_angelegt", req.person, echteIp(req), titel);
res.json({ ok: true });
} catch (fehler) {
console.error("[workspace] Schulung anlegen:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* ---------- Bestätigen -----------------------------------------------------
Beide Seiten getrennt. Der Server entscheidet anhand der ROLLE des
Absenders, welche Seite gesetzt wird -- nicht der Absender selbst.
Sonst könnte ein Creator die Bestätigung seines Betreuers eintragen,
und der ganze Nachweis wäre wertlos. */
schulungRouter.post("/workspace/api/schulung/:id(\\d+)/bestaetigen", gleicheHerkunft,
express.json({ limit: "8kb" }), (req, res) => {
try {
const schulungId = Number(req.params.id);
const s = db().prepare("SELECT * FROM schulungen WHERE id = ? AND aktiv = 1").get(schulungId);
if (!s) return res.status(404).json({ fehler: "nicht_gefunden" });
/* Um welchen Creator geht es? */
const creatorId = req.person.rolle === "creator"
? req.person.id
: Number(req.body.creator_id) || 0;
if (!creatorId) return res.status(400).json({ fehler: "Kein Creator angegeben." });
if (req.person.rolle !== "creator" && !darfCreator(req.person, creatorId)) {
return res.status(404).json({ fehler: "nicht_gefunden" });
}
/* Ein Creator bestätigt nur für sich. */
if (req.person.rolle === "creator" && creatorId !== req.person.id) {
return res.status(403).json({ fehler: "nicht_erlaubt" });
}
const vorhanden = db().prepare(
"SELECT * FROM schulung_bestaetigt WHERE schulung_id = ? AND creator_id = ?")
.get(schulungId, creatorId);
if (vorhanden?.abgeschlossen) {
return res.status(409).json({
fehler: "Diese Unterweisung ist bereits abgeschlossen und kann nicht geändert werden.",
});
}
const alsCreator = req.person.rolle === "creator";
const ip = echteIp(req);
const nun = jetzt();
if (!vorhanden) {
const abdruck = dateiHash(s.wissen_id);
db().prepare(`INSERT INTO schulung_bestaetigt
(schulung_id, creator_id, betreuer_id, creator_am, creator_ip,
betreuer_am, betreuer_ip, datei_hash, datei_name, abgeschlossen)
VALUES (?,?,?,?,?,?,?,?,?,0)`)
.run(schulungId, creatorId,
alsCreator ? null : req.person.id,
alsCreator ? nun : null, alsCreator ? ip : null,
alsCreator ? null : nun, alsCreator ? null : ip,
abdruck.hash, abdruck.name);
} else {
/* Die jeweils andere Seite ergänzen. Eine bereits gesetzte Seite
wird NICHT überschrieben -- sonst könnte man ein Datum
nachträglich verschieben. */
if (alsCreator) {
if (vorhanden.creator_am) {
return res.status(409).json({ fehler: "Du hast bereits bestätigt." });
}
db().prepare(
"UPDATE schulung_bestaetigt SET creator_am = ?, creator_ip = ? WHERE id = ?")
.run(nun, ip, vorhanden.id);
} else {
if (vorhanden.betreuer_am) {
return res.status(409).json({ fehler: "Die Betreuung hat bereits bestätigt." });
}
db().prepare(
"UPDATE schulung_bestaetigt SET betreuer_am = ?, betreuer_ip = ?, betreuer_id = ? WHERE id = ?")
.run(nun, ip, req.person.id, vorhanden.id);
}
}
/* Abschliessen, sobald BEIDE stehen. Das entscheidet der Server
anhand der Daten -- niemand kann "abgeschlossen" mitschicken. */
const stand = db().prepare(
"SELECT * FROM schulung_bestaetigt WHERE schulung_id = ? AND creator_id = ?")
.get(schulungId, creatorId);
if (stand.creator_am && stand.betreuer_am && !stand.abgeschlossen) {
db().prepare(
"UPDATE schulung_bestaetigt SET abgeschlossen = 1, abgeschlossen_am = ? WHERE id = ?")
.run(nun, stand.id);
protokolliere("schulung_abgeschlossen", req.person, ip,
`${s.titel} · Creator ${creatorId}`);
} else {
protokolliere("schulung_bestaetigt", req.person, ip,
`${s.titel} · ${alsCreator ? "Creator" : "Betreuung"}`);
}
const neu = db().prepare(
"SELECT * FROM schulung_bestaetigt WHERE schulung_id = ? AND creator_id = ?")
.get(schulungId, creatorId);
res.json({ stand: neu });
} catch (fehler) {
console.error("[workspace] Schulung bestätigen:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* ---------- Zurückziehen (nur solange NICHT abgeschlossen) ---------------- */
schulungRouter.delete("/workspace/api/schulung/:id(\\d+)/bestaetigen", gleicheHerkunft,
(req, res) => {
try {
const schulungId = Number(req.params.id);
const creatorId = req.person.rolle === "creator"
? req.person.id : Number(req.query.creator_id) || 0;
if (!creatorId) return res.status(400).json({ fehler: "Kein Creator angegeben." });
if (req.person.rolle !== "creator" && !darfCreator(req.person, creatorId)) {
return res.status(404).json({ fehler: "nicht_gefunden" });
}
const stand = db().prepare(
"SELECT * FROM schulung_bestaetigt WHERE schulung_id = ? AND creator_id = ?")
.get(schulungId, creatorId);
if (!stand) return res.status(404).json({ fehler: "nicht_gefunden" });
/* Der Trigger würde das ohnehin ablehnen. Die Prüfung hier ist
trotzdem richtig: Sie gibt eine verständliche Antwort statt
eines Datenbankfehlers. */
if (stand.abgeschlossen) {
return res.status(409).json({
fehler: "Abgeschlossen. Das ist der Nachweis und bleibt bestehen.",
});
}
db().prepare("DELETE FROM schulung_bestaetigt WHERE id = ?").run(stand.id);
protokolliere("schulung_zurueckgezogen", req.person, echteIp(req), `Schulung ${schulungId}`);
res.json({ ok: true });
} catch (fehler) {
console.error("[workspace] Schulung zurückziehen:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* ---------- Unterweisung abschalten (nur DogFather) -----------------------
Nicht löschen: Die Bestätigungen daran hängen und sind Nachweise.
`aktiv = 0` nimmt sie aus der Liste, ohne die Vergangenheit
anzutasten. */
schulungRouter.delete("/workspace/api/schulung/:id(\\d+)", gleicheHerkunft, (req, res) => {
if (!istDogFather(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
try {
db().prepare("UPDATE schulungen SET aktiv = 0 WHERE id = ?").run(Number(req.params.id));
protokolliere("schulung_abgeschaltet", req.person, echteIp(req), `Schulung ${req.params.id}`);
res.json({ ok: true });
} catch (fehler) {
console.error("[workspace] Schulung abschalten:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});