DogFatherGitandClaude Opus 5
b85740dc20
Filipe: "ich will dass du die 2 kategorien perfektionnierst. ich will
die noch viel besser, perfektionniert, viel geiler und krasser. es
soll so einfach wie moeglich sein fuer jeden."
Die AUSWAHL war der gut gebaute Teil dieser Seite: 21 Merkmale, sechs
Warnzeichen, ein Trichter mit Standzeiten. Die Stelle, an der Teams
tatsaechlich Leute verlieren, liegt dahinter -- zwischen dem "ja" und
der ersten echten Schicht. Wer zusagt und danach zwei Wochen nichts
hoert, hat innerlich schon abgesagt, und auf der Karte steht weiter
"angesprochen".
In der Beschreibung der Stufe "Probe" stand seit dem ersten Tag
"fester Buddy". Ein Feld dafuer gab es nicht. Ein Versprechen im Text
ist keine Eigenschaft des Systems -- erst eine Regel, die NEIN sagen
kann, ist eine.
Ab jetzt:
- Auf die Probe kommt niemand ohne einen Namen und ein Datum. Die
Absage sagt, welches von beiden fehlt, und die Karte bleibt dabei
stehen, wo sie war.
- Die Karte zeigt beides: wer einarbeitet, wann die erste Schicht
ist -- in einem Satz, den man laut vorlesen kann ("Erste Schicht
ist morgen."). Ein Termin weiter als 14 Tage ist erlaubt, wird
aber benannt.
- Drei Dinge fuer den ersten Tag stehen auf der Probekarte: was
gilt, was du darfst, wen du fragst. Keine Haken -- der Buddy soll
sie lesen, nicht abarbeiten.
- Buddy und Termin lassen sich spaeter aendern, OHNE die Standzeit
zurueckzusetzen: Sie ist die Auskunft ueber uns, nicht ueber den
Kandidaten.
- Wer geht, ist kein Buddy mehr -- stillgelegt wie geloescht. Die
Karte sagt dann "bitte neu bestimmen" und ist am Rand markiert.
Recherche (Quellen im Kopf von workspace-talent-punkte.js): Discord
nennt Buddy und Mentoring als die beiden Trainingswege, die
funktionieren; aus der Freiwilligenarbeit kommt dieselbe Aussage mit
Zahlen. Und: Am ersten Tag braucht jemand drei Dinge, nicht dreissig.
Was die Pruefung gefunden hat: buddy_weg fragte "buddy_id gesetzt UND
Person weg" -- damit war der zweite Weg blind. Wird ein Mensch
geloescht, setzt ON DELETE SET NULL die Spalte auf NULL, die Karte sah
unauffaellig aus, und eine laufende Probe stand ohne jeden Buddy da.
server/pruef-uebergang.mjs 61 Pruefungen, 0 Fehler (Port 4420)
pruef-nachwuchs 123, pruef-entwicklung 43, pruef-css-klassen -- 0 Fehler
Co-Authored-By: Claude Opus 5 <[email protected]>
936 lines
41 KiB
JavaScript
936 lines
41 KiB
JavaScript
/* =====================================================================
|
||
Entwicklung & Nachwuchs — die Mechanik (11.09.2026)
|
||
=====================================================================
|
||
|
||
Filipe: *„ich will dass diese zwei kategorien perfektionniert werden,
|
||
ich will dass fertige aufgaben da stehen und so … so dass dogfather
|
||
und rechte hand es so einfach wie möglich haben aber so professionell
|
||
wie auch nur möglich."*
|
||
|
||
Die Kataloge stehen in workspace-entwicklungs-punkte.js und
|
||
workspace-talent-punkte.js. Hier steht, was mit ihnen passiert.
|
||
|
||
---------------------------------------------------------------------
|
||
EINE EIGENE TABELLE — UND WARUM DER PLAN DARIN FALSCH LAG
|
||
|
||
Der Plan im Vault sagt: „zwei Spalten, keine neue Tabelle" — der
|
||
Stand solle in `punkt_stand` liegen, derselben Tabelle wie die
|
||
Checkliste. Nachgemessen geht das NICHT:
|
||
|
||
PRIMARY KEY (bereich, schluessel, creator_id)
|
||
|
||
Es passt genau EIN Stand je Punkt und Person hinein. Der Kern dieses
|
||
Bereichs ist aber, dass DogFather und die rechte Hand UNABHAENGIG
|
||
voneinander setzen und die Abweichung das eigentliche Ergebnis ist.
|
||
Dafuer muesste der Schluessel um den Beurteiler wachsen — also ein
|
||
Tabellenneubau an lebenden Checklisten-Daten, fuer einen Zweck, der
|
||
mit der Checkliste nichts zu tun hat.
|
||
|
||
Deshalb eine eigene Tabelle. Der Plan war ein Wegweiser, keine
|
||
Wahrheit; gemessen wurde vor dem Bauen, nicht danach.
|
||
|
||
---------------------------------------------------------------------
|
||
DREI RIEGEL, DIE VON ANFANG AN STEHEN
|
||
|
||
1. BLOCK 5 GEHOERT DER PERSON. „Wie geht es dir damit?" beantwortet
|
||
nur sie selbst — lesend UND schreibend. Auch DogFather nicht. Was
|
||
nach aussen dringt, ist eine Ampel ohne Namen.
|
||
|
||
2. DER STAND DES ANDEREN KOMMT ERST NACH DEM EIGENEN. Wer zuerst
|
||
sieht, was der andere angeklickt hat, klickt dasselbe — das ist
|
||
kein Verdacht, sondern ein gut belegter Effekt. Er wird hier nicht
|
||
durch Disziplin verhindert, sondern dadurch, dass die Auskunft
|
||
erst gar nicht ausgeliefert wird.
|
||
|
||
3. TALENTE ENTHAELT NAMEN VON MENSCHEN, DIE NICHTS DAVON WISSEN.
|
||
Der Bereich gehoert DogFather und der rechten Hand. Kein Modi,
|
||
keine Agentur, und ganz sicher nicht die Community.
|
||
|
||
---------------------------------------------------------------------
|
||
UND EINE ABWEICHUNG VOM PLAN, DIE FILIPES SATZ GESCHULDET IST
|
||
|
||
Der Plan verlangt einen Anlass (die drei SBI-Felder) bei JEDEM Klick
|
||
ausser „kann ich nicht sagen". Bei 28 Punkten je Person waeren das 28
|
||
Textfelder — und „so einfach wie moeglich" war die andere Haelfte des
|
||
Auftrags. Pflicht ist der Anlass deshalb dort, wo er etwas
|
||
entscheidet: bei **„Da hakt es"**. Bei „Laeuft" und „Waechst gerade"
|
||
steht dasselbe Feld da, freiwillig — wer etwas Konkretes gesehen hat,
|
||
schreibt es hin, und beim Gespraech steht es da.
|
||
===================================================================== */
|
||
|
||
import express from "express";
|
||
import {
|
||
db, sitzungLesen, protokolliere, echteIp, fuehrtTeamDogi, ROLLEN_NAME,
|
||
ROLLEN_SORTIERUNG,
|
||
} from "./workspace.js";
|
||
import {
|
||
ENTWICKLUNG_BLOECKE, ENTWICKLUNG_PUNKTE, ENTWICKLUNG_STUFEN,
|
||
ENTWICKLUNG_ERWARTUNG, ENTWICKLUNG_FREMD, ENTWICKLUNG_SELBST,
|
||
ENTWICKLUNG_NACH_SCHLUESSEL,
|
||
} from "./workspace-entwicklungs-punkte.js";
|
||
import {
|
||
TALENT_STUFEN, TALENT_GRUPPEN, TALENT_MERKMALE, TALENT_WARNZEICHEN,
|
||
SCHICHT_WEIT_TAGE, SCHICHT_MAX_TAGE, ERSTER_TAG,
|
||
TALENT_NACH_SCHLUESSEL, talentStufe, talentNaechste, ansprechtext,
|
||
} from "./workspace-talent-punkte.js";
|
||
|
||
export const entwicklungRouter = express.Router();
|
||
|
||
const jetzt = () => new Date().toISOString();
|
||
const TAG = 86400000;
|
||
const ANLASS_MAX = 1200;
|
||
|
||
/* WANN EINE EINSCHAETZUNG VERBLASST.
|
||
Nach 90 Tagen zaehlt ein Stand nicht mehr als aktuell. Er wird NICHT
|
||
geloescht -- man soll sehen, dass etwas alt ist, statt dass es
|
||
verschwindet. Eine Akte, die alles behaelt, hat hier nichts zu
|
||
suchen; eine, die heimlich vergisst, auch nicht. */
|
||
export const VERBLASST_NACH_TAGEN = 90;
|
||
|
||
/* Die Rollen, ueber die eine Entwicklungskarte gefuehrt wird. Das Team
|
||
von Dogi -- nicht die Agentur, nicht die Community. Als Liste und
|
||
nicht als "alle ausser X": Eine neue Rolle soll hier NICHT
|
||
automatisch eine Personalakte bekommen. */
|
||
const KARTEN_ROLLEN = ["hand", "modi"];
|
||
|
||
/** Wer einen Neuen einarbeiten kann.
|
||
*
|
||
* DIESELBEN WIE BEI DER KARTE, PLUS DOGFATHER. Er steht nicht ueber
|
||
* dem Team, er gehoert dazu -- und wer eine Probe begleitet, macht
|
||
* dieselbe Arbeit wie alle anderen. Ein Manager oder Scout dagegen
|
||
* arbeitet im anderen Haus und kann niemanden durch eine Schicht
|
||
* begleiten, die er selbst nicht macht. */
|
||
const BUDDY_ROLLEN = ["admin", "hand", "modi"];
|
||
|
||
/* =====================================================================
|
||
DIE TABELLEN
|
||
===================================================================== */
|
||
|
||
let bereit = false;
|
||
/** Auch von der Befindensseite aufgerufen.
|
||
*
|
||
* Sie liest `entwicklung_stand`, legt die Tabelle aber nicht selbst an
|
||
* -- eine zweite Abschrift derselben Spalten waere die Liste, die beim
|
||
* naechsten Zuwachs auseinanderlaeuft. Gefunden hat das die Pruefung:
|
||
* Wer die neue Seite oeffnete, ohne dass vorher jemand die
|
||
* Entwicklungsseite besucht hatte, bekam "no such table". */
|
||
export function tabellen() {
|
||
if (bereit) return;
|
||
db().exec(`
|
||
/* Eine Einschaetzung: WER hat bei WEM zu WELCHEM Punkt was gesetzt.
|
||
|
||
Der Beurteiler steht IM Schluessel. Genau daran ist die Idee
|
||
gescheitert, dieselbe Tabelle wie die Checkliste zu benutzen --
|
||
dort passt nur ein Stand je Punkt und Person hinein. */
|
||
CREATE TABLE IF NOT EXISTS entwicklung_stand (
|
||
person_id INTEGER NOT NULL REFERENCES personen(id) ON DELETE CASCADE,
|
||
schluessel TEXT NOT NULL,
|
||
von_id INTEGER NOT NULL REFERENCES personen(id) ON DELETE CASCADE,
|
||
stufe TEXT NOT NULL CHECK (stufe IN ('laeuft','waechst','hakt','unklar')),
|
||
anlass TEXT,
|
||
am TEXT NOT NULL,
|
||
PRIMARY KEY (person_id, schluessel, von_id)
|
||
);
|
||
CREATE INDEX IF NOT EXISTS idx_entwicklung_person
|
||
ON entwicklung_stand (person_id, am);
|
||
|
||
/* Ein angeklicktes Merkmal an einem Kandidaten.
|
||
|
||
KEIN von_id IM SCHLUESSEL, anders als oben -- und das ist
|
||
Absicht: Bei einem Talent geht es nicht um zwei Meinungen,
|
||
sondern darum, OB etwas beobachtet wurde. Zwei Leute, die
|
||
dasselbe gesehen haben, haben es einmal gesehen. Wer es gesetzt
|
||
hat, steht trotzdem dabei. */
|
||
CREATE TABLE IF NOT EXISTS talent_merkmal (
|
||
eintrag_id INTEGER NOT NULL REFERENCES eintraege(id) ON DELETE CASCADE,
|
||
schluessel TEXT NOT NULL,
|
||
von_id INTEGER REFERENCES personen(id) ON DELETE SET NULL,
|
||
am TEXT NOT NULL,
|
||
PRIMARY KEY (eintrag_id, schluessel)
|
||
);
|
||
|
||
/* Die Trichterstufe eines Kandidaten.
|
||
|
||
EIGENE TABELLE UND NICHT eintraege.status: Der Status dort hat
|
||
drei Werte fuer etwas ganz anderes (offen/erledigt/angenommen),
|
||
und die Stufe braucht ausserdem ein SEIT -- ohne das gibt es
|
||
keine Standzeit, und ohne Standzeit wird aus dem Trichter wieder
|
||
eine Liste. */
|
||
CREATE TABLE IF NOT EXISTS talent_stufe (
|
||
eintrag_id INTEGER PRIMARY KEY REFERENCES eintraege(id) ON DELETE CASCADE,
|
||
stufe TEXT NOT NULL
|
||
CHECK (stufe IN ('aufgefallen','beobachtet','angesprochen','probe','imteam')),
|
||
seit TEXT NOT NULL,
|
||
von_id INTEGER REFERENCES personen(id) ON DELETE SET NULL,
|
||
notiz TEXT
|
||
);
|
||
`);
|
||
|
||
/* DIE BEIDEN SPALTEN DES ÜBERGANGS (15.09.2026).
|
||
|
||
Sie stehen hier und nicht in der Umstellungsliste von workspace.js:
|
||
Die ueberspringt eine Tabelle stillschweigend, wenn es sie noch
|
||
nicht gibt -- und talent_stufe entsteht erst beim ersten Aufruf
|
||
dieser Seite, nicht beim Start. Hier, zwei Zeilen nach dem CREATE,
|
||
ist sie sicher da.
|
||
|
||
ON DELETE SET NULL beim Buddy: Wer geht, nimmt die Probe eines
|
||
anderen nicht mit. Die Karte verliert den Namen und faellt damit
|
||
genau dort auf, wo jemand einen neuen Buddy bestimmen muss. */
|
||
for (const [spalte, typ] of [
|
||
["buddy_id", "INTEGER REFERENCES personen(id) ON DELETE SET NULL"],
|
||
["erste_schicht", "TEXT"],
|
||
]) {
|
||
try {
|
||
const da = db().prepare("PRAGMA table_info(talent_stufe)").all().map((s) => s.name);
|
||
if (!da.includes(spalte)) {
|
||
db().exec(`ALTER TABLE talent_stufe ADD COLUMN ${spalte} ${typ}`);
|
||
console.log(`[talente] Spalte '${spalte}' ergaenzt.`);
|
||
}
|
||
} catch (f) { console.error(`[talente] Spalte '${spalte}':`, f?.message); }
|
||
}
|
||
bereit = true;
|
||
}
|
||
|
||
/* =====================================================================
|
||
DIE HUERDEN
|
||
===================================================================== */
|
||
|
||
function angemeldet(req, res, next) {
|
||
const person = sitzungLesen(req);
|
||
if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
|
||
req.person = person;
|
||
try { tabellen(); } catch (f) {
|
||
console.error("[entwicklung] Tabellen:", f?.message);
|
||
return res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
next();
|
||
}
|
||
|
||
/** Nur DogFather und die rechte Hand. 404 und nicht 403 -- wer „kein
|
||
* Zugriff" liest, fragt als Naechstes, wer denn dann. */
|
||
function nurLeitung(req, res, next) {
|
||
if (fuehrtTeamDogi(req.person)) return next();
|
||
return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
}
|
||
|
||
function gleicheHerkunft(req, res, next) {
|
||
const herkunft = req.get("origin");
|
||
if (!herkunft) return next();
|
||
let erlaubt;
|
||
try { erlaubt = new URL(herkunft).host === req.get("host"); } catch { erlaubt = false; }
|
||
if (!erlaubt) return res.status(403).json({ fehler: "fremde_herkunft" });
|
||
next();
|
||
}
|
||
|
||
entwicklungRouter.use("/workspace/api/entwicklung", angemeldet);
|
||
entwicklungRouter.use("/workspace/api/talente", angemeldet);
|
||
entwicklungRouter.use("/workspace/api/talente", nurLeitung);
|
||
|
||
const nummer = (x) => { const n = Number(x); return Number.isInteger(n) && n > 0 ? n : 0; };
|
||
const text = (x, max) => String(x ?? "").trim().slice(0, max);
|
||
const tageSeit = (iso) => {
|
||
const t = Date.parse(iso || "");
|
||
return Number.isFinite(t) ? Math.floor((Date.now() - t) / TAG) : null;
|
||
};
|
||
|
||
/* =====================================================================
|
||
ENTWICKLUNG
|
||
===================================================================== */
|
||
|
||
/* Der Katalog, wie ihn DIESE Person sehen darf.
|
||
Block 5 faellt fuer alle ausser der Person selbst heraus -- und zwar
|
||
schon hier, nicht erst in der Oberflaeche. */
|
||
function katalogFuer(person, ueberMichSelbst) {
|
||
return ENTWICKLUNG_BLOECKE
|
||
.filter((b) => !b.nurSelbst || ueberMichSelbst)
|
||
.map((b) => ({ ...b, punkte: ENTWICKLUNG_PUNKTE[b.schluessel] || [] }));
|
||
}
|
||
|
||
entwicklungRouter.get("/workspace/api/entwicklung/lage", (req, res) => {
|
||
try {
|
||
const leitung = fuehrtTeamDogi(req.person);
|
||
const platz = KARTEN_ROLLEN.map(() => "?").join(", ");
|
||
const personen = leitung
|
||
? db().prepare(`SELECT id, name, rolle, erstellt FROM personen
|
||
WHERE rolle IN (${platz}) AND aktiv = 1
|
||
ORDER BY ${ROLLEN_SORTIERUNG}, name COLLATE NOCASE`)
|
||
.all(...KARTEN_ROLLEN)
|
||
: [];
|
||
|
||
/* Je Person: wie viele Punkte ICH schon gesetzt habe, wie viele
|
||
davon verblasst sind, und wie viele wir beide verschieden sehen.
|
||
Die Abweichung ist das Ergebnis -- deshalb steht sie schon in
|
||
der Uebersicht und nicht erst in der Karte. */
|
||
const gesetzt = db().prepare(
|
||
"SELECT person_id, COUNT(*) AS n FROM entwicklung_stand WHERE von_id = ? GROUP BY person_id")
|
||
.all(req.person.id);
|
||
const meineZahl = new Map(gesetzt.map((z) => [z.person_id, z.n]));
|
||
|
||
const alt = db().prepare(
|
||
`SELECT person_id, COUNT(*) AS n FROM entwicklung_stand
|
||
WHERE von_id = ? AND am < ? GROUP BY person_id`)
|
||
.all(req.person.id, new Date(Date.now() - VERBLASST_NACH_TAGEN * TAG).toISOString());
|
||
const alteZahl = new Map(alt.map((z) => [z.person_id, z.n]));
|
||
|
||
const anders = db().prepare(
|
||
`SELECT a.person_id, COUNT(*) AS n
|
||
FROM entwicklung_stand a JOIN entwicklung_stand b
|
||
ON a.person_id = b.person_id AND a.schluessel = b.schluessel
|
||
WHERE a.von_id = ? AND b.von_id <> ? AND a.stufe <> b.stufe
|
||
AND a.stufe <> 'unklar' AND b.stufe <> 'unklar'
|
||
GROUP BY a.person_id`).all(req.person.id, req.person.id);
|
||
const andersZahl = new Map(anders.map((z) => [z.person_id, z.n]));
|
||
|
||
res.json({
|
||
leitung,
|
||
stufen: ENTWICKLUNG_STUFEN,
|
||
erwartung: ENTWICKLUNG_ERWARTUNG,
|
||
verblasst_nach: VERBLASST_NACH_TAGEN,
|
||
gesamt_fremd: ENTWICKLUNG_FREMD.length,
|
||
personen: personen.map((p) => ({
|
||
id: p.id, name: p.name,
|
||
rolle_name: ROLLEN_NAME[p.rolle] ?? p.rolle,
|
||
dabei_seit_tagen: tageSeit(p.erstellt),
|
||
gesetzt: meineZahl.get(p.id) || 0,
|
||
veraltet: alteZahl.get(p.id) || 0,
|
||
abweichungen: andersZahl.get(p.id) || 0,
|
||
})),
|
||
/* Die eigene Karte -- fuer jeden, der im Team ist. */
|
||
ich: { id: req.person.id, name: req.person.name },
|
||
});
|
||
} catch (f) {
|
||
console.error("[entwicklung] Lage:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
entwicklungRouter.get("/workspace/api/entwicklung/person/:id", nurLeitung, (req, res) => {
|
||
try {
|
||
const id = nummer(req.params.id);
|
||
const p = id && db().prepare("SELECT id, name, rolle FROM personen WHERE id = ?").get(id);
|
||
if (!p || !KARTEN_ROLLEN.includes(p.rolle)) {
|
||
return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
}
|
||
|
||
const meine = new Map(db().prepare(
|
||
"SELECT schluessel, stufe, anlass, am FROM entwicklung_stand WHERE person_id = ? AND von_id = ?")
|
||
.all(id, req.person.id).map((z) => [z.schluessel, z]));
|
||
|
||
/* DER STAND DES ANDEREN -- nur zu Punkten, bei denen ich selbst
|
||
schon gesetzt habe. Der Riegel sitzt hier, nicht in der
|
||
Oberflaeche: Was nicht ausgeliefert wird, kann niemand ankern. */
|
||
const fremde = db().prepare(
|
||
`SELECT s.schluessel, s.stufe, s.anlass, s.am, v.name AS von_name
|
||
FROM entwicklung_stand s LEFT JOIN personen v ON v.id = s.von_id
|
||
WHERE s.person_id = ? AND s.von_id <> ?`).all(id, req.person.id);
|
||
|
||
const grenze = Date.now() - VERBLASST_NACH_TAGEN * TAG;
|
||
const bloecke = katalogFuer(req.person, false).map((b) => ({
|
||
...b,
|
||
punkte: b.punkte.map((pt) => {
|
||
const m = meine.get(pt.schluessel) || null;
|
||
const andere = m
|
||
? fremde.filter((f) => f.schluessel === pt.schluessel)
|
||
.map((f) => ({ von_name: f.von_name, stufe: f.stufe, anlass: f.anlass, am: f.am }))
|
||
: null;
|
||
return {
|
||
...pt,
|
||
meins: m ? { ...m, verblasst: Date.parse(m.am) < grenze } : null,
|
||
andere,
|
||
/* WIE VIELE ES SONST NOCH GIBT -- ohne zu sagen, was sie
|
||
gesetzt haben. Ohne diese Zahl waere „noch nichts von der
|
||
rechten Hand" und „sie hat gesetzt, du siehst es nur
|
||
nicht" dasselbe Bild, und das erste ist eine Auskunft,
|
||
das zweite eine Taeuschung. */
|
||
andere_offen: m ? 0 : fremde.filter((f) => f.schluessel === pt.schluessel).length,
|
||
};
|
||
}),
|
||
}));
|
||
|
||
/* DIE ABWEICHUNGEN ZUERST. Sie sind das Ergebnis, nicht ein
|
||
Nebenprodukt: Wo zwei Leute dasselbe sehen, gibt es nichts zu
|
||
besprechen. */
|
||
const abweichungen = [];
|
||
for (const b of bloecke) {
|
||
for (const pt of b.punkte) {
|
||
if (!pt.meins || !pt.andere?.length) continue;
|
||
for (const a of pt.andere) {
|
||
if (a.stufe === pt.meins.stufe) continue;
|
||
if (a.stufe === "unklar" || pt.meins.stufe === "unklar") continue;
|
||
abweichungen.push({
|
||
schluessel: pt.schluessel, titel: pt.titel, block: b.name,
|
||
meins: pt.meins.stufe, andere: a.stufe, von_name: a.von_name,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
res.json({
|
||
person: { id: p.id, name: p.name, rolle_name: ROLLEN_NAME[p.rolle] ?? p.rolle },
|
||
stufen: ENTWICKLUNG_STUFEN,
|
||
erwartung: ENTWICKLUNG_ERWARTUNG,
|
||
bloecke,
|
||
abweichungen,
|
||
gesetzt: meine.size,
|
||
gesamt: ENTWICKLUNG_FREMD.length,
|
||
});
|
||
} catch (f) {
|
||
console.error("[entwicklung] Person:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
const STUFEN_SATZ = new Set(ENTWICKLUNG_STUFEN.map((s) => s.schluessel));
|
||
|
||
entwicklungRouter.put("/workspace/api/entwicklung/person/:id/:schluessel",
|
||
gleicheHerkunft, nurLeitung, (req, res) => {
|
||
try {
|
||
const id = nummer(req.params.id);
|
||
const schluessel = String(req.params.schluessel || "");
|
||
const stufe = String(req.body?.stufe || "");
|
||
const anlass = text(req.body?.anlass, ANLASS_MAX);
|
||
|
||
const p = id && db().prepare("SELECT id, rolle FROM personen WHERE id = ?").get(id);
|
||
if (!p || !KARTEN_ROLLEN.includes(p.rolle)) {
|
||
return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
}
|
||
/* NUR PUNKTE, DIE ANDERE SETZEN DUERFEN. Block 5 faellt hier
|
||
heraus -- und zwar an derselben Stelle, an der auch die
|
||
Auslieferung ihn wegnimmt. Ein Schluessel aus Block 5 sieht
|
||
von aussen genauso aus wie ein erfundener. */
|
||
if (!ENTWICKLUNG_FREMD.some((x) => x.schluessel === schluessel)) {
|
||
return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
}
|
||
if (!STUFEN_SATZ.has(stufe)) return res.status(400).json({ fehler: "unbekannte_stufe" });
|
||
|
||
/* DER ANLASS IST PFLICHT, WO ER ETWAS ENTSCHEIDET.
|
||
„Da hakt es" ohne Beispiel ist eine Meinung; mit Beispiel ist
|
||
es ein Gespraech. Bei den anderen beiden steht dasselbe Feld
|
||
freiwillig da. */
|
||
if (stufe === "hakt" && anlass.length < 10) {
|
||
return res.status(400).json({
|
||
fehler: "Woran hast du das gemerkt? Ein Satz genügt – ohne ihn "
|
||
+ "ist es beim Gespräch nur noch ein Gefühl.",
|
||
});
|
||
}
|
||
|
||
db().prepare(`INSERT INTO entwicklung_stand
|
||
(person_id, schluessel, von_id, stufe, anlass, am)
|
||
VALUES (?,?,?,?,?,?)
|
||
ON CONFLICT(person_id, schluessel, von_id) DO UPDATE SET
|
||
stufe = excluded.stufe, anlass = excluded.anlass, am = excluded.am`)
|
||
.run(id, schluessel, req.person.id, stufe, anlass || null, jetzt());
|
||
|
||
res.json({ ok: true });
|
||
} catch (f) {
|
||
console.error("[entwicklung] Setzen:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* ---------- Block 5: die eigene Karte -------------------------------- */
|
||
|
||
/* KEIN :id IN DER ADRESSE, und das ist der Riegel.
|
||
Eine Route /entwicklung/mich/:id waere eine Einladung, eine fremde
|
||
Nummer einzusetzen -- und dann haengt alles an einer einzigen
|
||
Vergleichszeile. Hier gibt es die Nummer gar nicht: Es ist immer die
|
||
Person, die fragt. */
|
||
entwicklungRouter.get("/workspace/api/entwicklung/mich", (req, res) => {
|
||
try {
|
||
const meine = new Map(db().prepare(
|
||
"SELECT schluessel, stufe, anlass, am FROM entwicklung_stand WHERE person_id = ? AND von_id = ?")
|
||
.all(req.person.id, req.person.id).map((z) => [z.schluessel, z]));
|
||
const block = ENTWICKLUNG_BLOECKE.find((b) => b.nurSelbst);
|
||
res.json({
|
||
block,
|
||
stufen: ENTWICKLUNG_STUFEN,
|
||
punkte: (ENTWICKLUNG_PUNKTE[block.schluessel] || []).map((pt) => ({
|
||
...pt, meins: meine.get(pt.schluessel) || null,
|
||
})),
|
||
});
|
||
} catch (f) {
|
||
console.error("[entwicklung] Mich:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
entwicklungRouter.put("/workspace/api/entwicklung/mich/:schluessel", gleicheHerkunft,
|
||
(req, res) => {
|
||
try {
|
||
const schluessel = String(req.params.schluessel || "");
|
||
const stufe = String(req.body?.stufe || "");
|
||
if (!ENTWICKLUNG_SELBST.some((x) => x.schluessel === schluessel)) {
|
||
return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
}
|
||
if (!STUFEN_SATZ.has(stufe)) return res.status(400).json({ fehler: "unbekannte_stufe" });
|
||
/* KEIN ANLASS, NIRGENDS. Hier antwortet jemand ueber sich selbst;
|
||
ein Pflichtfeld waere die zuverlaessigste Art, ehrliche
|
||
Antworten zu verhindern. */
|
||
db().prepare(`INSERT INTO entwicklung_stand
|
||
(person_id, schluessel, von_id, stufe, anlass, am)
|
||
VALUES (?,?,?,?,NULL,?)
|
||
ON CONFLICT(person_id, schluessel, von_id) DO UPDATE SET
|
||
stufe = excluded.stufe, am = excluded.am`)
|
||
.run(req.person.id, schluessel, req.person.id, stufe, jetzt());
|
||
res.json({ ok: true });
|
||
} catch (f) {
|
||
console.error("[entwicklung] Mich setzen:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* ---------- Die eigene Karte ------------------------------------------
|
||
|
||
Filipes Frage aus dem Plan, Punkt 2: "Sieht die Person ihre eigene
|
||
Entwicklungskarte?" -- und die Antwort war ja, aber unter zwei
|
||
Bedingungen. Beide sind hier gebaut, und beide sind der Grund, warum
|
||
es ueberhaupt geht:
|
||
|
||
ERST, WENN ALLE GESETZT HABEN. Eine halbe Karte ist schlimmer als
|
||
keine: Wer sieht, dass einer "da hakt es" gesetzt hat und der andere
|
||
noch nichts, liest daraus einen Streit, den es nicht gibt.
|
||
|
||
WER "ALLE" IST, wird gerechnet, nicht angenommen: alle aktiven
|
||
Personen, die das Team fuehren -- OHNE die Person selbst. Sonst
|
||
muesste die rechte Hand sich erst selbst beurteilen, um zu sehen,
|
||
was DogFather ueber sie denkt.
|
||
|
||
OHNE NAMEN UND OHNE ANLASS. Sie sieht "2x Laeuft" oder "1x Laeuft,
|
||
1x Waechst gerade" -- nicht, wer was gesetzt hat, und nicht, was
|
||
danebengeschrieben steht. Der Anlass ist fuer ein Gespraech
|
||
aufgeschrieben, nicht zum Lesen ohne den Menschen dazu. Genau
|
||
deshalb steht auf der Seite der Satz, dass man danach fragen soll.
|
||
|
||
UND WER GAR KEINE KARTE HAT, bekommt das gesagt. DogFather steht
|
||
nicht in KARTEN_ROLLEN -- eine leere Seite waere fuer ihn ein
|
||
Fehler, ein Satz ist eine Auskunft.
|
||
------------------------------------------------------------------- */
|
||
entwicklungRouter.get("/workspace/api/entwicklung/meine-karte", (req, res) => {
|
||
try {
|
||
if (!KARTEN_ROLLEN.includes(req.person.rolle)) {
|
||
return res.json({ hat_karte: false });
|
||
}
|
||
|
||
/* Wer ueber diese Person urteilt -- alle ausser ihr selbst. */
|
||
const beurteiler = db().prepare(
|
||
"SELECT id FROM personen WHERE rolle IN ('admin','hand') AND aktiv = 1 AND id <> ?")
|
||
.all(req.person.id).map((z) => z.id);
|
||
|
||
const staende = db().prepare(
|
||
"SELECT schluessel, von_id, stufe, am FROM entwicklung_stand WHERE person_id = ?")
|
||
.all(req.person.id).filter((z) => beurteiler.includes(z.von_id));
|
||
|
||
const nachPunkt = new Map();
|
||
for (const z of staende) {
|
||
if (!nachPunkt.has(z.schluessel)) nachPunkt.set(z.schluessel, []);
|
||
nachPunkt.get(z.schluessel).push(z);
|
||
}
|
||
|
||
const bloecke = ENTWICKLUNG_BLOECKE
|
||
.filter((b) => !b.nurSelbst)
|
||
.map((b) => ({
|
||
schluessel: b.schluessel, name: b.name, text: b.text,
|
||
punkte: (ENTWICKLUNG_PUNKTE[b.schluessel] || []).map((pt) => {
|
||
const liste = nachPunkt.get(pt.schluessel) || [];
|
||
/* VOLLSTAENDIG heisst: jeder Beurteiler hat gesetzt. */
|
||
const fertig = beurteiler.length > 0 && liste.length >= beurteiler.length;
|
||
if (!fertig) {
|
||
return { schluessel: pt.schluessel, titel: pt.titel, stufe: pt.stufe, offen: true };
|
||
}
|
||
const zaehler = {};
|
||
for (const z of liste) zaehler[z.stufe] = (zaehler[z.stufe] || 0) + 1;
|
||
return {
|
||
schluessel: pt.schluessel, titel: pt.titel, stufe: pt.stufe, offen: false,
|
||
/* Nach der Reihenfolge des Katalogs, nicht nach Haeufigkeit
|
||
-- sonst stuende bei einer Abweichung mal das eine, mal
|
||
das andere zuerst, und das liest sich wie eine Wertung. */
|
||
antworten: ENTWICKLUNG_STUFEN
|
||
.filter((x) => zaehler[x.schluessel])
|
||
.map((x) => ({ stufe: x.schluessel, name: x.name, anzahl: zaehler[x.schluessel] })),
|
||
einig: new Set(liste.map((z) => z.stufe)).size === 1,
|
||
am: liste.map((z) => z.am).sort().at(-1) || null,
|
||
};
|
||
}),
|
||
}));
|
||
|
||
const alle = bloecke.flatMap((b) => b.punkte);
|
||
res.json({
|
||
hat_karte: true,
|
||
beurteiler: beurteiler.length,
|
||
fertig: alle.filter((x) => !x.offen).length,
|
||
gesamt: alle.length,
|
||
stufen: ENTWICKLUNG_STUFEN,
|
||
erwartung: ENTWICKLUNG_ERWARTUNG,
|
||
bloecke,
|
||
});
|
||
} catch (f) {
|
||
console.error("[entwicklung] Meine Karte:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* ---------- Die Ampel ohne Namen -------------------------------------- */
|
||
|
||
/* WAS HIER HERAUSKOMMT UND WAS NICHT.
|
||
Heraus kommt: wie viele im Team gerade mindestens einen Punkt aus
|
||
Block 5 auf „da hakt es" stehen haben -- und ab zwei Personen auch
|
||
das nicht mehr genau, sondern als Spanne.
|
||
Nicht heraus kommt: wer, welcher Punkt, seit wann.
|
||
|
||
WARUM UEBERHAUPT ETWAS: Ein Block, den niemand je sieht, ist ein
|
||
Block, den niemand ausfuellt. Die Ampel ist der einzige Weg von
|
||
dort nach draussen -- und sie ist absichtlich so schmal, dass man
|
||
daraus niemanden erkennen kann.
|
||
|
||
AB WELCHER ZAHL SIE UEBERHAUPT ETWAS SAGT: Bei einem Team von zwei
|
||
Personen waere „einer hat gerade viel" dasselbe wie ein Name.
|
||
Deshalb schweigt sie unter MINDESTENS_TEAM Personen -- mit Grund,
|
||
nicht stillschweigend. */
|
||
const MINDESTENS_TEAM = 3;
|
||
|
||
entwicklungRouter.get("/workspace/api/entwicklung/ampel", nurLeitung, (req, res) => {
|
||
try {
|
||
const platz = KARTEN_ROLLEN.map(() => "?").join(", ");
|
||
const { n: team } = db().prepare(
|
||
`SELECT COUNT(*) AS n FROM personen WHERE rolle IN (${platz}) AND aktiv = 1`)
|
||
.all(...KARTEN_ROLLEN)[0] || { n: 0 };
|
||
|
||
if (team < MINDESTENS_TEAM) {
|
||
/* DREI VERSCHIEDENE LAGEN, DREI VERSCHIEDENE SAETZE.
|
||
|
||
Der erste Entwurf hatte einen Satz fuer alle: "Solange ihr zu
|
||
{n} seid …". Im Bildschirmfoto stand dort "Solange ihr zu 1
|
||
seid" -- und bei einem leeren Team "zu 0". Ein Satz, der bei
|
||
den haeufigsten Faellen falsches Deutsch ergibt, liest sich
|
||
wie ein Fehler, und ab da glaubt man auch dem Rest nicht mehr.
|
||
|
||
Gefunden hat das kein Test, sondern ein Blick auf die Seite. */
|
||
return res.json({
|
||
sagbar: false, team,
|
||
grund: team === 0
|
||
? "Noch ist niemand im Team. Sobald jemand dazukommt, kann hier etwas stehen."
|
||
: team === 1
|
||
? "Es ist gerade eine Person im Team – da wäre jede Auskunft hier "
|
||
+ "dasselbe wie ein Name. Frag sie direkt."
|
||
: `Ihr seid zu ${team}. Jede Auskunft an dieser Stelle wäre damit `
|
||
+ "so gut wie ein Name – frag sie direkt, das ist hier ohnehin der bessere Weg.",
|
||
});
|
||
}
|
||
|
||
const schluessel = ENTWICKLUNG_SELBST.map((p) => p.schluessel);
|
||
const pl = schluessel.map(() => "?").join(", ");
|
||
const { n: betroffen } = db().prepare(
|
||
`SELECT COUNT(DISTINCT person_id) AS n FROM entwicklung_stand
|
||
WHERE schluessel IN (${pl}) AND stufe = 'hakt' AND person_id = von_id`)
|
||
.all(...schluessel)[0] || { n: 0 };
|
||
const { n: geantwortet } = db().prepare(
|
||
`SELECT COUNT(DISTINCT person_id) AS n FROM entwicklung_stand
|
||
WHERE schluessel IN (${pl}) AND person_id = von_id`)
|
||
.all(...schluessel)[0] || { n: 0 };
|
||
|
||
res.json({
|
||
sagbar: true, team, geantwortet,
|
||
/* Keine genaue Zahl: „einer" waere bei kleinen Teams wieder ein
|
||
Name. Es gibt drei Antworten, und mehr braucht es nicht. */
|
||
lage: betroffen === 0 ? "ruhig" : betroffen === 1 ? "jemand" : "mehrere",
|
||
text: betroffen === 0
|
||
? (geantwortet === 0
|
||
? "Noch hat niemand geantwortet. Die Ampel sagt erst etwas, wenn jemand da war."
|
||
: "Gerade meldet niemand, dass es zu viel wird.")
|
||
: betroffen === 1
|
||
? "Jemand im Team hat gerade viel. Kein Name – frag reihum, nicht gezielt."
|
||
: "Mehrere im Team haben gerade viel. Das ist selten ein Zufall.",
|
||
});
|
||
} catch (f) {
|
||
console.error("[entwicklung] Ampel:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* =====================================================================
|
||
TALENTE
|
||
===================================================================== */
|
||
|
||
/** Ein Tagesdatum in Ortszeit, YYYY-MM-DD.
|
||
*
|
||
* NICHT toISOString().slice(0,10) -- das rechnet in UTC, und zwischen
|
||
* Mitternacht und zwei Uhr morgens liefert es in Deutschland den
|
||
* Vortag. Genau diese Zeile steht als offener Befund in pruef-struktur. */
|
||
function tagIn(d = new Date()) {
|
||
return new Intl.DateTimeFormat("sv-SE", { timeZone: "Europe/Berlin" }).format(d);
|
||
}
|
||
|
||
/** Wie viele Tage liegen zwischen heute und einem Tagesdatum?
|
||
* Negativ heisst: vorbei. */
|
||
function tageBis(tag) {
|
||
if (!tag) return null;
|
||
const heute = Date.parse(tagIn() + "T12:00:00Z");
|
||
const ziel = Date.parse(tag + "T12:00:00Z");
|
||
if (!Number.isFinite(ziel)) return null;
|
||
return Math.round((ziel - heute) / 86400000);
|
||
}
|
||
|
||
/** Der Übergang: ein Buddy und ein Datum — mehr braucht die Probe nicht.
|
||
*
|
||
* ER WIRD ABGELEITET, NICHT GESPEICHERT. Ein Satz wie „die erste
|
||
* Schicht war vor drei Tagen" in der Datenbank waere ab morgen falsch.
|
||
* Aus zwei Feldern wird hier jedes Mal neu gerechnet, was gerade gilt. */
|
||
function uebergangVon(stand) {
|
||
if (!stand?.erste_schicht && !stand?.buddy_id) return null;
|
||
const buddy = stand.buddy_id
|
||
? db().prepare("SELECT name, rolle, aktiv FROM personen WHERE id = ?").get(stand.buddy_id)
|
||
: null;
|
||
const bis = tageBis(stand.erste_schicht);
|
||
return {
|
||
buddy_id: stand.buddy_id || null,
|
||
buddy_name: buddy?.name || null,
|
||
/* WER GEGANGEN IST, IST KEIN BUDDY MEHR -- und zwar auf beiden
|
||
Wegen, auf denen jemand gehen kann.
|
||
|
||
Der erste Entwurf fragte "`buddy_id` gesetzt UND die Person weg".
|
||
Damit war der zweite Weg blind: Wird ein Mensch GELOESCHT, setzt
|
||
ON DELETE SET NULL die Spalte auf NULL -- die Bedingung war
|
||
falsch, die Karte sah unauffaellig aus, und eine laufende Probe
|
||
stand ohne jeden Buddy da. Gefunden hat das die Pruefung, nicht
|
||
das Lesen; sie loescht die Person wirklich.
|
||
|
||
Richtig ist die Frage, auf die es ankommt: Gibt es jemanden, der
|
||
gerade einarbeitet? */
|
||
buddy_weg: !buddy?.aktiv,
|
||
erste_schicht: stand.erste_schicht || null,
|
||
bis_schicht: bis,
|
||
/* Drei Lagen, drei Saetze -- derselbe Grund wie bei der Ampel:
|
||
ein Satz fuer alle ergibt bei der Haelfte falsches Deutsch. */
|
||
satz: !stand.erste_schicht ? null
|
||
: bis > SCHICHT_WEIT_TAGE
|
||
? `Erste Schicht in ${bis} Tagen. Das ist weit weg – bis dahin hört man nichts `
|
||
+ "voneinander, und genau da springen die meisten ab."
|
||
: bis > 1 ? `Erste Schicht in ${bis} Tagen.`
|
||
: bis === 1 ? "Erste Schicht ist morgen."
|
||
: bis === 0 ? "Erste Schicht ist heute."
|
||
: bis === -1 ? "Erste Schicht war gestern."
|
||
: `Erste Schicht war vor ${-bis} Tagen.`,
|
||
};
|
||
}
|
||
|
||
/** Die Karte eines Kandidaten -- Stufe, Standzeit, was zu tun ist. */
|
||
function talentKarte(e, merkmale) {
|
||
const stand = db().prepare(
|
||
"SELECT stufe, seit, notiz, buddy_id, erste_schicht FROM talent_stufe WHERE eintrag_id = ?")
|
||
.get(e.id);
|
||
const stufe = talentStufe(stand?.stufe) || TALENT_STUFEN[0];
|
||
const seit = stand?.seit || e.erstellt;
|
||
const tage = tageSeit(seit);
|
||
const gesetzt = merkmale.filter((m) => m.eintrag_id === e.id).map((m) => m.schluessel);
|
||
const warn = gesetzt.filter((s) => TALENT_NACH_SCHLUESSEL.get(s)?.warnung);
|
||
return {
|
||
id: e.id, titel: e.titel, text: e.text, einsatz: e.einsatz,
|
||
stufe: stufe.schluessel, stufe_name: stufe.name,
|
||
bedeutet: stufe.bedeutet, schritt: stufe.schritt, knopf: stufe.knopf,
|
||
naechste: talentNaechste(stufe.schluessel)?.schluessel || null,
|
||
seit, tage,
|
||
/* LIEGENGEBLIEBEN IST EINE AUSKUNFT UEBER UNS, nicht ueber den
|
||
Kandidaten. Deshalb steht sie an der Karte und nicht in einer
|
||
Erinnerungsmail, die man wegklickt. */
|
||
liegt: stufe.frist !== null && tage !== null && tage > stufe.frist,
|
||
merkmale: gesetzt.filter((s) => !TALENT_NACH_SCHLUESSEL.get(s)?.warnung),
|
||
warnzeichen: warn,
|
||
notiz: stand?.notiz || null,
|
||
/* DER ÜBERGANG. Er steht an der Karte und nicht in einem eigenen
|
||
Abruf: Er aendert sich mit jedem Tag, und was man extra holen
|
||
muss, ist beim Holen schon veraltet. */
|
||
uebergang: uebergangVon(stand),
|
||
/* DER VORLAGENTEXT -- gebaut aus den Merkmalen, die wirklich
|
||
angeklickt wurden. Er kommt MIT der Karte und nicht ueber einen
|
||
eigenen Weg: Er aendert sich mit jedem Klick, und ein Text, den
|
||
man extra abrufen muss, ist beim Abrufen schon veraltet. */
|
||
ansprechtext: ansprechtext(e.titel, gesetzt),
|
||
};
|
||
}
|
||
|
||
entwicklungRouter.get("/workspace/api/talente/lage", (req, res) => {
|
||
try {
|
||
const eintraege = db().prepare(
|
||
`SELECT id, titel, text, einsatz, erstellt FROM eintraege
|
||
WHERE bereich = 'talente' ORDER BY id DESC LIMIT 300`).all();
|
||
const merkmale = eintraege.length
|
||
? db().prepare(
|
||
`SELECT eintrag_id, schluessel FROM talent_merkmal
|
||
WHERE eintrag_id IN (${eintraege.map(() => "?").join(", ")})`)
|
||
.all(...eintraege.map((e) => e.id))
|
||
: [];
|
||
|
||
const karten = eintraege.map((e) => talentKarte(e, merkmale));
|
||
res.json({
|
||
stufen: TALENT_STUFEN,
|
||
gruppen: TALENT_GRUPPEN.map((g) => ({ ...g, merkmale: TALENT_MERKMALE[g.schluessel] || [] })),
|
||
warnzeichen: TALENT_WARNZEICHEN,
|
||
/* WER BUDDY SEIN KANN -- in der Reihenfolge des Hauses, nicht in
|
||
der der Datenbank. Sie kommt mit der Lage, damit die Auswahl
|
||
keine zweite Liste braucht, die man pflegen muesste. */
|
||
buddys: db().prepare(
|
||
`SELECT id, name, rolle FROM personen
|
||
WHERE aktiv = 1 AND rolle IN (${BUDDY_ROLLEN.map(() => "?").join(", ")})
|
||
ORDER BY ${ROLLEN_SORTIERUNG}, name COLLATE NOCASE`).all(...BUDDY_ROLLEN),
|
||
erster_tag: ERSTER_TAG,
|
||
schicht_weit_tage: SCHICHT_WEIT_TAGE,
|
||
kandidaten: karten,
|
||
/* Wie viele auf jeder Stufe liegen -- der Trichter als Zahlen.
|
||
Abgeleitet, damit er nicht danebenliegen kann. */
|
||
trichter: TALENT_STUFEN.map((s) => ({
|
||
schluessel: s.schluessel, name: s.name,
|
||
anzahl: karten.filter((k) => k.stufe === s.schluessel).length,
|
||
liegt: karten.filter((k) => k.stufe === s.schluessel && k.liegt).length,
|
||
})),
|
||
});
|
||
} catch (f) {
|
||
console.error("[talente] Lage:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
entwicklungRouter.put("/workspace/api/talente/:id/merkmal/:schluessel", gleicheHerkunft,
|
||
(req, res) => {
|
||
try {
|
||
const id = nummer(req.params.id);
|
||
const schluessel = String(req.params.schluessel || "");
|
||
const e = id && db().prepare(
|
||
"SELECT id, bereich FROM eintraege WHERE id = ?").get(id);
|
||
if (!e || e.bereich !== "talente") return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
if (!TALENT_NACH_SCHLUESSEL.has(schluessel)) {
|
||
return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
}
|
||
/* EIN KNOPF, ZWEI RICHTUNGEN. Ein Merkmal ist gesehen oder nicht;
|
||
ein zweiter Klick nimmt es zurueck. Kein eigener Weg zum
|
||
Abwaehlen -- der waere die Stelle, an der die Rechtepruefung
|
||
irgendwann fehlt. */
|
||
const schon = db().prepare(
|
||
"SELECT 1 AS x FROM talent_merkmal WHERE eintrag_id = ? AND schluessel = ?")
|
||
.get(id, schluessel);
|
||
if (schon) {
|
||
db().prepare("DELETE FROM talent_merkmal WHERE eintrag_id = ? AND schluessel = ?")
|
||
.run(id, schluessel);
|
||
} else {
|
||
db().prepare(
|
||
"INSERT INTO talent_merkmal (eintrag_id, schluessel, von_id, am) VALUES (?,?,?,?)")
|
||
.run(id, schluessel, req.person.id, jetzt());
|
||
}
|
||
res.json({ ok: true, gesetzt: !schon });
|
||
} catch (f) {
|
||
console.error("[talente] Merkmal:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/** Buddy und Datum prüfen. Gibt `{ fehlt: [...] }` oder `{ buddyId, schicht }`.
|
||
*
|
||
* EINE STELLE, ZWEI AUFRUFER: der Stufenwechsel auf „Probe" und das
|
||
* spaetere Aendern. Zwei Abschriften derselben Regeln waeren zwei
|
||
* Regeln, und die zweite ist immer die, die etwas durchlaesst. */
|
||
function uebergangPruefen(koerper, { pflicht }) {
|
||
const fehlt = [];
|
||
const buddyId = nummer(koerper?.buddy_id);
|
||
const b = buddyId
|
||
? db().prepare("SELECT id, aktiv, rolle FROM personen WHERE id = ?").get(buddyId) : null;
|
||
if (buddyId && (!b || !b.aktiv || !BUDDY_ROLLEN.includes(b.rolle))) fehlt.push("buddy_unbekannt");
|
||
else if (!buddyId && pflicht) fehlt.push("buddy");
|
||
|
||
const roh = String(koerper?.erste_schicht || "").trim();
|
||
if (roh) {
|
||
if (!/^\d{4}-\d{2}-\d{2}$/.test(roh)) fehlt.push("datum_unlesbar");
|
||
else {
|
||
const bis = tageBis(roh);
|
||
/* VERGANGENHEIT IST KEIN TERMIN. Wer eine Schicht nachtraegt, die
|
||
schon war, meint etwas anderes -- naemlich, dass die Probe
|
||
laeuft. Dann gehoert das Datum von damals hinein, nicht heute:
|
||
deshalb sind bis zu sieben Tage rueckwaerts erlaubt. */
|
||
if (bis === null) fehlt.push("datum_unlesbar");
|
||
else if (bis < -7) fehlt.push("datum_zu_alt");
|
||
else if (bis > SCHICHT_MAX_TAGE) fehlt.push("datum_zu_weit");
|
||
}
|
||
} else if (pflicht) fehlt.push("erste_schicht");
|
||
|
||
return fehlt.length ? { fehlt } : { buddyId: buddyId || null, schicht: roh || null };
|
||
}
|
||
|
||
/** Buddy oder Datum ändern, ohne die Stufe anzufassen.
|
||
*
|
||
* Ein eigener Weg, weil es ein eigener Vorgang ist: Ein Buddy hoert
|
||
* auf, ein Termin verschiebt sich. Wer dafuer die Stufe neu setzen
|
||
* muesste, setzt dabei `seit` zurueck -- und die Standzeit, die genau
|
||
* diese Verschleppung sichtbar macht, faengt wieder bei null an. */
|
||
entwicklungRouter.put("/workspace/api/talente/:id/uebergang", gleicheHerkunft, (req, res) => {
|
||
try {
|
||
const id = nummer(req.params.id);
|
||
const e = id && db().prepare("SELECT id, bereich, titel FROM eintraege WHERE id = ?").get(id);
|
||
if (!e || e.bereich !== "talente") return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
const stand = db().prepare("SELECT stufe FROM talent_stufe WHERE eintrag_id = ?").get(id);
|
||
if (!stand) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
const p = uebergangPruefen(req.body, { pflicht: stand.stufe === "probe" });
|
||
if (p.fehlt) return res.status(400).json({ fehler: "uebergang_offen", fehlt: p.fehlt });
|
||
|
||
db().prepare("UPDATE talent_stufe SET buddy_id = ?, erste_schicht = ? WHERE eintrag_id = ?")
|
||
.run(p.buddyId, p.schicht, id);
|
||
protokolliere("talent_uebergang", {
|
||
personId: req.person.id, ip: echteIp(req),
|
||
detail: `${e.titel}: Buddy/erste Schicht geaendert`.slice(0, 120),
|
||
});
|
||
res.json({ ok: true });
|
||
} catch (f) {
|
||
console.error("[talente] Uebergang:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
entwicklungRouter.put("/workspace/api/talente/:id/stufe", gleicheHerkunft, (req, res) => {
|
||
try {
|
||
const id = nummer(req.params.id);
|
||
const stufe = String(req.body?.stufe || "");
|
||
const notiz = text(req.body?.notiz, ANLASS_MAX);
|
||
const e = id && db().prepare("SELECT id, bereich, titel FROM eintraege WHERE id = ?").get(id);
|
||
if (!e || e.bereich !== "talente") return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
if (!talentStufe(stufe)) return res.status(400).json({ fehler: "unbekannte_stufe" });
|
||
|
||
/* AUF DIE PROBE KOMMT NIEMAND OHNE BUDDY UND DATUM.
|
||
|
||
In der Stufenbeschreibung stand „fester Buddy" seit dem ersten
|
||
Tag -- ein Feld dafuer gab es nicht. Ein Versprechen ohne Feld
|
||
ist eines, an das sich nach zwei Wochen niemand erinnert, und
|
||
genau an dieser Stelle verlieren Teams die Leute, die sie gerade
|
||
gewonnen haben.
|
||
|
||
EINE ABSAGE MIT GRUND, nicht ein „ging nicht": Die Oberflaeche
|
||
fragt beides vorher ab, aber die Regel gehoert hierher. Was nur
|
||
im Browser steht, gilt nur fuer den, der den Browser benutzt. */
|
||
const p = stufe === "probe"
|
||
? uebergangPruefen(req.body, { pflicht: true })
|
||
: uebergangPruefen(req.body, { pflicht: false });
|
||
if (p.fehlt) return res.status(400).json({ fehler: "uebergang_offen", fehlt: p.fehlt });
|
||
|
||
/* COALESCE, NICHT ÜBERSCHREIBEN: Wer aus der Probe ins Team geht,
|
||
schickt Buddy und Datum nicht noch einmal mit -- und die beiden
|
||
sollen bleiben, wo sie sind. Sie sind die Geschichte dieser
|
||
Probe, nicht ein Formularfeld. */
|
||
db().prepare(`INSERT INTO talent_stufe
|
||
(eintrag_id, stufe, seit, von_id, notiz, buddy_id, erste_schicht)
|
||
VALUES (?,?,?,?,?,?,?)
|
||
ON CONFLICT(eintrag_id) DO UPDATE SET
|
||
stufe = excluded.stufe, seit = excluded.seit,
|
||
von_id = excluded.von_id, notiz = excluded.notiz,
|
||
buddy_id = COALESCE(excluded.buddy_id, talent_stufe.buddy_id),
|
||
erste_schicht = COALESCE(excluded.erste_schicht, talent_stufe.erste_schicht)`)
|
||
.run(id, stufe, jetzt(), req.person.id, notiz || null, p.buddyId, p.schicht);
|
||
|
||
protokolliere("talent_stufe", {
|
||
personId: req.person.id, ip: echteIp(req),
|
||
detail: `${e.titel}: ${stufe}`.slice(0, 120),
|
||
});
|
||
res.json({ ok: true, stufe });
|
||
} catch (f) {
|
||
console.error("[talente] Stufe:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|