DogFatherGitandClaude Opus 5
db656f6e14
Filipe mit der Vorlage „Prompt · Kachel Agentur-Aufgaben" (02.10.2026):
Scouts, Manager, DogFather und Spicy Media bekommen vier Pflichten je
Monat -- Creator rekrutieren, Manager-Meeting, Schulung oder Community
Talk, Werbung auf TikTok -- mit Fortschritt, Ampel, Warnungen und
einem Monatsschnitt, der nichts loescht.
DREI ENTSCHEIDUNGEN, DIE VON DER VORLAGE ABWEICHEN -- alle abgestimmt:
1. DIE KACHEL HEISST „Manager-Ziele", nicht „Agentur-Aufgaben".
Es gibt bereits eine Kachel „Agentur" und eine „Aufgaben". Eine
dritte mit beiden Woertern im Namen waere auf einem Handy nicht
mehr auseinanderzuhalten.
2. DIE ZIELZAHLEN GELTEN JE ROLLE, und DogFather UND Spicy Media
duerfen sie aendern. Ein Scout muss nicht dieselbe Zahl schaffen
wie die Leitung.
3. DIE SCOUT-PIPELINE IST ANGEBUNDEN, in beide Richtungen: Vorschlaege
aus uebergebenen Leads, Namensvorschlaege beim Tippen, die
Verbindung bleibt am Eintrag gespeichert. Aber NICHTS zaehlt von
selbst -- gezaehlt wird nur, was ein Mensch bestaetigt hat. Ein
Zaehler, der sich allein fuellt, ist einer, dem niemand glaubt.
WAS ANDERS GEBAUT IST, ALS ES NAHELAG
DAS ZIEL WIRD PRO MONAT EINGEFROREN (`mz_ziel` hat den Monat im
Schluessel). Laege nur ein aktueller Wert in `einstellungen`, schriebe
jede spaetere Aenderung rueckwirkend den ganzen Verlauf um: Ein Monat,
der mit 2/2 abgeschlossen war, staende nach einer Erhoehung auf 4
ploetzlich als „nicht erreicht" da. Ein Verlauf, der sich rueckwirkend
aendert, ist keiner. Es gibt deshalb gar keinen Weg, den laufenden
Monat umzuschreiben -- gespeichert wird immer in den naechsten.
DIE SPERRE VERGANGENER MONATE SITZT IN DER DATENBANK, nicht im Code
(drei Trigger). Die Ausnahme fuer DogFather laesst sich in SQLite
nicht ueber die Sitzung abfragen, also ist sie ein sichtbarer Vorgang:
`mz_freigabe` wird fuer die eine Handlung geoeffnet, im `finally`
wieder geschlossen und verfaellt nach zwei Minuten von selbst. Jede
Korrektur steht mit Name und Zeit im Protokoll.
DER LAUFENDE MONAT STEHT IN EINER TABELLE (`mz_lage`), nicht in
`strftime(...,'localtime')`. Sonst entschiede die Zeitzone des Servers,
und am Monatsersten zwischen 00:00 und 02:00 griffe die Sperre fuer
den falschen Monat. Gerechnet wird durchgehend in Europe/Berlin
(identisch mit dem Europe/Luxembourg der Vorlage, aber dieselbe
Zeitrechnung wie der Rest des Hauses).
KEIN ZWEITER ZAEHLER FUER DIE KACHELWAND. Rand und Abzeichen auf der
Startseite kommen aus `workspace-hinweise.js` und damit aus derselben
Rechnung wie die Seite (`standFuer`). Zwei Rechnungen ueber dieselbe
Sache laufen auseinander, und zwar lautlos.
KEIN IMPORTKREIS ZU workspace-push.js. Die Erinnerungen entstehen hier
als Liste (`zielRufe`), verschickt werden sie im vorhandenen
Fuenf-Minuten-Takt. Der Tag steht im Merkmal -- dadurch geht pro
Person hoechstens EINE Meldung am Tag heraus, obwohl der Lauf
288-mal stattfindet.
GETRENNTE HAEUSER: Auf crew.dogfather-universe.com gibt es diese
Kachel nicht, auch nicht fuer DogFather. Gemessen, nicht angenommen.
GEPRUEFT (141 Pruefungen, 0 Fehler) -- mit Gegenproben zu jeder Sperre
* Vier Rollen kommen herein, drei bekommen 404 (nicht 403), und die
ANZAHL steht in der Bedingung. „Alle abgewiesen" waere auf einer
leeren Liste wahr.
* Die Ampel wird mit EINGESETZTEN Tagen gemessen, nie gegen die
Wanduhr -- diese Pruefung sagt am 16. November dasselbe wie heute.
(gate-oeffnung.mjs im Shop war gruen, bis der Kalender sie
ueberholte.)
* Die Datenbank lehnt einen Eintrag im Vormonat selbst ab; danach
wird nachgewiesen, dass die Freigabe nur EINMAL gewirkt hat.
* Neun Absagen mit dem jeweils richtigen Grund -- und eine
Instagram-Adresse, die durchgehen MUSS, weil sonst nur bewiesen
waere, dass die Pruefung streng ist, nicht dass sie richtig ist.
* Am 7. des Monats ist Ruhe: Ohne diese Zeile bewiese der
Erinnerungs-Block nur, dass immer etwas kommt.
ZWEI BEFUNDE KAMEN AUS DER MESSUNG, NICHT AUS DEM NACHDENKEN
* Beim Aufklappen einer Zeile wurde die ganze Liste neu gebaut --
der angeklickte Knopf existierte danach nicht mehr, der Fokus
sprang an den Seitenanfang. Gefunden hat es die Bildmessung, der
die Schaltflaeche unter der Hand wegbrach.
* Zwei meiner Messungen waren falsch, nicht der Code: Der
Haus-Test schickte den Keks nicht mit (401 statt 404), und
`Response.text()` entfernt ein BOM beim Dekodieren -- der Export
hatte eines, die Pruefung sah es nur nicht. Jetzt wird in Bytes
gemessen.
Kachelton 47 (#7368ff) ist mit tools/kachel-farbe-einzeln.mjs gegen
alle 46 vorhandenen gerechnet, nicht ausgesucht: Abstand 0,0899,
Kontrast 4,61:1. Beruehrziele, waagerechtes Schieben und
Schriftgroessen sind am Bildschirm bei 412 px und 1280 px nachgemessen.
Co-Authored-By: Claude Opus 5 <[email protected]>
735 lines
37 KiB
JavaScript
735 lines
37 KiB
JavaScript
/* =====================================================================
|
||
MANAGER-ZIELE (02.10.2026)
|
||
=====================================================================
|
||
|
||
Geprüft wird, was Filipe bestellt hat — und fünf Dinge, die er nicht
|
||
bestellt hat, weil sie sonst niemandem auffallen:
|
||
|
||
* JEDE Sperre muss auch NEIN sagen können. Eine Prüfung, die nur
|
||
den Erfolgsfall ansieht, beweist nichts: `every()` liefert auf
|
||
einem leeren Feld `true`, und ein Trigger, dessen Spaltenname
|
||
falsch ist, lehnt die Änderung ab, ohne je gelaufen zu sein
|
||
(RunOne, 01.09.2026). Zu jeder „geht"-Prüfung steht hier eine
|
||
„geht nicht"-Prüfung.
|
||
|
||
* DIE DATUMSLOGIK WIRD MIT EINGESETZTEN TAGEN GEMESSEN, nie gegen
|
||
die Wanduhr. `gate-oeffnung.mjs` im Shop war grün, bis der
|
||
Kalender sie überholte, und dann rot, ohne dass etwas kaputt
|
||
war. Hier liegen die Tage als Zahl im Aufruf — diese Prüfung
|
||
sagt am 16. November dasselbe wie heute.
|
||
|
||
* DIE ZAHL DER GEPRÜFTEN DINGE STEHT IN DER BEDINGUNG, nicht nur
|
||
im Meldetext. „Alle Rollen abgewiesen" ist auf einer leeren
|
||
Liste wahr.
|
||
|
||
* DIE BEIDEN HÄUSER BLEIBEN GETRENNT. Auf der Crew-Adresse gibt es
|
||
diese Kachel nicht, auch nicht für DogFather.
|
||
|
||
* DER MONATSSCHNITT ÄNDERT DEN VERLAUF NICHT. Wer die Zielzahlen
|
||
erhöht, darf einen abgeschlossenen Monat nicht nachträglich auf
|
||
„nicht erreicht" drehen.
|
||
===================================================================== */
|
||
import { mkdtempSync, rmSync } from "node:fs";
|
||
import { tmpdir } from "node:os";
|
||
import { join } from "node:path";
|
||
|
||
const ordner = mkdtempSync(join(tmpdir(), "ws-mz-"));
|
||
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
|
||
|
||
import { notbremse } from "./helfer-notbremse.mjs";
|
||
const { eigenerPort } = await import("./helfer-port.mjs");
|
||
const PORT = await eigenerPort(import.meta, "die Pruefung der Manager-Ziele");
|
||
|
||
process.env.PORT = `${PORT}`;
|
||
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 }); };
|
||
await import("./index.js");
|
||
notbremse(240_000, "pruef-manager-ziele");
|
||
await new Promise((r) => setTimeout(r, 900));
|
||
const BASIS = `http://127.0.0.1:${PORT}`;
|
||
const API = "/workspace/api/manager-ziele";
|
||
|
||
let fehler = 0, geprueft = 0;
|
||
const ok = (b, t) => { geprueft++; console.log((b ? " ok " : " FEHL ") + t); if (!b) fehler++; };
|
||
const melde = (t) => console.log(t);
|
||
|
||
/* DER DRITTE AUSGANG. Kann die Prüfung ihre Voraussetzung nicht
|
||
herstellen, ist das WEDER in Ordnung NOCH ein Befund am Code --
|
||
sie muss es sagen und abbrechen, statt grün zu melden. */
|
||
function braucht(bedingung, was) {
|
||
if (bedingung) return;
|
||
console.log(`\nABBRUCH: konnte nicht nachsehen — ${was}`);
|
||
console.log("Das ist KEIN Befund am Code. Die Pruefung konnte ihre");
|
||
console.log("Voraussetzung nicht herstellen und sagt das, statt zu schweigen.\n");
|
||
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
|
||
process.exit(2);
|
||
}
|
||
|
||
/* ---------- Personen anlegen ---------------------------------------- */
|
||
const { DatabaseSync } = await import("node:sqlite");
|
||
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
|
||
const d = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const jetztIso = new Date().toISOString();
|
||
const kennSchluessel = randomBytes(32).toString("hex");
|
||
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
|
||
+ " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
|
||
.run("code_kennung_schluessel", kennSchluessel, jetztIso);
|
||
|
||
/* ERSTELLT: ein Jahr alt. Sonst wären alle erst im Folgemonat
|
||
pflichtig (Regel 09 der Vorlage) und jede Ampelprüfung wäre
|
||
neutral — die Prüfung sähe grün aus und hätte nichts gemessen. */
|
||
const ALT = new Date(Date.now() - 365 * 86400_000).toISOString();
|
||
|
||
function anlegen(name, rolle, code, erstellt = ALT) {
|
||
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,"
|
||
+ " code_kennung, aktiv, erstellt) VALUES (?,?,?,?,?,?,1,?)")
|
||
.run(name, rolle, hash, salt, 32768,
|
||
createHmac("sha256", kennSchluessel).update(code).digest("hex"), erstellt);
|
||
return d.prepare("SELECT last_insert_rowid() AS id").get().id;
|
||
}
|
||
|
||
const ROLLEN = [
|
||
["admin", "Filipe"], ["spicy", "Spicy Media"], ["manager", "Patrick"],
|
||
["scout", "Kevin"], ["scout", "Sandra"], ["creator", "Luna"],
|
||
["hand", "VanVan"], ["modi", "Miss"],
|
||
];
|
||
const CODES = {}, IDS = {};
|
||
for (const [i, [rolle, name]] of ROLLEN.entries()) {
|
||
const schluessel = IDS[rolle] === undefined ? rolle : `${rolle}2`;
|
||
CODES[schluessel] = `CODE-Z${String(i).padStart(2, "0")}-000001`;
|
||
IDS[schluessel] = anlegen(name, rolle, CODES[schluessel]);
|
||
}
|
||
d.close();
|
||
|
||
/* ---------- Anmelden ------------------------------------------------- */
|
||
const { request } = await import("node:http");
|
||
const CREW_HOST = "crew.dogfather-universe.com";
|
||
|
||
function roh(pfad, host, koerper, methode) {
|
||
return new Promise((fertig, schief) => {
|
||
const daten = koerper ? JSON.stringify(koerper) : null;
|
||
const a = request({
|
||
host: "127.0.0.1", port: PORT, path: pfad,
|
||
method: methode || (daten ? "POST" : "GET"),
|
||
headers: {
|
||
...(host ? { Host: host } : {}),
|
||
Origin: host ? `https://${host}` : BASIS,
|
||
...(daten ? { "Content-Type": "application/json",
|
||
"Content-Length": Buffer.byteLength(daten) } : {}),
|
||
},
|
||
}, (antwort) => {
|
||
let text = "";
|
||
antwort.on("data", (t) => { text += t; });
|
||
antwort.on("end", () => fertig({ code: antwort.statusCode, kopf: antwort.headers, text }));
|
||
});
|
||
a.on("error", schief);
|
||
if (daten) a.write(daten);
|
||
a.end();
|
||
});
|
||
}
|
||
|
||
/** Derselbe Aufruf mit Hausadresse UND Sitzung. `fetch` verwirft den
|
||
* Host-Kopf (er steht auf der Liste der verbotenen Kopfzeilen), also
|
||
* geht das nur ueber node:http. */
|
||
function rohMitKeks(pfad, host, keks) {
|
||
return new Promise((fertig, schief) => {
|
||
const a = request({
|
||
host: "127.0.0.1", port: PORT, path: pfad, method: "GET",
|
||
headers: { Host: host, Origin: `https://${host}`, Cookie: keks || "" },
|
||
}, (antwort) => {
|
||
let text = "";
|
||
antwort.on("data", (t) => { text += t; });
|
||
antwort.on("end", () => fertig({ code: antwort.statusCode, text }));
|
||
});
|
||
a.on("error", schief);
|
||
a.end();
|
||
});
|
||
}
|
||
|
||
async function anmelden(schluessel, rolle, host = null) {
|
||
const r = await roh("/workspace/api/anmelden", host, { rolle, code: CODES[schluessel] });
|
||
if (r.code !== 200) return null;
|
||
return [].concat(r.kopf["set-cookie"] || []).map((z) => z.split(";")[0]).join("; ") || null;
|
||
}
|
||
|
||
const kekse = {};
|
||
melde("\n=== Alle Rollen kommen herein ===");
|
||
for (const schluessel of Object.keys(CODES)) {
|
||
const rolle = schluessel.replace(/2$/, "");
|
||
kekse[schluessel] = await anmelden(schluessel, rolle);
|
||
ok(!!kekse[schluessel], `${schluessel}: angemeldet`);
|
||
}
|
||
braucht(Object.values(kekse).every(Boolean), "nicht alle Rollen konnten sich anmelden");
|
||
|
||
async function hol(schluessel, pfad, einst = {}) {
|
||
return fetch(BASIS + pfad, {
|
||
...einst,
|
||
headers: {
|
||
Cookie: kekse[schluessel] || "", Origin: BASIS,
|
||
...(einst.body ? { "Content-Type": "application/json" } : {}),
|
||
...(einst.headers || {}),
|
||
},
|
||
});
|
||
}
|
||
const schick = (schluessel, pfad, methode, rumpf) =>
|
||
hol(schluessel, pfad, { method: methode, body: JSON.stringify(rumpf) });
|
||
|
||
/* =====================================================================
|
||
1 · WER DARF HEREIN — und wer ausdrücklich nicht
|
||
===================================================================== */
|
||
melde("\n=== Sichtbarkeit: vier Rollen ja, der Rest nein ===");
|
||
const DUERFEN = ["admin", "spicy", "manager", "scout"];
|
||
const DUERFEN_NICHT = ["creator", "hand", "modi"];
|
||
|
||
let drin = 0;
|
||
for (const r of DUERFEN) {
|
||
const a = await hol(r, `${API}/stand`);
|
||
if (a.status === 200) drin++;
|
||
ok(a.status === 200, `${r} kommt an den Stand (${a.status})`);
|
||
}
|
||
/* DIE ZAHL STEHT IN DER BEDINGUNG. „Alle durchgelassen" wäre auf einer
|
||
leeren Liste wahr. */
|
||
ok(drin === DUERFEN.length, `genau ${DUERFEN.length} Rollen kommen herein (${drin})`);
|
||
|
||
let draussen = 0;
|
||
for (const r of DUERFEN_NICHT) {
|
||
const a = await hol(r, `${API}/stand`);
|
||
if (a.status === 404) draussen++;
|
||
ok(a.status === 404, `${r} bekommt 404 (nicht 403) (${a.status})`);
|
||
}
|
||
ok(draussen === DUERFEN_NICHT.length,
|
||
`genau ${DUERFEN_NICHT.length} Rollen bleiben draussen (${draussen})`);
|
||
|
||
melde("\n=== Die Seite selbst ist ebenfalls zu ===");
|
||
const seiteCreator = await hol("creator", "/workspace/manager-ziele.html", { redirect: "manual" });
|
||
ok(seiteCreator.status === 302,
|
||
`Creator wird von der Seite weggeschickt (${seiteCreator.status})`);
|
||
const seiteScout = await hol("scout", "/workspace/manager-ziele.html", { redirect: "manual" });
|
||
ok(seiteScout.status === 200, `Scout bekommt die Seite (${seiteScout.status})`);
|
||
|
||
melde("\n=== Zwei getrennte Haeuser: auf crew. gibt es die Kachel nicht ===");
|
||
const crewKeks = await anmelden("admin", "admin", CREW_HOST);
|
||
braucht(!!crewKeks, "DogFather konnte sich auf der Crew-Adresse nicht anmelden");
|
||
/* DER KEKS MUSS MIT. Beim ersten Lauf stand hier 401 statt 404 --
|
||
und das sah aus wie ein Befund an der Haustrennung. Es war einer an
|
||
meiner Messung: Ohne Sitzung kommt man ueberall nicht herein, das
|
||
beweist nichts ueber DIESE Kachel. */
|
||
const crewStand = await rohMitKeks(`${API}/stand`, CREW_HOST, crewKeks);
|
||
ok(crewStand.code === 404,
|
||
`DogFather bekommt auf crew. ein 404 auf die Schnittstelle (${crewStand.code})`);
|
||
const crewMitKeks = await rohMitKeks("/workspace/start.html", CREW_HOST, crewKeks);
|
||
ok(crewMitKeks.code === 200,
|
||
`…und ist dort trotzdem angemeldet (${crewMitKeks.code}) — die Sitzung war es nicht`);
|
||
|
||
/* =====================================================================
|
||
2 · DIE AMPEL — reine Rechnung, mit eingesetzten Tagen
|
||
===================================================================== */
|
||
melde("\n=== Die Ampel (eingesetzte Tage, nicht die Wanduhr) ===");
|
||
const mz = await import("./workspace-manager-ziele.js");
|
||
|
||
/* Ein Monat mit 31 Tagen. `bisEnde = letzter - tag`. */
|
||
const L = 31;
|
||
ok(mz.stufeFuer(3, 3, 5, L) === "gruen", "Ziel erreicht am 5. -> gruen");
|
||
ok(mz.stufeFuer(4, 3, 5, L) === "gruen", "uebererfuellt (4/3) -> gruen");
|
||
ok(mz.stufeFuer(0, 3, 1, L) === "neutral", "Tag 1, offen -> neutral");
|
||
ok(mz.stufeFuer(1, 3, 15, L) === "neutral", "Tag 15, offen -> neutral");
|
||
ok(mz.stufeFuer(1, 3, 16, L) === "orange", "Tag 16, offen -> orange");
|
||
ok(mz.stufeFuer(1, 3, 23, L) === "orange", "Tag 23 (8 Tage uebrig) -> noch orange");
|
||
ok(mz.stufeFuer(1, 3, 24, L) === "rot", "Tag 24 (7 Tage uebrig) -> rot");
|
||
ok(mz.stufeFuer(1, 3, 31, L) === "rot", "letzter Tag, offen -> rot");
|
||
ok(mz.stufeFuer(0, 0, 31, L) === "aus", "Ziel 0 -> aus, nie eine Warnung");
|
||
/* GEGENPROBE: Die Rechnung muss auch dann rot sagen koennen, wenn der
|
||
16. gar nicht erreicht wurde -- in einem kurzen Monat. */
|
||
ok(mz.stufeFuer(0, 1, 21, 28) === "rot", "Februar, Tag 21 (7 uebrig) -> rot");
|
||
ok(mz.stufeFuer(0, 1, 13, 28) === "neutral", "Februar, Tag 13 -> neutral");
|
||
|
||
ok(mz.stufenText("rot", 0) === "Dringend – heute ist der letzte Tag",
|
||
"der letzte Tag bekommt seinen eigenen Satz");
|
||
ok(mz.stufenText("rot", 1) === "Dringend – noch 1 Tag", "Einzahl bei einem Tag");
|
||
ok(mz.stufenText("rot", 5) === "Dringend – noch 5 Tage", "Mehrzahl ab zwei Tagen");
|
||
ok(mz.stufenText("orange", 9) === "Sollte bis Monatsmitte erledigt sein",
|
||
"der Orange-Satz steht woertlich wie in der Vorlage");
|
||
ok(mz.stufenText("neutral", 20) === "", "neutral sagt ausdruecklich nichts");
|
||
|
||
ok(mz.schlechteste(["gruen", "neutral", "rot"]) === "rot",
|
||
"die Kachel traegt die schlechteste Farbe");
|
||
ok(mz.schlechteste(["gruen", "aus"]) === "gruen",
|
||
"eine abgeschaltete Aufgabe verschlechtert nichts");
|
||
|
||
melde("\n=== Monatsrechnung ===");
|
||
ok(mz.letzterTagVon("2026-02") === 28, "Februar 2026 hat 28 Tage");
|
||
ok(mz.letzterTagVon("2024-02") === 29, "Februar 2024 hat 29 Tage");
|
||
ok(mz.letzterTagVon("2026-10") === 31, "Oktober hat 31 Tage");
|
||
ok(mz.monatPlus("2026-12", 1) === "2027-01", "Dezember + 1 = Januar des Folgejahres");
|
||
ok(mz.monatPlus("2026-01", -1) === "2025-12", "Januar - 1 = Dezember des Vorjahres");
|
||
/* Die Zeitzone: ein Zeitpunkt, der in UTC noch zum Vortag gehoert,
|
||
aber in Berlin schon zum naechsten Tag. Ohne Europe/Berlin faende
|
||
diese Zeile den falschen Tag -- und am Monatsersten den falschen
|
||
Monat. */
|
||
ok(mz.tagBerlin(new Date("2026-06-30T23:30:00Z")) === "2026-07-01",
|
||
"23:30 UTC am 30.06. ist in Berlin schon der 1. Juli");
|
||
|
||
/* =====================================================================
|
||
3 · EINTRAGEN
|
||
===================================================================== */
|
||
melde("\n=== Eintragen ===");
|
||
const standVorher = await (await hol("scout", `${API}/stand`)).json();
|
||
braucht(standVorher && Array.isArray(standVorher.aufgaben),
|
||
"der Stand kam nicht als Liste zurueck");
|
||
const MONAT = standVorher.monat;
|
||
const HEUTE = standVorher.heute;
|
||
ok(standVorher.aufgaben.length === 4, `vier Aufgaben (${standVorher.aufgaben.length})`);
|
||
ok(standVorher.pflichtig === true, "ein ein Jahr alter Scout ist pflichtig");
|
||
|
||
const vorherCreator = standVorher.aufgaben.find((a) => a.schluessel === "creator");
|
||
ok(vorherCreator.ziel === 3, `Vorgabe fuer Creator ist 3 (${vorherCreator.ziel})`);
|
||
ok(vorherCreator.zahl === 0, "noch nichts eingetragen");
|
||
|
||
const neu1 = await schick("scout", `${API}/eintrag`, "POST",
|
||
{ aufgabe: "creator", datum: HEUTE, name: "@LunaTanzt", notiz: "über Discord gefunden" });
|
||
const neu1d = await neu1.json();
|
||
ok(neu1.status === 201, `Creator-Eintrag angelegt (${neu1.status})`);
|
||
ok(neu1d.stand?.aufgaben?.find((a) => a.schluessel === "creator")?.zahl === 1,
|
||
"der Zaehler steht sofort auf 1 (ohne Neuladen)");
|
||
|
||
for (const [aufgabe, rumpf] of [
|
||
["meeting", { datum: HEUTE }],
|
||
["schulung", { datum: HEUTE, art: "talk" }],
|
||
["werbung", { datum: HEUTE, art: "agentur", link: "https://www.tiktok.com/@dogi/video/123" }],
|
||
]) {
|
||
const a = await schick("scout", `${API}/eintrag`, "POST", { aufgabe, ...rumpf });
|
||
ok(a.status === 201, `${aufgabe}: angelegt (${a.status})`);
|
||
}
|
||
|
||
const standNachher = await (await hol("scout", `${API}/stand`)).json();
|
||
ok(standNachher.gesamt.erledigt === 4,
|
||
`Gesamtfortschritt 4 von 8 (${standNachher.gesamt.erledigt} von ${standNachher.gesamt.ziel})`);
|
||
ok(standNachher.gesamt.ziel === 8, "Zielsumme 3+2+2+1 = 8");
|
||
ok(standNachher.aufgaben.find((a) => a.schluessel === "werbung").stufe === "gruen",
|
||
"Werbung (1 von 1) steht auf gruen");
|
||
|
||
/* =====================================================================
|
||
4 · WAS ABGELEHNT WERDEN MUSS — die Gegenproben
|
||
===================================================================== */
|
||
melde("\n=== Abgelehnt wird, was abgelehnt gehoert ===");
|
||
const morgen = new Date(Date.parse(HEUTE + "T12:00:00Z") + 86400_000).toISOString().slice(0, 10);
|
||
const fremderMonat = `${mz.monatPlus(MONAT, -1)}-15`;
|
||
|
||
const absagen = [
|
||
["Datum in der Zukunft", { aufgabe: "meeting", datum: morgen }, "datum_zukunft"],
|
||
["Datum aus dem Vormonat", { aufgabe: "meeting", datum: fremderMonat }, "datum_fremder_monat"],
|
||
["gar kein Datum", { aufgabe: "meeting", datum: "" }, "datum_fehlt"],
|
||
["Creator ohne Namen", { aufgabe: "creator", datum: HEUTE, name: " " }, "name_fehlt"],
|
||
["Werbung ohne Link", { aufgabe: "werbung", datum: HEUTE, art: "eigen", link: "" }, "link_ungueltig"],
|
||
["Werbung mit javascript:", { aufgabe: "werbung", datum: HEUTE, art: "eigen",
|
||
link: "javascript:alert(1)" }, "link_ungueltig"],
|
||
["Werbung mit blossem Wort", { aufgabe: "werbung", datum: HEUTE, art: "eigen",
|
||
link: "tiktok" }, "link_ungueltig"],
|
||
["Schulung ohne Art", { aufgabe: "schulung", datum: HEUTE, art: "" }, "art_fehlt"],
|
||
["Aufgabe, die es nicht gibt", { aufgabe: "kaffee", datum: HEUTE }, "aufgabe_unbekannt"],
|
||
];
|
||
let abgelehnt = 0;
|
||
for (const [was, rumpf, grund] of absagen) {
|
||
const a = await schick("scout", `${API}/eintrag`, "POST", rumpf);
|
||
const j = await a.json().catch(() => ({}));
|
||
const richtig = a.status === 400 && j.fehler === grund;
|
||
if (richtig) abgelehnt++;
|
||
ok(richtig, `${was} -> abgelehnt mit „${grund}" (${a.status}/${j.fehler})`);
|
||
}
|
||
ok(abgelehnt === absagen.length,
|
||
`alle ${absagen.length} Absagen kamen mit dem richtigen Grund (${abgelehnt})`);
|
||
|
||
/* EINE GUELTIGE FREMDE ADRESSE MUSS DURCH -- Filipe am 02.10.2026:
|
||
„jede gültige Internetadresse". Ohne diese Zeile bewiese der Block
|
||
darueber nur, dass die Pruefung streng ist, nicht dass sie richtig
|
||
ist. */
|
||
const fremdLink = await schick("scout", `${API}/eintrag`, "POST",
|
||
{ aufgabe: "werbung", datum: HEUTE, art: "eigen", link: "https://www.instagram.com/p/abc" });
|
||
ok(fremdLink.status === 201,
|
||
`eine Instagram-Adresse wird angenommen (${fremdLink.status}) — nicht nur TikTok`);
|
||
|
||
melde("\n=== Dubletten ===");
|
||
const doppelt = await schick("scout", `${API}/eintrag`, "POST",
|
||
{ aufgabe: "creator", datum: HEUTE, name: "lunatanzt" });
|
||
const doppeltD = await doppelt.json().catch(() => ({}));
|
||
ok(doppelt.status === 409 && doppeltD.fehler === "schon_eingetragen",
|
||
`„lunatanzt" gilt als derselbe wie „@LunaTanzt" (${doppelt.status})`);
|
||
|
||
const anderer = await schick("scout2", `${API}/eintrag`, "POST",
|
||
{ aufgabe: "creator", datum: HEUTE, name: "@LunaTanzt" });
|
||
const andererD = await anderer.json().catch(() => ({}));
|
||
ok(anderer.status === 201, `eine ANDERE Person darf denselben Namen eintragen (${anderer.status})`);
|
||
ok(!!andererD.warnung, "…bekommt aber einen Hinweis, dass es jemand anders auch hat");
|
||
|
||
const neuerName = await schick("scout", `${API}/eintrag`, "POST",
|
||
{ aufgabe: "creator", datum: HEUTE, name: "@ZweiterCreator" });
|
||
ok(neuerName.status === 201, `ein anderer Name geht weiterhin (${neuerName.status})`);
|
||
|
||
/* =====================================================================
|
||
5 · AENDERN UND LOESCHEN
|
||
===================================================================== */
|
||
melde("\n=== Aendern und Loeschen ===");
|
||
const liste = await (await hol("scout", `${API}/eintraege?monat=${MONAT}&aufgabe=creator`)).json();
|
||
braucht(liste.eintraege?.length >= 2, "es gibt zu wenige Eintraege zum Aendern");
|
||
const einId = liste.eintraege.find((e) => e.name === "@ZweiterCreator").id;
|
||
|
||
const geaendert = await schick("scout", `${API}/eintrag/${einId}`, "PATCH",
|
||
{ datum: HEUTE, name: "@ZweiterCreatorNeu", notiz: "Name berichtigt" });
|
||
ok(geaendert.status === 200, `eigener Eintrag geaendert (${geaendert.status})`);
|
||
|
||
const fremdAendern = await schick("manager", `${API}/eintrag/${einId}`, "PATCH",
|
||
{ datum: HEUTE, name: "@Geklaut" });
|
||
ok(fremdAendern.status === 403,
|
||
`ein Manager kann einen fremden Eintrag NICHT aendern (${fremdAendern.status})`);
|
||
|
||
const adminAendern = await schick("admin", `${API}/eintrag/${einId}`, "PATCH",
|
||
{ datum: HEUTE, name: "@VonDogfatherBerichtigt" });
|
||
ok(adminAendern.status === 200, `DogFather darf korrigieren (${adminAendern.status})`);
|
||
|
||
const dd = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
|
||
const protokolliert = dd.prepare(
|
||
"SELECT COUNT(*) n FROM protokoll WHERE aktion = 'manager_ziele_korrigiert'").get().n;
|
||
dd.close();
|
||
ok(protokolliert >= 1, `jede Korrektur steht im Protokoll (${protokolliert})`);
|
||
|
||
const fremdLoeschen = await hol("manager", `${API}/eintrag/${einId}`, { method: "DELETE" });
|
||
ok(fremdLoeschen.status === 403,
|
||
`ein Manager kann einen fremden Eintrag NICHT loeschen (${fremdLoeschen.status})`);
|
||
|
||
const vorLoeschen = await (await hol("scout", `${API}/stand`)).json();
|
||
const geloescht = await hol("scout", `${API}/eintrag/${einId}`, { method: "DELETE" });
|
||
const geloeschtD = await geloescht.json().catch(() => ({}));
|
||
ok(geloescht.status === 200, `eigener Eintrag geloescht (${geloescht.status})`);
|
||
ok(geloeschtD.stand?.aufgaben?.find((a) => a.schluessel === "creator")?.zahl
|
||
=== vorLoeschen.aufgaben.find((a) => a.schluessel === "creator").zahl - 1,
|
||
"der Zaehler geht nach dem Loeschen um genau eins zurueck");
|
||
|
||
/* =====================================================================
|
||
6 · DER MONATSSCHNITT — die Sperre muss wirklich sperren
|
||
===================================================================== */
|
||
melde("\n=== Vergangene Monate sind zu ===");
|
||
const VORMONAT = mz.monatPlus(MONAT, -1);
|
||
|
||
/* Eine Zeile aus dem Vormonat einsetzen. Das geht NUR mit geoeffneter
|
||
Freigabe -- und genau das ist schon die erste Gegenprobe: Ohne sie
|
||
lehnt der Trigger ab. */
|
||
const db2 = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
let triggerHaelt = false;
|
||
try {
|
||
db2.prepare("INSERT INTO mz_eintrag (person_id, aufgabe, monat, datum, erstellt)"
|
||
+ " VALUES (?,?,?,?,?)").run(IDS.scout, "meeting", VORMONAT, `${VORMONAT}-05`, jetztIso);
|
||
} catch (f) {
|
||
triggerHaelt = String(f?.message || "").includes("monat_gesperrt");
|
||
}
|
||
ok(triggerHaelt,
|
||
"die DATENBANK lehnt einen Eintrag im Vormonat ab (nicht erst der Code)");
|
||
|
||
const weit = new Date(Date.now() + 600_000).toISOString().replace("T", " ").slice(0, 19);
|
||
db2.prepare("UPDATE mz_freigabe SET offen = 1, bis = ? WHERE eins = 1").run(weit);
|
||
db2.prepare("INSERT INTO mz_eintrag (person_id, aufgabe, monat, datum, erstellt)"
|
||
+ " VALUES (?,?,?,?,?)").run(IDS.scout, "meeting", VORMONAT, `${VORMONAT}-05`, jetztIso);
|
||
const altId = db2.prepare("SELECT last_insert_rowid() AS id").get().id;
|
||
db2.prepare("UPDATE mz_freigabe SET offen = 0, bis = NULL WHERE eins = 1").run();
|
||
db2.close();
|
||
braucht(!!altId, "es liess sich keine Zeile im Vormonat anlegen");
|
||
|
||
const altAendern = await schick("scout", `${API}/eintrag/${altId}`, "PATCH",
|
||
{ datum: `${VORMONAT}-06` });
|
||
ok(altAendern.status === 409,
|
||
`ein Scout kann im Vormonat nichts mehr aendern (${altAendern.status})`);
|
||
const altLoeschen = await hol("scout", `${API}/eintrag/${altId}`, { method: "DELETE" });
|
||
ok(altLoeschen.status === 409,
|
||
`…und auch nichts loeschen (${altLoeschen.status})`);
|
||
|
||
const altAdmin = await schick("admin", `${API}/eintrag/${altId}`, "PATCH",
|
||
{ datum: `${VORMONAT}-07`, notiz: "Korrektur im Nachhinein" });
|
||
ok(altAdmin.status === 200,
|
||
`DogFather darf auch im Vormonat korrigieren (${altAdmin.status})`);
|
||
|
||
/* UND DIE FREIGABE IST DANACH WIEDER ZU. Ein Schloss, das offen
|
||
bleibt, ist dasselbe wie keines. */
|
||
const db3 = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
|
||
const freigabe = db3.prepare("SELECT offen FROM mz_freigabe WHERE eins = 1").get();
|
||
db3.close();
|
||
ok(freigabe.offen === 0, `die Freigabe steht nach der Korrektur wieder auf zu (${freigabe.offen})`);
|
||
|
||
const altNochmal = await schick("scout", `${API}/eintrag/${altId}`, "PATCH",
|
||
{ datum: `${VORMONAT}-08` });
|
||
ok(altNochmal.status === 409,
|
||
`der Scout kommt auch danach nicht hinein (${altNochmal.status}) — die Freigabe wirkte nur einmal`);
|
||
|
||
/* =====================================================================
|
||
7 · DIE ZIELZAHLEN
|
||
===================================================================== */
|
||
melde("\n=== Zielzahlen: aenderbar, aber erst ab naechstem Monat ===");
|
||
const zieleScout = await hol("scout", `${API}/ziele`);
|
||
ok(zieleScout.status === 403, `ein Scout sieht die Zielzahlen nicht (${zieleScout.status})`);
|
||
const zieleManager = await hol("manager", `${API}/ziele`);
|
||
ok(zieleManager.status === 403, `ein Manager auch nicht (${zieleManager.status})`);
|
||
|
||
for (const r of ["admin", "spicy"]) {
|
||
const a = await hol(r, `${API}/ziele`);
|
||
ok(a.status === 200, `${r} darf die Zielzahlen sehen (${a.status})`);
|
||
}
|
||
|
||
const vorAenderung = await (await hol("scout", `${API}/stand`)).json();
|
||
const zielVorher = vorAenderung.aufgaben.find((a) => a.schluessel === "creator").ziel;
|
||
|
||
const gesetzt = await schick("spicy", `${API}/ziele`, "PUT",
|
||
{ ziele: { scout: { creator: 9 }, admin: { creator: 0 } } });
|
||
const gesetztD = await gesetzt.json().catch(() => ({}));
|
||
ok(gesetzt.status === 200, `Spicy Media darf die Zielzahlen setzen (${gesetzt.status})`);
|
||
ok(gesetztD.monat === mz.monatPlus(MONAT, 1),
|
||
`gespeichert wird fuer den NAECHSTEN Monat (${gesetztD.monat})`);
|
||
|
||
const nachAenderung = await (await hol("scout", `${API}/stand`)).json();
|
||
ok(nachAenderung.aufgaben.find((a) => a.schluessel === "creator").ziel === zielVorher,
|
||
`der laufende Monat bleibt bei ${zielVorher} — eine Aenderung wirkt NICHT rueckwirkend`);
|
||
|
||
const zieleJetzt = await (await hol("admin", `${API}/ziele`)).json();
|
||
ok(zieleJetzt.naechster.find((r) => r.rolle === "scout").ziele.creator === 9,
|
||
"im naechsten Monat steht beim Scout die 9");
|
||
ok(zieleJetzt.jetzt.find((r) => r.rolle === "scout").ziele.creator === zielVorher,
|
||
"im laufenden Monat steht dort weiterhin die alte Zahl");
|
||
|
||
const unsinn = await schick("admin", `${API}/ziele`, "PUT", { ziele: { scout: { creator: 500 } } });
|
||
ok(unsinn.status === 400, `eine Zielzahl von 500 wird abgelehnt (${unsinn.status})`);
|
||
const negativ = await schick("admin", `${API}/ziele`, "PUT", { ziele: { scout: { creator: -1 } } });
|
||
ok(negativ.status === 400, `eine negative Zielzahl wird abgelehnt (${negativ.status})`);
|
||
|
||
/* =====================================================================
|
||
8 · DIE TEAM-UEBERSICHT UND DER EXPORT
|
||
===================================================================== */
|
||
melde("\n=== Team-Uebersicht ===");
|
||
for (const r of ["manager", "scout"]) {
|
||
const a = await hol(r, `${API}/team`);
|
||
ok(a.status === 403, `${r} sieht die Team-Uebersicht nicht (${a.status})`);
|
||
}
|
||
const team = await hol("admin", `${API}/team`);
|
||
const teamD = await team.json();
|
||
ok(team.status === 200, `DogFather sieht die Team-Uebersicht (${team.status})`);
|
||
ok(teamD.leute.length === 5,
|
||
`fuenf pflichtige Personen in der Liste (${teamD.leute.length}) — Creator, Hand und Modi fehlen zu Recht`);
|
||
ok(teamD.leute.every((p) => ["spicy", "admin", "manager", "scout"].includes(p.rolle)),
|
||
"und keine einzige fremde Rolle darunter");
|
||
|
||
const spicyTeam = await hol("spicy", `${API}/team`);
|
||
ok(spicyTeam.status === 200, `Spicy Media ebenfalls (${spicyTeam.status})`);
|
||
|
||
const fremdeSicht = await hol("scout", `${API}/stand?person=${IDS.scout2}`);
|
||
const fremdeSichtD = await fremdeSicht.json();
|
||
ok(fremdeSichtD.person?.id === IDS.scout,
|
||
"ein Scout, der eine fremde Nummer in die Adresse schreibt, sieht trotzdem nur sich selbst");
|
||
|
||
melde("\n=== CSV-Export ===");
|
||
const csvScout = await hol("scout", `${API}/export.csv`);
|
||
ok(csvScout.status === 403, `ein Scout bekommt keinen Export (${csvScout.status})`);
|
||
const csv = await hol("admin", `${API}/export.csv?monat=${MONAT}`);
|
||
/* IN BYTES GEMESSEN, nicht in Zeichen. `Response.text()` entfernt ein
|
||
fuehrendes BOM beim Dekodieren -- die Pruefung meldete deshalb beim
|
||
ersten Lauf "kein BOM", obwohl es da war. Das war ein Fehler an der
|
||
Messung, nicht am Export. */
|
||
const csvBytes = new Uint8Array(await csv.clone().arrayBuffer());
|
||
const csvText = await csv.text();
|
||
ok(csv.status === 200, `DogFather bekommt den Export (${csv.status})`);
|
||
ok(csvBytes[0] === 0xEF && csvBytes[1] === 0xBB && csvBytes[2] === 0xBF,
|
||
`die Datei beginnt mit dem BOM (${[...csvBytes.slice(0, 3)].map((b) => b.toString(16)).join(" ")}) — sonst zeigt deutsches Excel kaputte Umlaute`);
|
||
ok(csvText.split("\n")[0].includes(";"),
|
||
"getrennt wird mit Semikolon — sonst steht alles in einer Spalte");
|
||
const csvZeilen = csvText.trim().split(/\r?\n/);
|
||
ok(csvZeilen.length === teamD.leute.length + 1,
|
||
`eine Kopfzeile und ${teamD.leute.length} Personen (${csvZeilen.length} Zeilen)`);
|
||
ok((csv.headers.get("content-disposition") || "").includes(`manager-ziele-${MONAT}.csv`),
|
||
"der Dateiname trägt den Monat");
|
||
|
||
/* =====================================================================
|
||
9 · DIE PIPELINE-BRUECKE
|
||
===================================================================== */
|
||
melde("\n=== Die Bruecke zur Scout-Pipeline ===");
|
||
const db4 = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
db4.prepare(`INSERT INTO leads (name, handle, status, scout_id, erstellt, erstellt_von, uebergeben_am)
|
||
VALUES (?,?,?,?,?,?,?)`)
|
||
.run("Mara K.", "@maratanzt", "uebergeben", IDS.scout, jetztIso, IDS.scout, `${HEUTE}T10:00:00Z`);
|
||
const leadId = db4.prepare("SELECT last_insert_rowid() AS id").get().id;
|
||
/* Ein Lead, der jemand ANDEREM gehoert -- fuer die Gegenprobe. */
|
||
db4.prepare(`INSERT INTO leads (name, handle, status, scout_id, erstellt, erstellt_von, uebergeben_am)
|
||
VALUES (?,?,?,?,?,?,?)`)
|
||
.run("Fremd F.", "@fremd", "uebergeben", IDS.scout2, jetztIso, IDS.scout2, `${HEUTE}T10:00:00Z`);
|
||
const fremdLeadId = db4.prepare("SELECT last_insert_rowid() AS id").get().id;
|
||
db4.close();
|
||
braucht(!!leadId && !!fremdLeadId, "die Leads liessen sich nicht anlegen");
|
||
|
||
const vorschlaege = await (await hol("scout", `${API}/vorschlaege`)).json();
|
||
ok(vorschlaege.vorschlaege.some((v) => v.id === leadId),
|
||
"der eigene uebergebene Lead steht als Vorschlag da");
|
||
ok(!vorschlaege.vorschlaege.some((v) => v.id === fremdLeadId),
|
||
"ein fremder Lead steht NICHT darin");
|
||
|
||
const uebernommen = await schick("scout", `${API}/eintrag`, "POST",
|
||
{ aufgabe: "creator", datum: HEUTE, name: "@maratanzt", lead_id: leadId });
|
||
ok(uebernommen.status === 201, `der Lead laesst sich uebernehmen (${uebernommen.status})`);
|
||
|
||
const danach = await (await hol("scout", `${API}/vorschlaege`)).json();
|
||
ok(!danach.vorschlaege.some((v) => v.id === leadId),
|
||
"…und verschwindet danach aus den Vorschlaegen");
|
||
|
||
/* GEGENPROBE: Eine fremde Lead-Nummer im Rumpf darf nicht uebernommen
|
||
werden -- der Eintrag entsteht, aber OHNE die Verbindung. Eine
|
||
Nummer in einem Formular ist kein Besitznachweis. */
|
||
const mitFremd = await schick("scout", `${API}/eintrag`, "POST",
|
||
{ aufgabe: "creator", datum: HEUTE, name: "@nochwer", lead_id: fremdLeadId });
|
||
ok(mitFremd.status === 201, `der Eintrag entsteht trotzdem (${mitFremd.status})`);
|
||
const db5 = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
|
||
const ohneVerbindung = db5.prepare(
|
||
"SELECT lead_id FROM mz_eintrag WHERE name = ?").get("@nochwer");
|
||
const mitVerbindung = db5.prepare(
|
||
"SELECT lead_id FROM mz_eintrag WHERE name = ?").get("@maratanzt");
|
||
db5.close();
|
||
ok(ohneVerbindung?.lead_id === null,
|
||
"…aber die fremde Lead-Verbindung wird verworfen");
|
||
ok(mitVerbindung?.lead_id === leadId,
|
||
"die eigene Verbindung dagegen bleibt gespeichert");
|
||
|
||
const treffer = await (await hol("scout", `${API}/namen?q=mara`)).json();
|
||
ok(treffer.treffer.some((t) => t.id === leadId),
|
||
"beim Tippen schlaegt die eigene Pipeline den Namen vor");
|
||
const trefferFremd = await (await hol("scout", `${API}/namen?q=fremd`)).json();
|
||
ok(!trefferFremd.treffer.length,
|
||
"fremde Leads werden beim Tippen NICHT vorgeschlagen");
|
||
|
||
/* =====================================================================
|
||
10 · DIE ERINNERUNGEN
|
||
===================================================================== */
|
||
melde("\n=== Die Erinnerungen (eingesetzte Tage) ===");
|
||
const { ARTEN } = await import("./workspace-push.js");
|
||
ok(ARTEN.some((a) => a.schluessel === "manager_ziele"),
|
||
"es gibt eine eigene, abschaltbare Benachrichtigungsart");
|
||
|
||
/* `zielRufe` bekommt das Datum als Argument -- dadurch misst diese
|
||
Prüfung dasselbe, egal an welchem Tag sie läuft. Gerechnet wird in
|
||
Berlin, deshalb 12:00 UTC: Da ist der Tag in beiden Zeitzonen
|
||
derselbe. */
|
||
const amTag = (tag) => new Date(`${MONAT}-${String(tag).padStart(2, "0")}T12:00:00Z`);
|
||
const letzterTag = mz.letzterTagVon(MONAT);
|
||
|
||
const rufe1 = mz.zielRufe(amTag(1));
|
||
ok(rufe1.length > 0, `am 1. geht eine Meldung an alle mit offenen Zielen (${rufe1.length})`);
|
||
ok(rufe1.every((r) => r.merkmal.includes(`${MONAT}-01`) || r.merkmal.endsWith(":fertig")),
|
||
"das Merkmal enthaelt den TAG — dadurch kann es hoechstens eine pro Tag geben");
|
||
ok(rufe1.some((r) => r.titel === "Neuer Monat"), "…mit dem Titel aus der Vorlage");
|
||
ok(rufe1.every((r) => r.ziel === "/workspace/manager-ziele.html"),
|
||
"jede Meldung fuehrt direkt zur Kachel");
|
||
|
||
const RUF_TAGE = [
|
||
[1, "Neuer Monat"], [10, "Kurze Erinnerung"],
|
||
[15, "Heute ist Stichtag Monatsmitte"], [16, "Monatsmitte ist vorbei"],
|
||
[letzterTag - 7, "Dringend – noch 7 Tage"],
|
||
[letzterTag - 2, "Noch 2 Tage"], [letzterTag - 1, "Noch 1 Tag"],
|
||
[letzterTag, "Letzter Tag des Monats"],
|
||
];
|
||
let getroffen = 0;
|
||
for (const [tag, titel] of RUF_TAGE) {
|
||
const r = mz.zielRufe(amTag(tag)).filter((x) => !x.merkmal.endsWith(":fertig"));
|
||
const passt = r.some((x) => x.titel === titel);
|
||
if (passt) getroffen++;
|
||
ok(passt, `Tag ${tag}: „${titel}" (${r[0]?.titel || "nichts"})`);
|
||
}
|
||
ok(getroffen === RUF_TAGE.length,
|
||
`alle ${RUF_TAGE.length} Anlaesse der Vorlage sind belegt (${getroffen})`);
|
||
|
||
/* GEGENPROBE: An einem Tag OHNE Anlass darf nichts herausgehen. Ohne
|
||
diese Zeile bewiese der Block darueber nur, dass immer etwas kommt. */
|
||
const stillerTag = mz.zielRufe(amTag(7)).filter((x) => !x.merkmal.endsWith(":fertig"));
|
||
ok(stillerTag.length === 0,
|
||
`am 7. ist Ruhe (${stillerTag.length} Meldungen) — es wird nicht jeden Tag gemahnt`);
|
||
|
||
/* UND WER ALLES HAT, BEKOMMT GENAU EINEN GLUECKWUNSCH. Dafuer wird
|
||
einer Person alles abgenommen: Ziel 0 ueberall heisst „nichts
|
||
offen". */
|
||
const db6 = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
for (const a of ["creator", "meeting", "schulung", "werbung"]) {
|
||
db6.prepare(`INSERT INTO mz_ziel (monat, rolle, aufgabe, ziel, gesetzt_am)
|
||
VALUES (?,?,?,?,?)
|
||
ON CONFLICT(monat, rolle, aufgabe) DO UPDATE SET ziel = 0`)
|
||
.run(MONAT, "manager", a, 0, jetztIso);
|
||
}
|
||
db6.close();
|
||
const fertig = mz.zielRufe(amTag(10)).filter((r) => r.personId === IDS.manager);
|
||
ok(fertig.length === 0,
|
||
"wer gar keine Ziele hat, bekommt weder Mahnung noch Glueckwunsch");
|
||
|
||
/* =====================================================================
|
||
11 · DIE HINWEISE AUF DER STARTSEITE
|
||
===================================================================== */
|
||
melde("\n=== Die Zahl auf der Kachel ===");
|
||
const hinweise = await (await hol("scout", "/workspace/api/hinweise")).json();
|
||
const meine = (hinweise.hinweise || []).filter((h) => String(h.art).startsWith("mz_"));
|
||
ok(meine.length > 0, `der Scout bekommt einen Hinweis zu den Monatszielen (${meine.length})`);
|
||
ok(meine.every((h) => h.ziel === "manager-ziele.html"),
|
||
"…und er fuehrt auf die richtige Seite");
|
||
|
||
const hinweiseCreator = await (await hol("creator", "/workspace/api/hinweise")).json();
|
||
const creatorMz = (hinweiseCreator.hinweise || []).filter((h) => String(h.art).startsWith("mz_"));
|
||
ok(creatorMz.length === 0,
|
||
`ein Creator bekommt keinen (${creatorMz.length}) — kein Weg zu einer Seite, die er nicht hat`);
|
||
|
||
/* GEGENPROBE: Die Summe der Hinweise muss zur Zahl der offenen
|
||
Aufgaben passen. Zwei Zaehler waeren zwei Wahrheiten. */
|
||
const standJetzt = await (await hol("scout", `${API}/stand`)).json();
|
||
const summe = meine.reduce((s, h) => s + h.anzahl, 0);
|
||
ok(summe === standJetzt.gesamt.offen,
|
||
`die Kachelzahl (${summe}) ist dieselbe wie auf der Seite (${standJetzt.gesamt.offen})`);
|
||
|
||
/* =====================================================================
|
||
12 · WER NEU DAZUKOMMT, WIRD NICHT GEMAHNT
|
||
===================================================================== */
|
||
melde("\n=== Wer im Laufe des Monats dazukommt ===");
|
||
const dbNeu = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const heuteNr = Number(HEUTE.slice(8, 10));
|
||
dbNeu.close();
|
||
|
||
const neuerCode = "CODE-Z99-000001";
|
||
const dbA = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const salt = randomBytes(16).toString("hex");
|
||
const hash = scryptSync(neuerCode, salt, 64,
|
||
{ N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
|
||
dbA.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n,"
|
||
+ " code_kennung, aktiv, erstellt) VALUES (?,?,?,?,?,?,1,?)")
|
||
.run("Ganz Neu", "scout", hash, salt, 32768,
|
||
createHmac("sha256", kennSchluessel).update(neuerCode).digest("hex"),
|
||
`${HEUTE}T09:00:00Z`);
|
||
const neuId = dbA.prepare("SELECT last_insert_rowid() AS id").get().id;
|
||
dbA.close();
|
||
CODES.scout3 = neuerCode;
|
||
kekse.scout3 = await anmelden("scout3", "scout");
|
||
braucht(!!kekse.scout3, "der neue Scout konnte sich nicht anmelden");
|
||
|
||
const standNeu = await (await hol("scout3", `${API}/stand`)).json();
|
||
if (heuteNr === 1) {
|
||
ok(standNeu.pflichtig === true,
|
||
"wer am 1. dazukommt, ist sofort pflichtig — er hat den vollen Monat");
|
||
} else {
|
||
ok(standNeu.pflichtig === false,
|
||
`wer am ${heuteNr}. dazukommt, bekommt diesen Monat keine Warnungen`);
|
||
const rufeNeu = mz.zielRufe(amTag(Math.max(heuteNr, 16)))
|
||
.filter((r) => r.personId === neuId);
|
||
ok(rufeNeu.length === 0, "…und auch keine Erinnerung");
|
||
ok(standNeu.aufgaben.every((a) => a.stufe === "neutral" || a.stufe === "aus"),
|
||
"…alle seine Zeilen stehen auf neutral, keine einzige warnt");
|
||
}
|
||
|
||
/* =====================================================================
|
||
SCHLUSS
|
||
===================================================================== */
|
||
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
|
||
melde(`\n${geprueft} Pruefungen, ${fehler} Fehler`);
|
||
process.exit(fehler ? 1 : 0);
|