DogFatherGitandClaude Opus 5
ad47fc2b00
DER GRUND JEDER KACHEL IM HAUS VON TEAM DOGI
Filipe: "ich will dass die hintergrunde von den kacheln immer unviersum
artig ist, es muss richtig geil sein aber immer so dass man alles noch
gut erkkent. und das IN DER GANZEN WEBSITE VON TEAM DOGI. nur die
kacheln. [...] wichtig ist die form der kacheln soll gleich bleiben."
module.css hat eine kanonische KACHELLISTE -- 48 Klassen, siebenmal in
der Datei, von pruef-css-klassen gegeneinander gehalten. Eine achte
Abschrift in crew-haus.css waere die Sorte Fehler, die nicht auffaellt:
heute vollstaendig, bei der naechsten neuen Kachel lautlos nicht mehr.
Deshalb faerbt crew-haus.css keine einzige Kachel. module.css baut den
Grund jetzt aus vier Werten (--sternenfeld, -mass, -lage,
--modul-schleier), und das zweite Haus setzt nur diese vier um. Damit
hat jede Kachel der ganzen Adresse den Himmel -- auch die, die es noch
nicht gibt. Im Agenturhaus steht `none`: kein Pixel aendert sich.
ZWEI DINGE HAT ERST DIE MESSUNG GEFUNDEN, NICHT DAS NACHDENKEN:
1. Die Nebel standen zuerst oben links. Dort ist aber JEDE Kachel dieses
Hauses schon von sich aus am hellsten -- ihr eigener Lichtverlauf
laeuft bei allen aus derselben Richtung (155/150/158 Grad) --, und
genau dort stehen ueberall die Ueberschriften. Hinter der leisesten
Textzeile lagen dadurch 2,09 % der Bildpunkte unter 4,5:1; im
Agenturhaus sind es an derselben Stelle 0,115 %. Nach dem Umzug in
die beiden gegenueberliegenden Ecken: 0,22 % -- und der Nebel durfte
dabei KRAEFTIGER werden (.80 statt .62), weil er nicht mehr auf dem
hellsten Punkt liegt. Besser lesbar und deutlicher zu sehen; das ist
selten und war hier umsonst zu haben.
2. Kleinere, dafuer hellere Sternkerne waren der falsche Weg: Der
hellste Punkt blieb fast gleich, der Stern wurde nur unschaerfer.
Entschieden hat die Deckkraft, nicht die Groesse.
Form unangetastet: Fase, Silhouette und die drei Eckwinkel werden vor
und nach dem Hauswechsel Zeichen fuer Zeichen verglichen.
pruef-kachel-universum.mjs (NEU, 37 Pruefungen, Port 4391) misst an
echten Bildpunkten und fragt nicht nach Durchschnitt allein, sondern
nach dem ANTEIL der Punkte unter 4,5:1 -- das unterscheidet einen Punkt
von einer Flaeche. Zwei Gegenproben: ein zu dunkler Text UND ein zu
heller Nebel muessen durchfallen.
MEINE SICHT -- "GENAU SO WIE SIE ES SEHEN"
Filipe: "oben bei meine sicht soll ich auch die sicht von allen jeden
moment sehen koennen und das genau genau so wie sie es sehen alles.
ausser die kalender daten oder chat daten wo ich nicht mit drin bin.."
Gemessen wurde nicht "mit Umschalter gegen ohne" -- das ist bei duenner
Datenlage ueberall gleich und beweist nichts. Gemessen wurde die
Antwort mit Umschalter gegen die Antwort, die die Person SELBST bekommt.
Das hat sechs Stellen gefunden:
* workspace-zentrale.js las `req.person.sicht` -- ein Feld, das es nicht
gibt. Der Ausdruck war immer `undefined || req.person`, daneben ein
ausfuehrlicher Kommentar, der genau das Richtige beschrieb. Die grosse
Kachel zeigte verlaesslich die eigene Lage, waehrend die Zahlen
darunter der fremden folgten -- zwei Wahrheiten in einer Kachel. Ein
Tippfehler in einem Variablennamen macht nichts kaputt; er tut nur
nichts, und genau deshalb faellt so etwas nie von selbst auf. Die
Route hatte ausserdem ZWEI Personenvariablen; jetzt hat sie eine.
* sichtPerson() gab die angesehene Person ohne Feld `haus` zurueck --
und nurHaus()/hausBedingung() fangen beide mit `haus !== "crew"` an.
Jede fremde Sicht war damit eine Agentursicht: In der Sicht auf einen
Modi kamen die Dateien, Personen und Berichte des anderen Hauses.
Das Haus haengt jetzt an der ROLLE, nicht an der Adresse.
* leistung, profil, schulung, fruehwarnung, report und teamlage lasen
weiterhin den Angemeldeten. Nur LESEN ist umgestellt, nie ein Recht --
und weil DogFather ohnehin alles sehen darf, kann das nichts oeffnen,
nur weniger zeigen.
Der Sicht-Umschalter zeichnete ausserdem nur die fuenf Rollen aus
bereiche.js; wer eine sechste hat, stand nicht darin. Dieselbe Luecke
wie in der Chat-Auswahl und der Personenliste, zum dritten Mal. Die
Ueberschrift kommt jetzt vom Server (`gruppe`), der Browser zeichnet,
was ankommt -- auch eine Rolle, deren Namen er nicht kennen darf.
DREI STELLEN FOLGEN BEWUSST NICHT: die Personenliste (aus ihr wird der
Umschalter gebaut -- folgte sie der Sicht, kaeme man aus einer fremden
nicht mehr heraus), die Auswahllisten beim Anlegen (Kategorien,
Empfaenger) und steckbrief/mein (ein Formular, das fremd liest und
eigen speichert, zerstoert Daten).
KALENDER UND CHAT BLEIBEN PRIVAT, auch mit Umschalter -- Termine,
Calls und Wiederholungen lesen ab jetzt immer die eigene Person. Eine
Pruefung musste dafuer umgedreht werden: pruef-sicht verlangte bis
heute das Gegenteil ("dafuer gibt es den Umschalter"). Die Gegenprobe
bleibt dieselbe Frage, nur andersherum -- Patrick selbst MUSS seine
Termine sehen, sonst hiesse "DogFather sieht sie nicht" nur, dass sie
niemand sieht. Dabei fiel auf, dass die Managerin gar keinen Call
hatte: Die Pruefung "bleibt privat" war nicht bestanden, sondern nicht
durchfuehrbar. Antwort darauf sind Daten, keine weichere Bedingung.
Gruen: pruef-sicht 84 (vorher 53), pruef-kachel-universum 37 (neu),
pruef-rollen 282, pruef-crew-adresse 129, pruef-start-ansicht 143,
pruef-kalender 104, pruef-haus-trennung 62, pruef-team-ampel 32,
pruef-team-stufen 26, pruef-css-klassen. Stempel 202609110209.
Co-Authored-By: Claude Opus 5 <[email protected]>
642 lines
31 KiB
JavaScript
642 lines
31 KiB
JavaScript
/* Prueft "die Sicht eines anderen" — DogFathers Umschalter.
|
||
|
||
Wunsch vom 01.09.2026: "ich will alles von den Scouts und Managern
|
||
einsehen koennen, auswaehlen, was und von wem ich sehen will. Und das
|
||
soll ich als DogFather-Rolle ueberall haben, auf jeder Seite.
|
||
NUR WIR BEIDE SOLLEN DIESE OPTION HABEN."
|
||
|
||
DAS HIER IST EINE RECHTEPRUEFUNG, keine Bedienpruefung. Wenn etwas
|
||
davon nicht stimmt, kann ein Manager oder Scout durch Anhaengen von
|
||
?sicht=<Nummer> in fremde Bereiche sehen. Deshalb steht der Missbrauch
|
||
VOR der Funktion:
|
||
|
||
1. Ein Scout haengt ?sicht=<DogFather> an -> muss ignoriert werden
|
||
2. Ein Manager haengt ?sicht=<Creator> an -> muss ignoriert werden
|
||
3. Ein Creator haengt ?sicht=<Scout> an -> muss ignoriert werden
|
||
4. DogFather haengt eine erfundene Nummer an -> eigene Sicht
|
||
5. DogFather waehlt einen Scout -> sieht dessen Liste
|
||
|
||
Und, genauso wichtig: SCHREIBEN passiert immer im eigenen Namen. Ein
|
||
Eintrag, der unter fremdem Namen im Protokoll landet, waere schlimmer
|
||
als gar keine Funktion. */
|
||
|
||
import { mkdtempSync, rmSync } from "node:fs";
|
||
import { tmpdir } from "node:os";
|
||
import { join } from "node:path";
|
||
|
||
const ordner = mkdtempSync(join(tmpdir(), "ws-sicht-"));
|
||
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
|
||
process.env.PORT = "4215";
|
||
process.env.SITE_ACCESS_SECRET = "lokaler-test";
|
||
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
|
||
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 }); };
|
||
import { notbremse } from "./helfer-notbremse.mjs";
|
||
await import("./index.js");
|
||
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
|
||
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
|
||
richtig fuer den Betrieb, fatal fuer eine Pruefung. Ohne diese
|
||
Zeile bleibt der Prozess nach einem Fehler ewig stehen, weil der
|
||
Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
|
||
notbremse(480_000, "pruef-sicht");
|
||
await new Promise((r) => setTimeout(r, 700));
|
||
const BASIS = "http://127.0.0.1:4215";
|
||
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();
|
||
|
||
/* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des
|
||
Benutzers; toISOString() liefert dagegen UTC und damit zwischen
|
||
Mitternacht und 2 Uhr den VORTAG. In diesem Fenster schlug diese
|
||
Pruefung fehl, ohne dass etwas kaputt war. */
|
||
const tagText = (d = new Date()) =>
|
||
`${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`
|
||
+ `-${String(d.getDate()).padStart(2, "0")}`;
|
||
|
||
let fehler = 0;
|
||
const ok = (b, t) => { console.log((b ? " ok " : " FEHL ") + t); if (!b) fehler++; };
|
||
|
||
await fetch(BASIS + "/workspace/api/anmelden", {
|
||
method: "POST", headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
|
||
|
||
const { DatabaseSync } = await import("node:sqlite");
|
||
const { scryptSync, randomBytes } = await import("node:crypto");
|
||
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();
|
||
const heute = tagText();
|
||
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("Filipe", "admin", "CODE-DOGI-0001");
|
||
/* SPICY MEDIA GEHOERT DAZU (09.09.2026).
|
||
|
||
Filipe: "ich will da auch noch die spicy rolle sehen und die leute in
|
||
der rolle wie die anderen."
|
||
|
||
Der Umschalter fuehrte eine EIGENE Rollenliste -- vier Eintraege, und
|
||
Spicy Media fehlte. Ohne eine Spicy-Person in diesen Testdaten waere
|
||
das nie aufgefallen: Eine Rolle ohne Leute wird ohnehin weggelassen,
|
||
und die Pruefung darunter haette weiter brav "Manager, Scouts,
|
||
Creator" bestaetigt. */
|
||
const idSpicy = anlegen("Cigdem", "spicy", "CODE-SPIC-0001");
|
||
const idMgr = anlegen("Mara", "manager", "CODE-MANA-0001");
|
||
const idPat = anlegen("Patrick", "scout", "CODE-SCOU-0001");
|
||
const idBen = anlegen("Ben", "scout", "CODE-SCOB-0001");
|
||
const idTili = anlegen("Tili", "creator", "CODE-ANNA-0001");
|
||
const idLuna = anlegen("Luna", "creator", "CODE-LUNA-0001");
|
||
/* Patrick betreut Tili, Ben betreut Luna -- so haben die beiden Scouts
|
||
wirklich VERSCHIEDENE Arbeitsplaetze. Ohne das koennte die Pruefung
|
||
nicht unterscheiden, ob umgeschaltet wurde oder ob beide dasselbe
|
||
sehen. */
|
||
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idTili, idPat, jetzt);
|
||
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idBen, jetzt);
|
||
|
||
/* Je zwei Aufgaben mit eindeutigen Titeln -- daran laesst sich ablesen,
|
||
WESSEN Liste gerade kommt. */
|
||
const neueAufgabe = (titel, creator, verant) =>
|
||
d.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet,
|
||
creator_id, verantwortlich_id, erstellt, erstellt_von) VALUES (?,?,?,?,?,?,?,?)`)
|
||
.run(titel, "", "offen", "mittel", creator, verant, jetzt, idDogi);
|
||
neueAufgabe("PATRICK-SACHE-1", idTili, idPat);
|
||
neueAufgabe("PATRICK-SACHE-2", idTili, idPat);
|
||
neueAufgabe("BEN-SACHE-1", idLuna, idBen);
|
||
neueAufgabe("NUR-DOGI", null, idDogi);
|
||
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 k = a.headers.getSetCookie?.() || [];
|
||
return k.map((x) => x.split(";")[0]).join("; ");
|
||
}
|
||
const holen = (pfad, keks) =>
|
||
fetch(BASIS + pfad, { headers: { cookie: keks } });
|
||
const titel = async (pfad, keks) => {
|
||
const a = await holen(pfad, keks);
|
||
if (!a.ok) return { status: a.status, liste: [] };
|
||
const j = await a.json();
|
||
return { status: a.status, liste: (j.aufgaben || []).map((x) => x.titel).sort() };
|
||
};
|
||
|
||
const kDogi = await anmelden("admin", "CODE-DOGI-0001");
|
||
const kMgr = await anmelden("manager", "CODE-MANA-0001");
|
||
const kPat = await anmelden("scout", "CODE-SCOU-0001");
|
||
const kTili = await anmelden("creator", "CODE-ANNA-0001");
|
||
|
||
/* ================================================================
|
||
1. ZUERST DER MISSBRAUCH
|
||
================================================================ */
|
||
console.log("\n=== Niemand ausser DogFather darf umschalten");
|
||
|
||
{
|
||
const ohne = await titel("/workspace/api/aufgaben", kPat);
|
||
const mit = await titel(`/workspace/api/aufgaben?sicht=${idBen}`, kPat);
|
||
ok(JSON.stringify(ohne.liste) === JSON.stringify(mit.liste),
|
||
`ein Scout aendert mit ?sicht= nichts (${mit.liste.length} Aufgaben, wie ohne)`);
|
||
ok(!mit.liste.includes("BEN-SACHE-1"),
|
||
" und sieht die Sachen des anderen Scouts NICHT");
|
||
}
|
||
{
|
||
const ohne = await titel("/workspace/api/aufgaben", kMgr);
|
||
const mit = await titel(`/workspace/api/aufgaben?sicht=${idTili}`, kMgr);
|
||
ok(JSON.stringify(ohne.liste) === JSON.stringify(mit.liste),
|
||
`ein Manager aendert mit ?sicht= nichts (${mit.liste.length} Aufgaben)`);
|
||
}
|
||
{
|
||
const ohne = await titel("/workspace/api/aufgaben", kTili);
|
||
const mit = await titel(`/workspace/api/aufgaben?sicht=${idPat}`, kTili);
|
||
ok(JSON.stringify(ohne.liste) === JSON.stringify(mit.liste),
|
||
`ein Creator aendert mit ?sicht= nichts (${mit.liste.length} Aufgaben)`);
|
||
ok(!mit.liste.includes("NUR-DOGI"),
|
||
" und kommt so nicht an fremde Aufgaben");
|
||
}
|
||
|
||
/* ================================================================
|
||
2. DOGFATHER SCHALTET UM
|
||
================================================================ */
|
||
console.log("\n=== DogFather sieht durch fremde Augen");
|
||
|
||
const alles = await titel("/workspace/api/aufgaben", kDogi);
|
||
ok(alles.liste.length === 4, `ohne Auswahl sieht er alles (${alles.liste.length} Aufgaben)`);
|
||
|
||
const alsPat = await titel(`/workspace/api/aufgaben?sicht=${idPat}`, kDogi);
|
||
ok(alsPat.liste.length === 2 &&
|
||
alsPat.liste.every((t) => t.startsWith("PATRICK")),
|
||
`als Patrick genau dessen zwei (${alsPat.liste.join(", ")})`);
|
||
ok(!alsPat.liste.includes("BEN-SACHE-1") && !alsPat.liste.includes("NUR-DOGI"),
|
||
" und wirklich NUR dessen – nicht mehr");
|
||
|
||
const alsBen = await titel(`/workspace/api/aufgaben?sicht=${idBen}`, kDogi);
|
||
ok(alsBen.liste.length === 1 && alsBen.liste[0] === "BEN-SACHE-1",
|
||
`als Ben dessen eine (${alsBen.liste.join(", ")})`);
|
||
ok(JSON.stringify(alsPat.liste) !== JSON.stringify(alsBen.liste),
|
||
" zwei Scouts liefern wirklich Verschiedenes – es wird also umgeschaltet");
|
||
|
||
const alsTili = await titel(`/workspace/api/aufgaben?sicht=${idTili}`, kDogi);
|
||
ok(alsTili.liste.length === 2,
|
||
`als Creator dessen Brett (${alsTili.liste.length})`);
|
||
|
||
/* ================================================================
|
||
3. WAS BEI UNSINN PASSIERT
|
||
================================================================ */
|
||
console.log("\n=== Unsinnige Auswahl");
|
||
for (const [wert, was] of [
|
||
["999999", "eine Nummer, die es nicht gibt"],
|
||
["0", "die Null"],
|
||
["-5", "eine negative Zahl"],
|
||
["abc", "Buchstaben"],
|
||
["1%20OR%201=1", "ein Einschleusversuch"],
|
||
]) {
|
||
const r = await titel(`/workspace/api/aufgaben?sicht=${wert}`, kDogi);
|
||
ok(r.status === 200 && r.liste.length === 4,
|
||
`${was} faellt auf die eigene Sicht zurueck (${r.status}, ${r.liste.length} Aufgaben)`);
|
||
}
|
||
|
||
/* Eine ABGESCHALTETE Person darf keine Sicht liefern -- sonst waere das
|
||
Abschalten eines Kontos halbherzig. */
|
||
{
|
||
const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
d2.prepare("UPDATE personen SET aktiv = 0 WHERE id = ?").run(idBen);
|
||
d2.close();
|
||
const r = await titel(`/workspace/api/aufgaben?sicht=${idBen}`, kDogi);
|
||
ok(r.liste.length === 4,
|
||
`eine abgeschaltete Person liefert keine Sicht mehr (${r.liste.length} Aufgaben = alles)`);
|
||
const d3 = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
d3.prepare("UPDATE personen SET aktiv = 1 WHERE id = ?").run(idBen);
|
||
d3.close();
|
||
}
|
||
|
||
/* ================================================================
|
||
4. GESCHRIEBEN WIRD IMMER IM EIGENEN NAMEN
|
||
================================================================ */
|
||
console.log("\n=== Schreiben bleibt im eigenen Namen");
|
||
{
|
||
const a = await fetch(`${BASIS}/workspace/api/aufgaben?sicht=${idPat}`, {
|
||
method: "POST",
|
||
headers: { cookie: kDogi, "Content-Type": "application/json" },
|
||
body: JSON.stringify({ titel: "WER-HAT-DAS-ANGELEGT", prioritaet: "mittel" }),
|
||
});
|
||
ok(a.ok, `anlegen geht auch bei fremder Sicht (${a.status})`);
|
||
const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const z = d2.prepare("SELECT erstellt_von FROM aufgaben WHERE titel = ?")
|
||
.get("WER-HAT-DAS-ANGELEGT");
|
||
d2.close();
|
||
ok(z?.erstellt_von === idDogi,
|
||
`und steht unter DogFather, nicht unter dem angesehenen Scout `
|
||
+ `(${z?.erstellt_von} statt ${idPat})`);
|
||
}
|
||
|
||
/* ================================================================
|
||
5. DIE ANDEREN BEREICHE ZIEHEN MIT
|
||
================================================================ */
|
||
console.log("\n=== Es gilt nicht nur fuer Aufgaben");
|
||
for (const [pfad, name, feld] of [
|
||
["/workspace/api/hinweise", "Was ist dran", "hinweise"],
|
||
["/workspace/api/termine?von=" + heute + "&tage=7", "Kalender", "termine"],
|
||
["/workspace/api/dateien", "Dateien", "dateien"],
|
||
["/workspace/api/leads", "Scout-Pipeline", "leads"],
|
||
]) {
|
||
const a = await holen(`${pfad}${pfad.includes("?") ? "&" : "?"}sicht=${idPat}`, kDogi);
|
||
const b = await holen(pfad, kDogi);
|
||
ok(a.status === 200 && b.status === 200, `${name}: beide Abfragen gehen durch`);
|
||
}
|
||
|
||
/* DER KALENDER IST PRIVAT -- AUCH FUER DEN UMSCHALTER (11.09.2026).
|
||
|
||
Bis heute stand hier das Gegenteil: "Fremde Verabredungen sieht er
|
||
nicht mehr in seinem eigenen Kalender; dafuer gibt es den
|
||
Umschalter." Filipe hat die Regel selbst nachgezogen, als er die
|
||
Sicht vervollstaendigen liess:
|
||
|
||
"oben bei meine sicht soll ich auch die sicht von allen jeden
|
||
moment sehen koennen und das genau genau so wie sie es sehen
|
||
alles. AUSSER die kalender daten oder chat daten wo ich nicht mit
|
||
drin bin.. also private daten."
|
||
|
||
Damit ist der Kalender die AUSNAHME von der Sicht, nicht ihr
|
||
Paradebeispiel. Ein Termin traegt Titel, Ort und Gegenueber; wer ihn
|
||
liest, liest mit, wo jemand war und mit wem.
|
||
|
||
DIE GEGENPROBE BLEIBT DIESELBE FRAGE, NUR ANDERSHERUM GESTELLT. Ein
|
||
Kalender, der gar nichts mehr liefert, waere die sauberste Pruefung
|
||
von allen und die wertloseste -- deshalb muss jemand die Eintraege
|
||
sehen. Das ist jetzt Patrick selbst, angemeldet als er. */
|
||
{
|
||
const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const rein = d2.prepare(
|
||
`INSERT INTO termine (titel, art, beginn, dauer_min, creator_id, erstellt, erstellt_von)
|
||
VALUES (?,?,?,?,?,?,?)`);
|
||
rein.run("PATRICK-TERMIN", "call", heute + "T10:00", 30, idTili, jetzt, idPat);
|
||
rein.run("BEN-TERMIN", "call", heute + "T12:00", 30, idLuna, jetzt, idBen);
|
||
/* Am 07.09.2026 nachgezogen: Ein Termin OHNE Teilnehmer ist kein
|
||
Team-Termin mehr, sondern der private Eintrag dessen, der ihn
|
||
angelegt hat -- Filipe hat es an seinem "Manager Meeting" in
|
||
Cigdems Kalender gesehen. Der hier gehoert also Patrick, und genau
|
||
das wird unten geprueft. */
|
||
rein.run("PATRICKS NOTIZ", "termin", heute + "T14:00", 30, null, jetzt, idPat);
|
||
/* UND EINER FUER MARA. Ohne ihn stand die Managerin in der Pruefung
|
||
unten mit einer LEEREN Call-Liste da -- und eine leere Liste ist
|
||
zufaellig genau dasselbe wie DogFathers leere Liste. Die Pruefung
|
||
"bleibt privat" waere damit nicht bestanden, sondern gar nicht
|
||
durchfuehrbar gewesen. Sie hat das gemeldet, statt es zu
|
||
verschweigen; die Antwort darauf sind Daten, keine weichere
|
||
Bedingung. */
|
||
rein.run("MARA-CALL", "call", heute + "T16:00", 30, null, jetzt, idMgr);
|
||
d2.close();
|
||
|
||
const j = async (k, s) => {
|
||
const a = await holen(`/workspace/api/termine?von=${heute}&tage=2${s ? "&sicht=" + s : ""}`, k);
|
||
return ((await a.json()).termine || []).map((t) => t.titel).sort();
|
||
};
|
||
const alleT = await j(kDogi);
|
||
const patT = await j(kDogi, idPat);
|
||
ok(!alleT.includes("PATRICK-TERMIN") && !alleT.includes("BEN-TERMIN"),
|
||
`DogFather sieht fremde Verabredungen nicht mehr (${alleT.join(", ") || "nichts"})`);
|
||
ok(!alleT.includes("PATRICKS NOTIZ"),
|
||
"auch einen Termin OHNE Teilnehmer nicht -- der gehoert dem, der ihn anlegt");
|
||
ok(!patT.includes("PATRICK-TERMIN") && !patT.includes("PATRICKS NOTIZ")
|
||
&& !patT.includes("BEN-TERMIN"),
|
||
`auch mit dem Umschalter auf Patrick nicht -- der Kalender ist privat (${patT.join(", ") || "nichts"})`);
|
||
/* UND JETZT DER BEWEIS, DASS DIE PRUEFUNG DARUEBER ETWAS MISST.
|
||
Patrick selbst muss beide Eintraege bekommen; sonst hiesse
|
||
"DogFather sieht sie nicht" nur, dass niemand sie sieht. */
|
||
const patSelbst = await j(kPat);
|
||
ok(patSelbst.includes("PATRICK-TERMIN") && patSelbst.includes("PATRICKS NOTIZ")
|
||
&& !patSelbst.includes("BEN-TERMIN"),
|
||
`Patrick selbst sieht genau seine beiden (${patSelbst.join(", ")})`);
|
||
}
|
||
|
||
/* ================================================================
|
||
6. IM BROWSER: der Umschalter steht da -- und nur bei DogFather
|
||
================================================================ */
|
||
/* =======================================================================
|
||
DIE SICHT IST VOLLSTAENDIG -- UND SIE HAT GENAU ZWEI AUSNAHMEN
|
||
=======================================================================
|
||
|
||
Filipe, 11.09.2026: "oben bei meine sicht soll ich auch die sicht von
|
||
allen jeden moment sehen koennen und das genau genau so wie sie es
|
||
sehen alles. ausser die kalender daten oder chat daten wo ich nicht
|
||
mit drin bin.. also private daten."
|
||
|
||
"GENAU SO WIE SIE ES SEHEN" IST EINE GLEICHUNG, ALSO WIRD SIE ALS
|
||
GLEICHUNG GEPRUEFT. Verglichen wird nicht "mit Umschalter gegen ohne"
|
||
-- das ist bei duenner Datenlage ueberall gleich und beweist nichts,
|
||
genau die Sorte gruener Haken, die nichts gruent. Verglichen wird die
|
||
Antwort, die DogFather mit gesetztem Umschalter bekommt, mit der
|
||
Antwort, die die Person SELBST bekommt, angemeldet als sie.
|
||
|
||
So ist dieser Abschnitt entstanden: als Wegwerf-Messung ueber alle
|
||
Wege des Hauses. Sie hat sechs Stellen gefunden, an denen die Sicht
|
||
ins Leere lief -- darunter eine, an der seit dem 01.09. ein
|
||
ausfuehrlicher Kommentar beschrieb, was der Code daneben nie getan
|
||
hat (`req.person.sicht`, ein Feld, das es nicht gibt). Ein Tippfehler
|
||
in einem Variablennamen macht nichts kaputt; er tut nur nichts. Genau
|
||
deshalb steht die Messung jetzt hier fest drin.
|
||
|
||
DIE AUSNAHMEN WERDEN GENAUSO SCHARF GEPRUEFT wie die Regel: Kalender,
|
||
Calls, Wiederholungen und Chat MUESSEN abweichen. Waeren sie gleich,
|
||
waere Filipes Grenze gefallen, ohne dass es jemandem auffiele. */
|
||
console.log("\n=== Die Sicht zeigt, was die andere Person sieht");
|
||
{
|
||
/* Was hier NICHT steht und warum: `/workspace/api/ich` (es meldet
|
||
absichtlich weiter, WER angemeldet ist -- sonst stuende im Kopf der
|
||
falsche Name), `/workspace/api/personen` (das ist die Liste, aus
|
||
der der Umschalter selbst gebaut wird; folgte sie der Sicht, kaeme
|
||
man aus einer fremden Sicht nicht mehr heraus) und die Listen, aus
|
||
denen man beim ANLEGEN waehlt (Kategorien, Empfaenger) -- die
|
||
gehoeren zum Schreiben, und geschrieben wird immer als man selbst. */
|
||
const GLEICH = [
|
||
["die Zentrale", "/workspace/api/zentrale"],
|
||
["die Leistungszahlen", "/workspace/api/leistung"],
|
||
["die Creator-Liste im Profil", "/workspace/api/profil"],
|
||
["die Schulungen", "/workspace/api/schulung"],
|
||
["die Fruehwarnung", "/workspace/api/fruehwarnung"],
|
||
["der Report", "/workspace/api/report"],
|
||
["die Uebersicht", "/workspace/api/uebersicht"],
|
||
];
|
||
const PRIVAT = [
|
||
["der Kalender", "/workspace/api/termine"],
|
||
["die Calls", "/workspace/api/calls"],
|
||
["die Gespraeche", "/workspace/api/chat/raeume"],
|
||
];
|
||
|
||
const text = async (pfad, keks) => {
|
||
const a = await holen(pfad, keks);
|
||
return { status: a.status, text: await a.text() };
|
||
};
|
||
|
||
for (const [wer, id, keks] of [
|
||
["Manager", idMgr, kMgr], ["Scout", idPat, kPat], ["Creator", idTili, kTili],
|
||
]) {
|
||
for (const [name, pfad] of GLEICH) {
|
||
const durch = await text(pfad + "?sicht=" + id, kDogi);
|
||
const selbst = await text(pfad, keks);
|
||
/* DRITTER AUSGANG: Kann die Person den Weg gar nicht aufrufen,
|
||
ist hier nichts zu vergleichen -- und das ist ein Fehler, kein
|
||
Ueberspringen. Sonst waere diese Schleife gruen, sobald eine
|
||
Rolle irgendwann 404 bekommt. */
|
||
ok(durch.status === 200 && selbst.status === 200
|
||
&& durch.text === selbst.text,
|
||
`${wer}: ${name} ist in der Sicht dieselbe Antwort`
|
||
+ ` (${durch.status}/${selbst.status}, ${durch.text.length}/${selbst.text.length} Zeichen)`);
|
||
}
|
||
for (const [name, pfad] of PRIVAT) {
|
||
const durch = await text(pfad + "?sicht=" + id, kDogi);
|
||
const selbst = await text(pfad, keks);
|
||
const eigen = await text(pfad, kDogi);
|
||
ok(durch.status === 200 && durch.text === eigen.text && durch.text !== selbst.text,
|
||
`${wer}: ${name} bleibt privat -- der Umschalter aendert daran nichts`
|
||
+ ` (${durch.text.length} eigene / ${selbst.text.length} ihre)`);
|
||
}
|
||
}
|
||
|
||
/* GEGENPROBE ZUR GLEICHUNG SELBST. Wenn zwei Antworten, die
|
||
verschieden sein MUESSEN, hier als gleich durchgingen, waere der
|
||
ganze Abschnitt darueber wertlos. Also einmal absichtlich die
|
||
falsche Person einsetzen: Die Zentrale des Managers und die des
|
||
Scouts duerfen nicht dieselbe Antwort sein. */
|
||
const zMgr = await (await holen("/workspace/api/zentrale?sicht=" + idMgr, kDogi)).text();
|
||
const zPat = await (await holen("/workspace/api/zentrale?sicht=" + idPat, kDogi)).text();
|
||
ok(zMgr !== zPat,
|
||
"Gegenprobe: zwei verschiedene Personen ergeben auch zwei verschiedene Antworten");
|
||
}
|
||
|
||
console.log("\n=== Der Umschalter im Seitenkopf");
|
||
const { chromium } = await import(
|
||
"file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
|
||
const browser = await chromium.launch();
|
||
|
||
async function browserAls(rolle, code) {
|
||
const kontext = await browser.newContext({ viewport: { width: 1280, height: 1000 } });
|
||
const konsole = [];
|
||
const seite = await kontext.newPage();
|
||
seite.on("console", (m) => { if (m.type() === "error") konsole.push(m.text()); });
|
||
seite.on("pageerror", (e) => konsole.push("pageerror: " + e.message));
|
||
await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
|
||
await seite.click(`.rolle[data-rolle="${rolle}"]`);
|
||
await seite.fill("#code", code);
|
||
await seite.click("button[type=submit]");
|
||
await seite.waitForURL("**/start.html", { timeout: 15000 });
|
||
return { kontext, seite, konsole };
|
||
}
|
||
|
||
const bDogi = await browserAls("admin", "CODE-DOGI-0001");
|
||
/* AUF JEDER SEITE -- das war der ausdrueckliche Wunsch. Geprueft wird
|
||
deshalb nicht eine Seite, sondern alle. */
|
||
const SEITEN = ["start.html", "aufgaben.html", "kalender.html", "dateien.html",
|
||
"bereich.html?b=live", "content.html", "calls.html", "scouting.html",
|
||
"report.html", "personen.html", "wissen.html", "uebersicht.html",
|
||
"profil.html", "startcheck.html", "steckbrief.html", "automation.html"];
|
||
let fehlend = [];
|
||
for (const s of SEITEN) {
|
||
await bDogi.seite.goto(BASIS + "/workspace/" + s, { waitUntil: "networkidle" });
|
||
await bDogi.seite.waitForTimeout(900);
|
||
const da = await bDogi.seite.evaluate(() => {
|
||
const f = document.getElementById("sicht-wahl");
|
||
if (!f) return false;
|
||
const r = f.getBoundingClientRect();
|
||
return r.width > 0 && r.height > 0;
|
||
});
|
||
if (!da) fehlend.push(s);
|
||
}
|
||
ok(fehlend.length === 0,
|
||
`der Umschalter steht auf allen ${SEITEN.length} Seiten`
|
||
+ (fehlend.length ? ` – FEHLT auf: ${fehlend.join(", ")}` : ""));
|
||
|
||
const wahl = await bDogi.seite.evaluate(() => {
|
||
const s = document.getElementById("sicht-feld");
|
||
return {
|
||
gruppen: [...s.querySelectorAll("optgroup")].map((g) => g.label),
|
||
anzahl: s.querySelectorAll("option").length,
|
||
erste: s.querySelector("option")?.textContent,
|
||
ichDrin: [...s.querySelectorAll("option")].some((o) => o.textContent === "Filipe"),
|
||
namen: [...s.querySelectorAll("optgroup option")].map((o) => o.textContent),
|
||
};
|
||
});
|
||
/* Die Reihenfolge ist die des Hauses (window.Bereiche.ROLLENFOLGE):
|
||
Spicy Media, DogFather, Manager, Scout, Creator. DogFather faellt
|
||
weg, weil dort nur Filipe selbst steht. */
|
||
ok(wahl.gruppen.join(", ") === "Spicy Media, Manager, Scouts, Creator",
|
||
`nach Rollen gruppiert: ${wahl.gruppen.join(", ")}`);
|
||
ok(wahl.gruppen.includes("Spicy Media"),
|
||
"Spicy Media steht mit dabei — nicht mehr nur vier von fuenf Rollen");
|
||
|
||
/* GEGENPROBE: Die Liste kommt wirklich aus der zentralen Reihenfolge
|
||
und ist nicht wieder abgeschrieben. Waere sie es, koennte sie beim
|
||
naechsten Mal genauso stehenbleiben. */
|
||
const ausZentral = await bDogi.seite.evaluate(() => {
|
||
const folge = window.Bereiche?.ROLLENFOLGE || [];
|
||
const namen = window.Bereiche?.ROLLEN_GRUPPE || {};
|
||
const s = document.getElementById("sicht-feld");
|
||
const da = [...s.querySelectorAll("optgroup")].map((g) => g.label);
|
||
const erwartet = folge.map((r) => namen[r]).filter((n) => da.includes(n));
|
||
return { gleich: erwartet.join(", ") === da.join(", "), erwartet, da };
|
||
});
|
||
ok(ausZentral.gleich,
|
||
`die Reihenfolge folgt der zentralen Liste (${ausZentral.erwartet.join(", ")})`);
|
||
|
||
/* Und die PERSON steht drin, nicht nur die Ueberschrift. */
|
||
ok([...(wahl.namen || [])].includes("Cigdem"),
|
||
`die Spicy-Media-Person steht in ihrer Gruppe (${(wahl.namen || []).join(", ")})`);
|
||
ok(/meine Sicht/i.test(wahl.erste || ""),
|
||
`der Rueckweg steht ganz oben ("${wahl.erste}")`);
|
||
ok(!wahl.ichDrin, "DogFather selbst steht nicht in der Liste – das waere derselbe Zustand");
|
||
|
||
/* Umschalten im Browser und pruefen, dass die Seite danach wirklich
|
||
die andere Liste zeigt. */
|
||
await bDogi.seite.goto(BASIS + "/workspace/aufgaben.html", { waitUntil: "networkidle" });
|
||
await bDogi.seite.waitForTimeout(1100);
|
||
const vorher = await bDogi.seite.evaluate(() =>
|
||
document.querySelectorAll(".karte").length);
|
||
await bDogi.seite.selectOption("#sicht-feld", String(idPat));
|
||
await bDogi.seite.waitForTimeout(1800);
|
||
const nachher = await bDogi.seite.evaluate(() => ({
|
||
karten: document.querySelectorAll(".karte").length,
|
||
titel: [...document.querySelectorAll(".karte__titel")].map((e) => e.textContent).sort(),
|
||
rahmen: getComputedStyle(document.body, "::after").borderTopWidth,
|
||
hinweis: !!document.querySelector('.sicht[data-fremd="ja"]'),
|
||
weg: !!document.querySelector(".sicht__weg"),
|
||
}));
|
||
ok(nachher.karten < vorher,
|
||
`nach dem Umschalten weniger Aufgaben (${vorher} -> ${nachher.karten})`);
|
||
ok(nachher.titel.every((t) => t.startsWith("PATRICK")),
|
||
`und zwar genau Patricks (${nachher.titel.join(", ")})`);
|
||
ok(nachher.hinweis, "der Umschalter zeigt deutlich, dass eine fremde Sicht laeuft");
|
||
ok(nachher.weg, " und bietet den Weg zurueck an");
|
||
ok(parseFloat(nachher.rahmen) >= 1,
|
||
`ein Rahmen um die Seite erinnert daran (${nachher.rahmen}) – `
|
||
+ "der gefaehrlichste Fall ist, dass man es vergisst");
|
||
|
||
/* ================================================================
|
||
DIE SEITE SELBST MUSS SICH AENDERN, nicht nur die Listen.
|
||
|
||
Der Fehler, den diese Pruefung uebersehen hat (gemeldet 02.09.2026):
|
||
"ich hab oben die Ansicht von Tili ausgewaehlt und seh immer noch die
|
||
Seite genau wie meine."
|
||
|
||
Sie hat bisher nur geprueft, dass WENIGER AUFGABEN erscheinen -- und
|
||
das stimmte ja. Kacheln, Rollenzeile und Begruessung kamen aber
|
||
weiterhin von DogFather, weil /api/ich immer den Angemeldeten
|
||
lieferte. Der Umschalter war halb gebaut, und die Pruefung hat genau
|
||
die Haelfte geprueft, die fertig war.
|
||
|
||
Deshalb jetzt: Sieht man den Arbeitsplatz eines CREATORS, duerfen die
|
||
Kacheln der Leitung nicht mehr dastehen -- und es muss dranstehen,
|
||
WESSEN Arbeitsplatz das ist. */
|
||
console.log("\n=== Die Seite zeigt den fremden Arbeitsplatz, nicht den eigenen");
|
||
await bDogi.seite.goto(BASIS + "/workspace/start.html", { waitUntil: "networkidle" });
|
||
await bDogi.seite.waitForTimeout(1400);
|
||
/* ZUERST AUF DIE EIGENE SICHT ZURUECK. Der Abschnitt davor hat auf einen
|
||
Scout umgeschaltet, und die Auswahl ueberlebt den Seitenwechsel -- das
|
||
ist ja gerade gewollt. Ohne dieses Zuruecksetzen mass der erste Anlauf
|
||
"seine eigenen Kacheln" waehrend noch die fremde Sicht lief und
|
||
meldete einen Fehler, den es nicht gab.
|
||
|
||
Eine Pruefung, die ihren eigenen Ausgangszustand nicht herstellt,
|
||
misst den Nachhall der vorigen. */
|
||
await bDogi.seite.selectOption("#sicht-feld", "");
|
||
await bDogi.seite.waitForTimeout(1600);
|
||
const eigene = await bDogi.seite.evaluate(() => ({
|
||
kacheln: [...document.querySelectorAll(".kachel__name")].map((e) => e.textContent),
|
||
rolle: document.getElementById("rollentext")?.textContent,
|
||
}));
|
||
ok(eigene.kacheln.includes("Personen & Zugänge"),
|
||
`als er selbst sieht er die Leitungs-Kacheln (${eigene.kacheln.length} Kacheln)`);
|
||
|
||
await bDogi.seite.selectOption("#sicht-feld", String(idTili));
|
||
await bDogi.seite.waitForTimeout(1800);
|
||
const fremd = await bDogi.seite.evaluate(() => ({
|
||
kacheln: [...document.querySelectorAll(".kachel__name")].map((e) => e.textContent),
|
||
rolle: document.getElementById("rollentext")?.textContent,
|
||
gruppen: [...document.querySelectorAll(".gruppe__name")].map((e) => e.textContent),
|
||
}));
|
||
ok(!fremd.kacheln.includes("Personen & Zugänge"),
|
||
`in der Sicht eines Creators fehlen die Leitungs-Kacheln `
|
||
+ `(${eigene.kacheln.length} -> ${fremd.kacheln.length})`);
|
||
ok(!fremd.kacheln.includes("Automationen"), " auch die Automationen");
|
||
ok(fremd.kacheln.length < eigene.kacheln.length,
|
||
" die Seite zeigt wirklich weniger, nicht dasselbe");
|
||
ok(/Tili/.test(fremd.rolle || ""),
|
||
`und es steht dran, wessen Arbeitsplatz das ist ("${fremd.rolle}")`);
|
||
ok(/Creator/.test(fremd.rolle || ""),
|
||
" samt seiner Rolle");
|
||
/* Die Gruppe heisst fuer einen Creator "Wissen" statt "Team & System" --
|
||
ein weiterer Beleg, dass die SEITE der Sicht folgt und nicht nur die
|
||
Daten dahinter. */
|
||
ok(fremd.gruppen.includes("Wissen"),
|
||
`die Gruppentitel folgen ebenfalls (${fremd.gruppen.join(", ")})`);
|
||
|
||
await bDogi.seite.click(".sicht__weg");
|
||
await bDogi.seite.waitForTimeout(1600);
|
||
const zurueckSeite = await bDogi.seite.evaluate(() => ({
|
||
kacheln: [...document.querySelectorAll(".kachel__name")].map((e) => e.textContent),
|
||
rolle: document.getElementById("rollentext")?.textContent,
|
||
}));
|
||
ok(zurueckSeite.kacheln.includes("Personen & Zugänge")
|
||
&& !/Tili/.test(zurueckSeite.rolle || ""),
|
||
`zurueck bei sich sieht er wieder alles ("${zurueckSeite.rolle}")`);
|
||
|
||
await bDogi.seite.goto(BASIS + "/workspace/kalender.html", { waitUntil: "networkidle" });
|
||
await bDogi.seite.waitForTimeout(1200);
|
||
await bDogi.seite.selectOption("#sicht-feld", String(idPat));
|
||
await bDogi.seite.waitForTimeout(1800);
|
||
|
||
/* Und er BLEIBT beim Seitenwechsel -- sonst muesste man ihn auf jeder
|
||
Seite neu setzen, und genau das war der Wunsch ("ueberall"). */
|
||
await bDogi.seite.goto(BASIS + "/workspace/kalender.html", { waitUntil: "networkidle" });
|
||
await bDogi.seite.waitForTimeout(1200);
|
||
const bleibt = await bDogi.seite.evaluate(() => ({
|
||
wert: document.getElementById("sicht-feld")?.value,
|
||
fremd: !!document.querySelector('.sicht[data-fremd="ja"]'),
|
||
}));
|
||
ok(bleibt.wert === String(idPat) && bleibt.fremd,
|
||
`die Auswahl ueberlebt den Seitenwechsel (${bleibt.wert})`);
|
||
|
||
/* Zurueck -- und wirklich zurueck. */
|
||
await bDogi.seite.click(".sicht__weg");
|
||
await bDogi.seite.waitForTimeout(1600);
|
||
const zurueck = await bDogi.seite.evaluate(() => ({
|
||
wert: document.getElementById("sicht-feld")?.value,
|
||
fremd: !!document.querySelector('.sicht[data-fremd="ja"]'),
|
||
}));
|
||
ok(zurueck.wert === "" && !zurueck.fremd, '"zurück zu mir" stellt die eigene Sicht wieder her');
|
||
ok(bDogi.konsole.length === 0,
|
||
`keine Fehler in der Konsole${bDogi.konsole.length ? " -> " + bDogi.konsole.join(" | ") : ""}`);
|
||
await bDogi.kontext.close();
|
||
|
||
/* GEGENPROBE IM BROWSER: Die anderen drei Rollen bekommen ihn nicht
|
||
einmal zu sehen. */
|
||
for (const [rolle, code, name] of [
|
||
["manager", "CODE-MANA-0001", "Manager"],
|
||
["scout", "CODE-SCOU-0001", "Scout"],
|
||
["creator", "CODE-ANNA-0001", "Creator"],
|
||
]) {
|
||
const b = await browserAls(rolle, code);
|
||
await b.seite.goto(BASIS + "/workspace/aufgaben.html", { waitUntil: "networkidle" });
|
||
await b.seite.waitForTimeout(900);
|
||
const da = await b.seite.evaluate(() => !!document.getElementById("sicht-wahl"));
|
||
ok(!da, `Gegenprobe: ein ${name} sieht den Umschalter nicht`);
|
||
await b.kontext.close();
|
||
}
|
||
|
||
await browser.close();
|
||
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
|
||
console.log(fehler ? `\n${fehler} Prüfung(en) fehlgeschlagen.` : "\nAlles in Ordnung.");
|
||
process.exit(fehler ? 1 : 0);
|