DogFatherGitandClaude Opus 5
ac432d85e1
Filipe hat drei Sachen gemeldet. Zwei davon waren nicht das, wonach sie
aussahen.
1. "BEI DER SPICY ROLLE IST DA EIN PROBLEM" (Creator-Profil laedt nicht)
Nicht diese Seite war kaputt. In NEUN Skripten stand dieselbe Zeile
const LEITUNG = new Set(['admin', 'manager']);
und in keinem davon 'spicy'. profil.js nahm deshalb den Creator-Zweig
und lud das EIGENE Profil -- ein Spicy-Zugang ist kein Creator, also
404. Acht der neun sind nicht kaputtgegangen; sie haben sich still
falsch verhalten.
Die Liste steht jetzt EINMAL in bereiche.js. Beim Aufraeumen kamen mit
derselben Suche sechs weitere Luecken heraus, alle vom selben Typ:
* Aufgaben abbrechen -- Server UND Knopf ohne 'spicy'
* Teilen-Knopf in der Kopfleiste -- ohne 'spicy'
* Chat: die Gespraechsliste laeuft ueber eine feste Rollenfolge.
Wer nicht darin steht, taucht gar nicht auf -- eine Person, die es
fuer die anderen nicht gibt.
* Kalender: dieselbe Rollenfolge, dort landete Spicy Media durch
indexOf() === -1 ganz oben statt an ihrem Platz.
* Dashboard: "Creator anlegen" nur fuer admin/manager -- der Server
haette sie gelassen, den Knopf hat sie nie gesehen.
* Personenliste: ROLLENNAME ohne 'spicy'. Der Auffangwert
`|| p.rolle` schrieb "spicy" statt "Spicy Media" -- plausibel
genug, um jahrelang zu bleiben.
`pruef-css-klassen.mjs` verlangt jetzt, dass kein Workspace-Skript sich
wieder eine eigene Rollenliste baut. Mit Gegenprobe, dass der Sucher so
eine Liste auch wirklich findet.
2. "DIE ZAHLEN DIESE KATEGORIE NICHT SEHEN"
Kachel und Seite waren beim Anlegen der Rolle auf ["spicy","admin"]
gesetzt worden -- "dieselben Rechte ausser Automationen". Beides jetzt
auf DogFather allein.
3. "IN CIGDEMS KALENDER STEHT IMMER NOCH MEIN MANAGER MEETING"
Das war MEIN Denkfehler von heute Frueh, nicht ein vergessener Fall.
Ich hatte "geht alle an" als "kein Teilnehmer eingetragen" definiert --
also entschied der Server, was alle angeht, und nicht der, der den
Termin anlegt. Wer niemanden eintraegt, meint aber meistens nicht
"alle", sondern "mich".
Der Fall ist entfallen. Sichtbar ist ein Termin jetzt nur noch fuer
den, der ihn angelegt hat, dem er zugeordnet ist, der das Gegenueber
ist -- oder der in der Teilnehmerliste steht. Damit ist das Markieren
im Termin die einzige Antwort auf "wen geht das an": eine sichtbare
Entscheidung im Formular statt einer unsichtbaren Regel im Server.
Calls & Protokolle rufen dieselbe Funktion auf und koennen deshalb gar
nicht auseinanderlaufen -- das war Filipes vierter Wunsch, und er ist
mit derselben Zeile erledigt.
Am laufenden System als Cigdem nachgemessen: Profil laedt ("Profil:
Luna"), Zahlen-Kachel weg und Seite gesperrt, im Kalender NUR der
Termin, bei dem sie markiert ist, Calls zeigt genau denselben.
Fuenf Pruefungen auf die endgueltige Regel umgeschrieben statt
geloescht (sicht, spicy, teilnehmer, scout-zuteilung, css-klassen).
Die dritte Drehung bei scout-zuteilung steht mit allen drei Staenden
in der Akte -- eine geloeschte Pruefung hinterlaesst keine Spur davon,
dass hier einmal etwas anderes galt.
Co-Authored-By: Claude Opus 5 <[email protected]>
324 lines
16 KiB
JavaScript
324 lines
16 KiB
JavaScript
/* MEHRERE TEILNEHMER AN EINEM TERMIN
|
||
|
||
Wunsch Filipe (05.09.2026): *"wenn ich im kalender was eintrage will
|
||
ich dass ich auch 2 leute markieren kann mit denen der call ist."*
|
||
|
||
WARUM DAS EINE EIGENE PRUEFUNG BRAUCHT. An der Teilnehmerliste haengt
|
||
die SICHTBARKEIT: Wer eingetragen ist, sieht den Termin. Damit ist
|
||
jede Zeile hier gleichzeitig eine Rechteregel. Zwei Fehler waeren
|
||
moeglich, und beide fallen im Alltag nicht auf:
|
||
|
||
zu wenig Ein Eingetragener sieht seinen eigenen Termin nicht.
|
||
Er merkt es nur, wenn er ihn sucht -- und haelt es dann
|
||
fuer sein eigenes Versehen.
|
||
|
||
zu viel Jemand traegt sich in einen fremden Termin ein und macht
|
||
ihn sich damit sichtbar. Das ist ein Datenleck mit
|
||
Selbstbedienung.
|
||
|
||
Beides wird hier gemessen, nicht angenommen.
|
||
|
||
DIE ANZAHL GEHOERT IN DIE BEDINGUNG -- ein Lauf, der keinen Termin
|
||
angelegt hat, ist kein bestandener Lauf.
|
||
|
||
GEGENPROBE: Am Ende muss nachgewiesen sein, dass diese Pruefung
|
||
ueberhaupt "nicht sichtbar" erkennen kann. */
|
||
|
||
import { mkdtempSync, rmSync } from "node:fs";
|
||
import { tmpdir } from "node:os";
|
||
import { join } from "node:path";
|
||
import { heuteLokal } from "./helfer-zeit.mjs";
|
||
|
||
const ordner = mkdtempSync(join(tmpdir(), "ws-teiln-"));
|
||
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
|
||
/* Der Port muss frei sein -- sonst wird gegen einen fremden Server
|
||
gemessen. Begruendung in helfer-port.mjs. */
|
||
const { portMussFreiSein } = await import("./helfer-port.mjs");
|
||
await portMussFreiSein(4321, "die Teilnehmerpruefung");
|
||
|
||
process.env.PORT = "4321";
|
||
process.env.SITE_ACCESS_SECRET = "lokaler-test";
|
||
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
|
||
|
||
const express = (await import("express")).default;
|
||
const ec = express.response.cookie;
|
||
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
|
||
await import("./index.js");
|
||
await new Promise((r) => setTimeout(r, 900));
|
||
const BASIS = "http://127.0.0.1:4321";
|
||
|
||
let fehler = 0;
|
||
const ok = (b, t) => { console.log((b ? " ok " : " FEHL ") + t); if (!b) fehler++; };
|
||
|
||
/* ---- Bestand ------------------------------------------------------------ */
|
||
const { DatabaseSync } = await import("node:sqlite");
|
||
const { scryptSync, randomBytes } = await import("node:crypto");
|
||
await fetch(BASIS + "/workspace/api/anmelden", {
|
||
method: "POST", headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
|
||
for (let i = 0; i < 60; i++) {
|
||
try {
|
||
const p = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
try { p.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { p.close(); }
|
||
} catch { await new Promise((r) => setTimeout(r, 250)); }
|
||
}
|
||
const d = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const jetzt = new Date().toISOString();
|
||
/* ORTSZEIT, nicht UTC -- Begruendung in helfer-zeit.mjs. Mit
|
||
`jetzt.slice(0, 10)` war diese Pruefung jede Nacht zwischen 00:00
|
||
und 02:00 rot, weil sie ihre Termine auf gestern legte. */
|
||
const heute = heuteLokal();
|
||
function anlegen(name, rolle, code) {
|
||
const salt = randomBytes(16).toString("hex");
|
||
const hash = scryptSync(code, salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
|
||
d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
|
||
.run(name, rolle, hash, salt, 32768, jetzt);
|
||
return d.prepare("SELECT last_insert_rowid() AS id").get().id;
|
||
}
|
||
const idDogi = anlegen("Chef", "admin", "CODE-DOGI-0001");
|
||
const idPat = anlegen("Pat", "scout", "CODE-SCOU-0001");
|
||
const idBea = anlegen("Bea", "scout", "CODE-SCOU-0002");
|
||
const idLuna = anlegen("Luna", "creator", "CODE-CREA-0001");
|
||
const idNora = anlegen("Nora", "creator", "CODE-CREA-0002");
|
||
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idPat, jetzt);
|
||
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idNora, idBea, jetzt);
|
||
|
||
/* EIN ALTER TERMIN, angelegt wie vor der Umstellung: nur
|
||
teilnehmer_id, kein Eintrag in termin_teilnehmer. Er prueft, dass die
|
||
Uebernahme beim Start wirklich gelaufen ist. */
|
||
d.prepare(`INSERT INTO termine (titel, art, beginn, dauer_min, teilnehmer_id, erstellt, erstellt_von)
|
||
VALUES ('Alter Termin von frueher','call',?,30,?,?,?)`)
|
||
.run(heute + "T09:00", idLuna, jetzt, idDogi);
|
||
const idAlt = d.prepare("SELECT last_insert_rowid() AS id").get().id;
|
||
d.close();
|
||
|
||
async function anmelden(rolle, code) {
|
||
const a = await fetch(BASIS + "/workspace/api/anmelden", {
|
||
method: "POST", headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({ rolle, code }) });
|
||
const keks = (a.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
|
||
if (!keks) throw new Error(`Anmeldung ${rolle} fehlgeschlagen (${a.status})`);
|
||
return keks;
|
||
}
|
||
const K = {
|
||
dogi: await anmelden("admin", "CODE-DOGI-0001"),
|
||
pat: await anmelden("scout", "CODE-SCOU-0001"),
|
||
bea: await anmelden("scout", "CODE-SCOU-0002"),
|
||
luna: await anmelden("creator", "CODE-CREA-0001"),
|
||
nora: await anmelden("creator", "CODE-CREA-0002"),
|
||
};
|
||
|
||
const ruf = async (art, pfad, rumpf, keks) => {
|
||
const a = await fetch(BASIS + pfad, {
|
||
method: art,
|
||
headers: { "Content-Type": "application/json", cookie: keks, origin: BASIS },
|
||
body: rumpf === undefined ? undefined : JSON.stringify(rumpf),
|
||
});
|
||
let text = ""; try { text = await a.text(); } catch { /* egal */ }
|
||
let daten = null; try { daten = JSON.parse(text); } catch { /* kein JSON */ }
|
||
return { status: a.status, text, daten };
|
||
};
|
||
|
||
/** Sieht diese Person den Termin mit dieser Nummer? */
|
||
async function siehtTermin(keks, id) {
|
||
const a = await ruf("GET", "/workspace/api/termine?tage=30", undefined, keks);
|
||
if (a.status !== 200) return false;
|
||
return (a.daten?.termine || []).some((t) => t.id === id);
|
||
}
|
||
|
||
/* =======================================================================
|
||
1. Die Uebernahme alter Termine
|
||
======================================================================= */
|
||
console.log("\n=== Alte Termine behalten ihren Teilnehmer ===");
|
||
{
|
||
const a = await ruf("GET", "/workspace/api/termine?tage=30", undefined, K.dogi);
|
||
const alt = (a.daten?.termine || []).find((t) => t.id === idAlt);
|
||
ok(!!alt, "der alte Termin ist da");
|
||
ok(Array.isArray(alt?.teilnehmer) && alt.teilnehmer.some((p) => p.id === idLuna),
|
||
`sein Teilnehmer wurde uebernommen (${(alt?.teilnehmer || []).map((p) => p.name).join(", ") || "LEER"})`);
|
||
ok(await siehtTermin(K.luna, idAlt), "und Luna sieht ihn weiterhin");
|
||
}
|
||
|
||
/* =======================================================================
|
||
2. Zwei Teilnehmer anlegen
|
||
======================================================================= */
|
||
console.log("\n=== Ein Call mit zwei Leuten ===");
|
||
let idCall = 0;
|
||
{
|
||
const a = await ruf("POST", "/workspace/api/termine", {
|
||
titel: "Call zu dritt", art: "call", beginn: heute + "T14:00",
|
||
teilnehmer_id: idLuna, teilnehmer: [idLuna, idPat],
|
||
}, K.dogi);
|
||
ok(a.status === 201, `angelegt (${a.status})`);
|
||
idCall = a.daten?.id || 0;
|
||
ok(idCall > 0, `hat eine Nummer bekommen (#${idCall})`);
|
||
ok((a.daten?.teilnehmer || []).length === 2,
|
||
`zwei Teilnehmer gespeichert (${(a.daten?.teilnehmer || []).length})`);
|
||
|
||
const b = await ruf("GET", "/workspace/api/termine?tage=30", undefined, K.dogi);
|
||
const t = (b.daten?.termine || []).find((x) => x.id === idCall);
|
||
ok((t?.teilnehmer || []).length === 2,
|
||
`und sie kommen zurueck: ${(t?.teilnehmer || []).map((p) => p.name).join(", ") || "LEER"}`);
|
||
}
|
||
|
||
/* =======================================================================
|
||
3. BEIDE sehen den Termin — das ist der Kern
|
||
======================================================================= */
|
||
console.log("\n=== Beide Eingetragenen sehen ihn ===");
|
||
ok(await siehtTermin(K.luna, idCall), "Luna sieht den Call (Haupt-Gegenueber)");
|
||
ok(await siehtTermin(K.pat, idCall), "Pat sieht den Call (zweiter Teilnehmer)");
|
||
ok(await siehtTermin(K.dogi, idCall), "DogFather sieht ihn ohnehin");
|
||
|
||
/* =======================================================================
|
||
4. Und die anderen NICHT
|
||
======================================================================= */
|
||
console.log("\n=== Wer nicht dabei ist, sieht ihn nicht ===");
|
||
ok(!(await siehtTermin(K.nora, idCall)), "Nora (fremde Creatorin) sieht ihn nicht");
|
||
ok(!(await siehtTermin(K.bea, idCall)), "Bea (fremde Scoutin) sieht ihn nicht");
|
||
|
||
/* =======================================================================
|
||
5. Niemand traegt sich selbst in fremde Termine ein
|
||
======================================================================= */
|
||
console.log("\n=== Kein Eintragen in fremde Termine ===");
|
||
{
|
||
/* Nora versucht, sich in den Call einzutragen. Sie sieht ihn nicht --
|
||
also muss schon das Aendern scheitern (404, nicht 403: Was man
|
||
nicht sehen darf, existiert fuer einen nicht). */
|
||
const a = await ruf("PATCH", `/workspace/api/termine/${idCall}`,
|
||
{ teilnehmer: [idNora] }, K.nora);
|
||
ok(a.status === 404, `Nora aendert den fremden Call -> ${a.status} (erwartet 404)`);
|
||
ok(!(await siehtTermin(K.nora, idCall)), "und sie sieht ihn danach immer noch nicht");
|
||
|
||
/* Pat SIEHT den Call (er ist Teilnehmer). Aendert er die Liste,
|
||
darf das nichts bewirken -- Zuordnungen verschiebt nur die
|
||
Leitung. */
|
||
const b = await ruf("PATCH", `/workspace/api/termine/${idCall}`,
|
||
{ teilnehmer: [idPat, idNora] }, K.pat);
|
||
ok(b.status < 500, `Pat aendert die Liste -> ${b.status} (kein Serverfehler)`);
|
||
ok(!(await siehtTermin(K.nora, idCall)),
|
||
"Nora ist dadurch NICHT hineingekommen — ein Scout verschiebt keine Zuordnungen");
|
||
}
|
||
|
||
/* =======================================================================
|
||
6. Aendern: jemanden hinzufuegen und wieder entfernen
|
||
======================================================================= */
|
||
console.log("\n=== Hinzufuegen und Entfernen ===");
|
||
{
|
||
const a = await ruf("PATCH", `/workspace/api/termine/${idCall}`,
|
||
{ teilnehmer: [idLuna, idPat, idBea] }, K.dogi);
|
||
ok(a.status === 200, `dritte Person hinzugefuegt (${a.status})`);
|
||
ok(await siehtTermin(K.bea, idCall), "Bea sieht den Call jetzt");
|
||
|
||
const b = await ruf("PATCH", `/workspace/api/termine/${idCall}`,
|
||
{ teilnehmer: [idLuna] }, K.dogi);
|
||
ok(b.status === 200, `wieder entfernt (${b.status})`);
|
||
ok(!(await siehtTermin(K.bea, idCall)), "Bea sieht ihn nicht mehr");
|
||
ok(await siehtTermin(K.luna, idCall), "Luna weiterhin schon");
|
||
|
||
/* Das Haupt-Gegenueber bleibt drin, auch wenn die Liste es nicht
|
||
nennt -- sonst verlöre der Termin seinen eigentlichen Partner. */
|
||
const c = await ruf("PATCH", `/workspace/api/termine/${idCall}`,
|
||
{ teilnehmer: [] }, K.dogi);
|
||
ok(c.status === 200, `leere Liste geschickt (${c.status})`);
|
||
ok(await siehtTermin(K.luna, idCall),
|
||
"das Haupt-Gegenueber bleibt trotzdem eingetragen");
|
||
}
|
||
|
||
/* =======================================================================
|
||
7. Serien vererben ihre Teilnehmer
|
||
======================================================================= */
|
||
console.log("\n=== Wiederkehrende Termine ===");
|
||
{
|
||
const a = await ruf("POST", "/workspace/api/serien", {
|
||
titel: "Woechentlicher Team-Call", art: "call", takt: "woechentlich",
|
||
start_tag: heute, uhrzeit: "11:00", dauer_min: 30,
|
||
teilnehmer_id: idLuna, teilnehmer: [idLuna, idPat],
|
||
}, K.dogi);
|
||
ok(a.status === 201, `Serie angelegt (${a.status})`);
|
||
ok((a.daten?.angelegt || 0) > 1, `${a.daten?.angelegt} Termine erzeugt`);
|
||
|
||
const b = await ruf("GET", "/workspace/api/termine?tage=60", undefined, K.dogi);
|
||
const ausSerie = (b.daten?.termine || []).filter((t) => t.titel === "Woechentlicher Team-Call");
|
||
ok(ausSerie.length > 1, `${ausSerie.length} davon stehen im Kalender`);
|
||
const alleMitBeiden = ausSerie.every((t) =>
|
||
(t.teilnehmer || []).some((p) => p.id === idLuna)
|
||
&& (t.teilnehmer || []).some((p) => p.id === idPat));
|
||
ok(alleMitBeiden, "JEDE Auspraegung hat beide Teilnehmer geerbt");
|
||
|
||
const c = await ruf("GET", "/workspace/api/termine?tage=60", undefined, K.pat);
|
||
const patSieht = (c.daten?.termine || []).filter((t) => t.titel === "Woechentlicher Team-Call");
|
||
ok(patSieht.length === ausSerie.length,
|
||
`Pat sieht alle ${patSieht.length} von ${ausSerie.length} — nicht nur den ersten`);
|
||
}
|
||
|
||
/* =======================================================================
|
||
8. Unsinn in der Liste
|
||
======================================================================= */
|
||
console.log("\n=== Unsinn in der Teilnehmerliste ===");
|
||
{
|
||
for (const [wie, wert] of [
|
||
["Text statt Nummern", ["abc", "xyz"]],
|
||
["negative Nummer", [-1]],
|
||
["null", [null]],
|
||
["gar keine Liste", "keine Liste"],
|
||
["riesige Liste", Array.from({ length: 500 }, (_, i) => i + 1)],
|
||
["doppelte Eintraege", [idLuna, idLuna, idLuna]],
|
||
["Person, die es nicht gibt", [999999]],
|
||
]) {
|
||
const a = await ruf("PATCH", `/workspace/api/termine/${idCall}`,
|
||
{ teilnehmer: wert }, K.dogi);
|
||
ok(a.status < 500, `${wie} -> ${a.status} (kein Serverfehler)`);
|
||
}
|
||
ok(await siehtTermin(K.luna, idCall),
|
||
"nach all dem ist das Haupt-Gegenueber immer noch eingetragen");
|
||
}
|
||
|
||
/* =======================================================================
|
||
GEGENPROBE — kann diese Pruefung "nicht sichtbar" erkennen?
|
||
======================================================================= */
|
||
console.log("\n=== Gegenprobe ===");
|
||
{
|
||
/* SEIT DEM 07.09.2026 IST EIN TERMIN OHNE TEILNEHMER DER ÖFFENTLICHE
|
||
FALL, nicht der geheime (siehe termineSichtbar in workspace.js):
|
||
"Wer niemanden einträgt, meint alle." Hier stand deshalb vorher
|
||
das Gegenteil — ein teilnehmerloser Termin, von dem erwartet
|
||
wurde, dass Luna ihn NICHT sieht.
|
||
|
||
Für eine Gegenprobe braucht es aber weiterhin einen Termin, den
|
||
sie wirklich nicht sehen darf. Das ist jetzt der Termin MIT einem
|
||
anderen Gegenüber: eine Verabredung zwischen zwei anderen. */
|
||
const a = await ruf("POST", "/workspace/api/termine", {
|
||
titel: "Verabredung ohne Luna", art: "termin", beginn: heute + "T20:00",
|
||
teilnehmer: [idBea],
|
||
}, K.dogi);
|
||
const geheim = a.daten?.id;
|
||
ok(geheim > 0, `ein Termin mit Bea, ohne Luna, angelegt (#${geheim})`);
|
||
ok(await siehtTermin(K.dogi, geheim), "DogFather sieht ihn — er hat ihn angelegt");
|
||
ok(!(await siehtTermin(K.luna, geheim)),
|
||
"Luna sieht ihn NICHT — die Messung erkennt also 'nicht sichtbar'");
|
||
|
||
const b = await ruf("PATCH", `/workspace/api/termine/${geheim}`,
|
||
{ teilnehmer: [idBea, idLuna] }, K.dogi);
|
||
ok(b.status === 200, `Luna dazugenommen (${b.status})`);
|
||
ok(await siehtTermin(K.luna, geheim),
|
||
"jetzt sieht sie ihn — die Messung erkennt auch 'sichtbar'");
|
||
|
||
/* UND DER FALL, DER SICH AM SELBEN TAG NOCH EINMAL GEDREHT HAT:
|
||
Ein Termin OHNE Teilnehmer ist nicht „für alle", sondern privat.
|
||
Hier stand zwischenzeitlich das Gegenteil -- Filipe hat an seinem
|
||
„Manager Meeting" in Cigdems Kalender gezeigt, warum das falsch
|
||
war. Die Teilnehmerliste ist jetzt die einzige Art, jemanden zu
|
||
beteiligen; deshalb gehört genau dieser Fall hierher. */
|
||
const c = await ruf("POST", "/workspace/api/termine", {
|
||
titel: "Nur fuer mich", art: "termin", beginn: heute + "T21:30",
|
||
}, K.dogi);
|
||
ok(!(await siehtTermin(K.luna, c.daten?.id)),
|
||
"einen Termin ganz ohne Teilnehmer sieht nur, wer ihn angelegt hat");
|
||
ok(await siehtTermin(K.dogi, c.daten?.id),
|
||
" – der nämlich schon, sonst wäre die Zeile darüber wertlos");
|
||
}
|
||
|
||
console.log(`\n${fehler === 0 ? "ALLES IN ORDNUNG" : `${fehler} FEHLER`}`);
|
||
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
|
||
process.exit(fehler ? 1 : 0);
|