DogFatherGit
21793b6c36
Aus dem Auftrag vom 21.09.2026, Abschnitt 6: "Die linke Hand erhaelt
grundsaetzlich dieselben Rechte wie die rechte Hand in allen Bereichen,
die die Modis, Aufgaben, Aufgabenzuweisungen, Uebersichten,
Kommunikation und Auswertungen betreffen. Die linke Hand darf keine
neuen Personen oder Accounts hinzufuegen. Die linke Hand darf keine
privaten bzw. persoenlichen Bereiche oder Informationen von Dogfather
sehen."
GEMESSEN VOR DEM BAUEN: Die Rolle "hand" steht an 35 Stellen im
Servercode und 17-mal in der Rechtetafel. Haette ich ueberall ein
"linke" danebengeschrieben, waere die naechste Stelle, die jemand
hinzufuegt, die erste, die es vergisst -- und eine vergessene Stelle
heisst hier: Die linke Hand sieht etwas nicht, ohne dass jemand merkt,
warum.
DESHALB EINE REGEL STATT DREISSIG ABSCHRIFTEN:
WIE_RECHTE_HAND = new Set(["hand", "linke"]) in workspace.js
istHand(person) fuer die Faehigkeiten
eine Schleife ueber SEITEN fuer die Rechtetafel
Die Schleife gibt der linken Hand jede Seite der rechten -- ausser
fuenf, und jede davon steht mit Grund da:
personen.html legt Personen an
bewerbungen.html fuehrt zu neuen Personen
talente.html fuehrt zu neuen Personen
hilfe.html vertraulicher Meldeweg
rechte.html Rechteverwaltung
Gemessen: 25 Seiten fuer die rechte Hand, 20 fuer die linke. Als
Kacheln: 30 gegen 26 -- die vier verbotenen erscheinen gar nicht erst,
statt beim Antippen abgelehnt zu werden.
ZWEI DINGE, DIE ERST DAS MESSEN GEZEIGT HAT:
(1) OHNE KACHEL AUF DER ANMELDEWAND GIBT ES DIE ROLLE NICHT. Die
Anmeldung sucht `WHERE rolle = ?` auf die angetippte Kachel -- es
gibt keinen rollenuebergreifenden Sonderweg, auch nicht auf der
Crew-Wand. Eine linke Hand haette sich mit dem richtigen Code
NIEMALS anmelden koennen, und der Fehler haette ausgesehen wie ein
falscher Code.
(2) DIE REIHENFOLGE DER DATENBANK-UMSTELLUNG ZAEHLT.
`checkListeErweitern` baut die CHECK-Regel NEU aus der Liste, die
man ihm gibt. Mein Schritt stand zuerst bei der rechten Hand --
der Schritt fuer "gast" darunter nahm die Rolle damit wieder
heraus, denn seine Liste kennt sie nicht. Die Kette ist kumulativ;
neue Schritte gehoeren ans ENDE. Das steht jetzt auch dort.
Dazu zwei kleinere Funde beim Bauen:
- Meine erste Ableitung aenderte die Rollenliste AN ORT UND STELLE.
Mehrere Seiten teilen sich dieselbe Liste (`ALLE`) -- das haette
die Rolle allen Seiten gegeben, die sie benutzen, auch einer
Ausnahme. Faellt nicht auf, solange keine Ausnahme `ALLE` benutzt.
Jetzt eine Kopie je Seite.
- ROLLEN_NAME fehlte der Eintrag: Die linke Hand haette ueberall
"linke" geheissen statt "Linke Hand". Gefunden hat das
pruef-rechtetafel, weil sie diese Tabelle gegen ROLLEN haelt.
Ihre Meldung nennt jetzt, WELCHE Liste was vermisst -- vorher
zeigte sie beim Fehlschlag nur eine der beiden.
NICHT BEKOMMEN -- und jedes einzeln begruendet im Code:
Personen anlegen (ANLEGBAR.linke = []), Rollen aendern
(darfRollenWechseln), Bewerbungen, der vertrauliche Meldeweg. Beim
Meldeweg ist es bewusst das kleinere Recht: Ein Wort von Filipe
oeffnet ihn, eine versehentlich gelesene Meldung laesst sich nicht
zurueckholen.
UNBERUEHRT GEBLIEBEN, obwohl dort "hand" steht:
workspace-leistung.js:406 -- dort heisst "hand" nicht die Rolle,
sondern "von Hand eingetragen".
Am laufenden System gemessen: Datenbank nimmt die Rolle, Anmeldung
HTTP 200, 26 Kacheln, darf_verteilen = true, personen/hilfe/rechte
antworten mit 302, aufgaben und teamlage mit 200.
pruef-rechtetafel 19/0 (war 18/1), pruef-schranke 39/0,
pruef-umstellung 18/0.
1780 lines
80 KiB
JavaScript
1780 lines
80 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, MODI_KATEGORIEN, kategorienFuer,
|
||
} from "./workspace.js";
|
||
/* Die Aufgaben, die ein Neuer bekommen kann -- dieselbe Liste, aus der
|
||
auch die Aufgabenseite ihre Vorschlaege baut. Eine zweite waere die,
|
||
die beim naechsten Nachschaerfen auseinanderlaeuft. */
|
||
import { MODI_AUFGABEN_FLACH } from "./workspace-vorlagen.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,
|
||
// (Probeplan siehe unten -- eigene Datei, eigener Gegenstand)
|
||
SCHICHT_WEIT_TAGE, SCHICHT_MAX_TAGE, ERSTER_TAG,
|
||
TALENT_NACH_SCHLUESSEL, talentStufe, talentNaechste, ansprechtext,
|
||
} from "./workspace-talent-punkte.js";
|
||
import {
|
||
PROBE_PHASEN, PROBE_SCHRITTE, PROBE_WER, PROBE_ALLE, PROBE_FRAGEN,
|
||
PROBE_NACH_SCHLUESSEL, probeStand,
|
||
} from "./workspace-probeplan.js";
|
||
|
||
export const entwicklungRouter = express.Router();
|
||
|
||
const jetzt = () => new Date().toISOString();
|
||
const TAG = 86400000;
|
||
const ANLASS_MAX = 1200;
|
||
|
||
/* WIE KURZ EIN ABSCHIEDSSATZ SEIN DARF.
|
||
Zehn Zeichen -- dieselbe Grenze wie bei einer abgelehnten Anfrage
|
||
(NACHRICHT_MIN, workspace-bewerbung-fragen.js), und aus demselben
|
||
Grund: Sie verhindert nicht das schlechte Argument, sie verhindert
|
||
das leere Feld. "Passt nicht" hat neun Zeichen. */
|
||
const BEENDEN_GRUND_MIN = 10;
|
||
|
||
/* 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", "linke", "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", "linke", "modi"];
|
||
|
||
/** Welchen Zugang der letzte Schritt des Trichters anlegt.
|
||
*
|
||
* ER STEHT HIER UND NICHT IM BROWSER (16.09.2026). Die Talente-Seite
|
||
* hatte `rolle: 'modi'` als festen Text im Skript -- und jede Datei
|
||
* unter `workspace/` liefert der Server an JEDEN aus, der die Adresse
|
||
* kennt. Nachgemessen am 16.09.: `talente.js` kommt ohne jede
|
||
* Anmeldung mit 200 aus dem offenen Netz, 25 KB Quelltext, der
|
||
* Rollenname mittendrin.
|
||
*
|
||
* Damit stand der verborgene Zugang in einer Datei, die man nicht
|
||
* einmal geschenkt bekommen muss -- man kann sie abrufen. Die
|
||
* Rollentabelle nebenan sagt seit dem 11.09. genau das Richtige dazu:
|
||
* „Der Name steht hier und NICHT in einer Datei, die jeder
|
||
* herunterlaedt -- ausgeliefert wird er nur an den, der ihn selbst
|
||
* traegt, und an die, die ihn sehen duerfen."
|
||
*
|
||
* Die Seite fragt ihn deshalb ab, statt ihn zu kennen. Die Antwort
|
||
* geht ueber `nurLeitung` -- also nur an DogFather und die rechte
|
||
* Hand. */
|
||
const ZUGANG_ROLLE = "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);
|
||
|
||
/* =================================================================
|
||
DIE SPUR (19.09.2026) — jede Aenderung, angehaengt statt ueberschrieben.
|
||
|
||
Die Tabelle darueber hat den Schluessel (person, punkt, beurteiler)
|
||
und wird bei jeder Aenderung UEBERSCHRIEBEN. Das ist dort richtig:
|
||
Eine Beobachtung ueber einen Menschen soll aktuell sein, nicht
|
||
historisch.
|
||
|
||
Nur: Damit existierte nichts, woraus man einen Verlauf zeichnen
|
||
koennte. Am 19.09. nachgemessen: 43 Zeilen Stand, NULL Zeilen
|
||
Geschichte. Ein Diagramm ueber einen einzigen Zeitpunkt ist kein
|
||
Diagramm, sondern ein Balken.
|
||
|
||
SIE STEHT HIER UND NICHT IN workspace-werdegang.js, obwohl sie
|
||
dort ausgewertet wird: Eine Tabelle gehoert zu dem Modul, das sie
|
||
SCHREIBT. Andersherum gaebe es einen Ring zwischen zwei Modulen,
|
||
und Ringe halten in JavaScript genau so lange, bis jemand eine
|
||
Konstante auf oberster Ebene benutzt.
|
||
|
||
KEIN ANLASS, NIE. Neben jedem "da hakt es" steht in der Tabelle
|
||
oben ein Satz, woran man es gemerkt hat. Der ist fuer ein
|
||
Gespraech aufgeschrieben. Eine CHRONIK dieser Saetze waere das
|
||
Belastendste, was dieses Haus speichern kann -- jede laengst
|
||
geklaerte Beobachtung bliebe auf Dauer lesbar. Dasselbe Prinzip
|
||
wie beim Befinden-Verlauf.
|
||
|
||
VORHER steht dabei, obwohl es aus der vorigen Zeile abzuleiten
|
||
waere: Fuer die Startaufnahme (siehe unten) gibt es kein
|
||
"vorher", und NULL sagt das, waehrend eine abgeleitete Kette es
|
||
verschweigen wuerde.
|
||
|
||
NACHGETRAGEN unterscheidet beobachtete Uebergaenge von der
|
||
Startaufnahme. Ohne dieses Feld saehe der Tag, an dem die Spur
|
||
entstand, wie ein Tag aus, an dem 43 Dinge gleichzeitig passiert
|
||
sind.
|
||
============================================================= */
|
||
CREATE TABLE IF NOT EXISTS entwicklung_lauf (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
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')),
|
||
vorher TEXT,
|
||
nachgetragen INTEGER NOT NULL DEFAULT 0,
|
||
am TEXT NOT NULL
|
||
);
|
||
CREATE INDEX IF NOT EXISTS idx_lauf_person
|
||
ON entwicklung_lauf (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. */
|
||
/* WAS IN DER PROBEZEIT SCHON PASSIERT IST (17.09.2026).
|
||
|
||
Filipe: "wie talente ... aufgaben bekommen, analysiert werden von
|
||
vanvan und mir."
|
||
|
||
EIGENE TABELLE UND NICHT DIE AUFGABEN: Ein Talent ist ein EINTRAG,
|
||
kein Zugang -- es gibt keine Person, der man eine Aufgabe geben
|
||
koennte. Und die Schritte gehoeren nicht alle ihm: drei davon tut
|
||
der Buddy, drei die Leitung. Eine Aufgabe auf dem Brett waere
|
||
damit entweder herrenlos oder an der falschen Person.
|
||
|
||
MIT von_id UND am, anders als bei den Merkmalen mit Absicht
|
||
SICHTBAR: Bei einem Schritt zaehlt, WER ihn gesehen hat. "Das
|
||
Team wurde gefragt" von dir und von der rechten Hand sind zwei
|
||
verschiedene Auskuenfte. */
|
||
CREATE TABLE IF NOT EXISTS talent_probe (
|
||
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,
|
||
notiz TEXT,
|
||
PRIMARY KEY (eintrag_id, schluessel)
|
||
);
|
||
|
||
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"],
|
||
/* DER AUSGANG (17.09.2026).
|
||
|
||
Der Trichter hatte bis heute genau EINEN: "Ins Team holen". Die
|
||
Stufenbeschreibung versprach daneben "oder sauber beenden" --
|
||
den Weg dazu gab es nicht. Ein Kandidat, bei dem es nicht passt,
|
||
blieb damit fuer immer auf seiner Stufe stehen, mit wachsender
|
||
Standzeit und rotem Hinweis. Das ist schlimmer als keine
|
||
Funktion: Die Liste fuellt sich mit Leuten, bei denen laengst
|
||
entschieden ist, und irgendwann liest niemand mehr die
|
||
Standzeiten.
|
||
|
||
ZWEI SPALTEN UND KEINE NEUE STUFE, und das ist Absicht:
|
||
|
||
Eine Stufe "beendet" haette die Regel in talent_stufe umbauen
|
||
muessen (CHECK) -- ein Tabellenneubau an lebenden Daten fuer
|
||
etwas, das sich mit zwei Spalten sagen laesst.
|
||
|
||
Und sie haette eine Auskunft VERNICHTET: So bleibt stehen, WO
|
||
es geendet hat. "Beendet in der Probe" und "beendet nach dem
|
||
ersten Hinsehen" sind zwei verschiedene Saetze ueber dieselbe
|
||
Person -- und wenn sie in einem halben Jahr wieder auffaellt,
|
||
ist genau das die Frage. */
|
||
["beendet_am", "TEXT"],
|
||
["beendet_grund", "TEXT"],
|
||
["beendet_von", "INTEGER"],
|
||
|
||
/* WER AUS DEM TALENT GEWORDEN IST (17.09.2026).
|
||
|
||
Der letzte Schritt des Trichters legt einen Zugang an -- und bis
|
||
heute war das eine Einbahnstrasse: Die Person entstand, der Code
|
||
wurde einmal gezeigt, und die Karte wusste hinterher NICHT, wer
|
||
daraus geworden ist.
|
||
|
||
Was dadurch nicht ging:
|
||
- von der Karte zur Person springen
|
||
- dem Neuen seine ersten Aufgaben aus der Karte heraus geben
|
||
- in einem halben Jahr nachsehen, aus welchem Kandidaten
|
||
eigentlich welches Teammitglied wurde
|
||
|
||
KEIN FREMDSCHLUESSEL AUF personen. Wird ein Zugang geloescht,
|
||
soll die Karte stehen bleiben -- sie erzaehlt, wie jemand
|
||
gekommen ist, und das bleibt wahr, auch wenn er wieder geht. Ein
|
||
CASCADE haette genau diesen Verlauf mitgeloescht. */
|
||
["person_id", "INTEGER"],
|
||
|
||
/* WER SICH UM DIESEN KANDIDATEN KUEMMERT (17.09.2026).
|
||
|
||
Dieselbe Luecke wie bei den Anfragen, nur teurer: Ein Kandidat,
|
||
fuer den sich niemand zustaendig fuehlt, bleibt auf seiner Stufe
|
||
liegen -- und die Standzeit an der Karte sagt zwar, DASS etwas
|
||
liegt, aber nicht, wer es aufheben sollte.
|
||
|
||
`zustaendig_seit` kommt mit: „seit gestern uebernommen“ und „seit
|
||
drei Wochen uebernommen" sind zwei verschiedene Auskuenfte, und
|
||
die zweite ist die, die man sehen will. */
|
||
["zustaendig_id", "INTEGER"],
|
||
["zustaendig_seit", "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); }
|
||
}
|
||
startaufnahme();
|
||
bereit = true;
|
||
}
|
||
|
||
/** Die Spur einmalig aus dem heutigen Stand fuellen (19.09.2026).
|
||
*
|
||
* WARUM UEBERHAUPT: Ohne sie waere die Auswertungsseite am ersten Tag
|
||
* leer, und zwar fuer Monate -- bis jemand genug Einschaetzungen
|
||
* geaendert hat. Eine Seite, die nach dem Bauen leer bleibt, sieht aus
|
||
* wie ein Fehler und wird kein zweites Mal geoeffnet.
|
||
*
|
||
* WARUM DAS EHRLICH IST: Jede Zeile in `entwicklung_stand` traegt ihr
|
||
* echtes `am` -- den Tag, an dem jemand wirklich geklickt hat. Es wird
|
||
* nichts erfunden, nur uebernommen, was ohnehin dasteht. Was sich
|
||
* NICHT rekonstruieren laesst -- ob vorher schon etwas anderes
|
||
* dastand --, bleibt NULL und traegt `nachgetragen = 1`. Die
|
||
* Auswertung zaehlt diese Zeilen ausdruecklich NICHT als Bewegung:
|
||
* Der Tag der Startaufnahme ist der Nullpunkt, nicht ein Tag, an dem
|
||
* etwas passiert ist.
|
||
*
|
||
* GENAU EINMAL: nur wenn die Spur leer ist. Ein zweiter Lauf traege
|
||
* jeden Stand ein zweites Mal ein, und ab da zaehlte jede Bewegung
|
||
* doppelt.
|
||
*
|
||
* UND SIE DARF NIE DEN SERVER AUFHALTEN. Schlaegt sie fehl, ist die
|
||
* Auswertung duenn -- das ist aergerlich. Wuerde dadurch `tabellen()`
|
||
* scheitern, waere die ganze Entwicklungsseite mit 503 tot, und das
|
||
* waere ungleich schlimmer. */
|
||
function startaufnahme() {
|
||
try {
|
||
const da = db().prepare("SELECT COUNT(*) AS n FROM entwicklung_lauf").get();
|
||
if (da.n > 0) return;
|
||
|
||
const staende = db().prepare(
|
||
`SELECT person_id, schluessel, von_id, stufe, am
|
||
FROM entwicklung_stand ORDER BY am`).all();
|
||
if (!staende.length) return;
|
||
|
||
const rein = db().prepare(
|
||
`INSERT INTO entwicklung_lauf
|
||
(person_id, schluessel, von_id, stufe, vorher, nachgetragen, am)
|
||
VALUES (?,?,?,?,NULL,1,?)`);
|
||
let n = 0;
|
||
for (const s of staende) {
|
||
/* DIE SELBSTAUSKUNFT FAELLT HERAUS. Block 5 ("Wie geht es dir
|
||
damit?") hat mit dem Befinden-Verlauf eine eigene Tabelle, die
|
||
niemand sonst liest. Hier waere sie eine Aussage, die ein
|
||
Mensch ueber sich selbst gemacht hat -- und die ploetzlich in
|
||
einer Auswertung fuer die Leitung stuende. */
|
||
if (!ENTWICKLUNG_FREMD.some((x) => x.schluessel === s.schluessel)) continue;
|
||
rein.run(s.person_id, s.schluessel, s.von_id, s.stufe, s.am);
|
||
n++;
|
||
}
|
||
if (n) console.log(`[entwicklung] Startaufnahme: ${n} Staende in die Spur uebernommen.`);
|
||
} catch (f) {
|
||
console.error("[entwicklung] Startaufnahme:", f?.message);
|
||
}
|
||
}
|
||
|
||
/** Eine Aenderung in der Spur festhalten.
|
||
*
|
||
* SIE DARF NIE DEN KLICK VERHINDERN. Geht hier etwas schief, ist die
|
||
* Auswertung lueckenhaft. Wuerde dadurch die Einschaetzung nicht
|
||
* gespeichert, waere die Arbeit weg. Deshalb faengt sie ihren Fehler
|
||
* selbst und meldet ihn nur ins Protokoll der Konsole. */
|
||
function spurLegen({ personId, schluessel, vonId, stufe, vorher }) {
|
||
try {
|
||
db().prepare(
|
||
`INSERT INTO entwicklung_lauf
|
||
(person_id, schluessel, von_id, stufe, vorher, nachgetragen, am)
|
||
VALUES (?,?,?,?,?,0,?)`)
|
||
.run(personId, schluessel, vonId, stufe, vorher ?? null, jetzt());
|
||
} catch (f) {
|
||
console.error("[entwicklung] Spur:", f?.message);
|
||
}
|
||
}
|
||
|
||
/* =====================================================================
|
||
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 schritte = schritteVon(p.id);
|
||
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,
|
||
/* DER SCHRITT ZU DIESEM PUNKT. Er steht an der Karte und
|
||
nicht auf einer eigenen Liste: Wer die Beobachtung sieht,
|
||
soll im selben Blick sehen, ob daraus etwas geworden ist. */
|
||
schritt: schritte.get(pt.schluessel) || null,
|
||
};
|
||
}),
|
||
}));
|
||
|
||
/* 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,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
/* WIE DIESER MENSCH GEKOMMEN IST (17.09.2026).
|
||
|
||
Die Talentkarte sagt seit heute, wer aus ihr geworden ist. Die
|
||
Gegenrichtung fehlte: Wer hier eine Karte aufschlaegt, sieht
|
||
Namen und Punkte -- aber nicht, dass derselbe Mensch vier Wochen
|
||
lang beobachtet wurde, wer ihn eingearbeitet hat und was dabei
|
||
aufgefallen ist.
|
||
|
||
Das ist keine Nebensaechlichkeit. Beim ersten Beurteilen ist
|
||
genau das die Frage: „Woher kommt der eigentlich?“ -- und wer sie
|
||
nicht beantwortet bekommt, faengt bei null an, obwohl vier Wochen
|
||
Beobachtung vorliegen.
|
||
|
||
NUR DER HINWEIS, NICHT DIE DATEN. Die Merkmale aus dem Trichter
|
||
hierher zu kopieren waere bequem und falsch: Es sind zwei
|
||
verschiedene Kataloge mit zwei verschiedenen Fragen (taugt er? /
|
||
wie entwickelt er sich?). Eine Zahl aus dem einen im anderen
|
||
sieht aus wie eine Beurteilung und ist keine. Hier steht der
|
||
WEG dorthin -- lesen kann man ihn selbst. */
|
||
const herkunft = db().prepare(
|
||
`SELECT e.id, e.titel, s.stufe, s.seit, b.name AS buddy_name
|
||
FROM talent_stufe s
|
||
JOIN eintraege e ON e.id = s.eintrag_id
|
||
LEFT JOIN personen b ON b.id = s.buddy_id
|
||
WHERE s.person_id = ? AND e.bereich = 'talente'
|
||
ORDER BY s.seit DESC LIMIT 1`).get(p.id);
|
||
|
||
res.json({
|
||
person: { id: p.id, name: p.name, rolle_name: ROLLEN_NAME[p.rolle] ?? p.rolle },
|
||
/* Null, wenn niemand die Karte verknuepft hat -- und das ist der
|
||
Normalfall fuer alle, die vor dem 17.09. ins Team kamen. Eine
|
||
erfundene Herkunft waere schlimmer als keine. */
|
||
herkunft: herkunft ? {
|
||
eintrag_id: herkunft.id,
|
||
titel: herkunft.titel,
|
||
seit: herkunft.seit,
|
||
buddy_name: herkunft.buddy_name || null,
|
||
} : null,
|
||
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" });
|
||
}
|
||
});
|
||
|
||
/* =====================================================================
|
||
AUS EINER BEOBACHTUNG WIRD EIN SCHRITT (15.09.2026)
|
||
|
||
Filipe: „ich will die noch viel besser, perfektionniert […] so
|
||
einfach wie möglich für jeden."
|
||
|
||
---------------------------------------------------------------------
|
||
WAS GEFEHLT HAT
|
||
|
||
Die Karte konnte bisher genau eines: festhalten, dass etwas hakt --
|
||
mit Anlass, das war schon richtig. Danach passierte nichts. Beim
|
||
nächsten Öffnen stand dieselbe Beobachtung da, nur älter.
|
||
|
||
Die Quellen zur laufenden Entwicklungsbegleitung sagen übereinstimmend
|
||
zweierlei: weg von der Bewertung, hin zum Gespräch -- und ein
|
||
Entwicklungsplan wirkt dann, wenn er an einer ECHTEN Aufgabe hängt.
|
||
Nicht „daran arbeiten wir“, sondern etwas, das auf dem Aufgabenbrett
|
||
steht, einen Verantwortlichen hat und irgendwann erledigt ist.
|
||
|
||
Genau dieses Muster gibt es im Haus schon: Aus einer Idee auf einem
|
||
Brett wird eine Aufgabe. Hier ist es dasselbe, nur mit einem anderen
|
||
Ausgangspunkt -- und deshalb sieht es auch gleich aus.
|
||
|
||
---------------------------------------------------------------------
|
||
UND DANN SCHLIESST SICH DER KREIS
|
||
|
||
Ist der Schritt erledigt, sagt die Karte das und fragt dieselbe Frage
|
||
noch einmal. Das ist der Rhythmus, den die Quellen meinen: nicht
|
||
einmal im Jahr eine Bewertung, sondern eine Runde, die zu Ende geht.
|
||
|
||
Quellen:
|
||
https://www.quantumworkplace.com/future-of-work/continuous-performance-management
|
||
https://www.aihr.com/blog/continuous-performance-management/
|
||
https://www.deel.com/blog/implement-continuous-performance-management-system/
|
||
===================================================================== */
|
||
|
||
/** Wie lange ein Schritt Zeit bekommt. Vorschlag, kein Gesetz --
|
||
* auf dem Aufgabenbrett lässt sich die Frist ändern wie bei jeder
|
||
* anderen Aufgabe auch. Zwei Wochen sind nah genug, dass man sich
|
||
* erinnert, und weit genug, dass sich etwas ändern kann. */
|
||
export const SCHRITT_TAGE = 14;
|
||
|
||
/** Die Schritte zu den Punkten einer Person — einer je Punkt.
|
||
*
|
||
* ES IST IMMER DER JÜNGSTE. Wer denselben Punkt ein zweites Mal
|
||
* angeht, soll den neuen Schritt sehen und nicht den von vor einem
|
||
* halben Jahr. */
|
||
function schritteVon(personId) {
|
||
const zeilen = db().prepare(
|
||
`SELECT id, titel, status, frist, erledigt_am, aus_punkt, erstellt
|
||
FROM aufgaben
|
||
WHERE verantwortlich_id = ? AND aus_punkt IS NOT NULL
|
||
ORDER BY id DESC`).all(personId);
|
||
const nach = new Map();
|
||
for (const z of zeilen) if (!nach.has(z.aus_punkt)) nach.set(z.aus_punkt, z);
|
||
return nach;
|
||
}
|
||
|
||
entwicklungRouter.post("/workspace/api/entwicklung/person/:id/:schluessel/schritt",
|
||
gleicheHerkunft, nurLeitung, express.json({ limit: "8kb" }), (req, res) => {
|
||
try {
|
||
const id = nummer(req.params.id);
|
||
const schluessel = String(req.params.schluessel || "");
|
||
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 punkt = ENTWICKLUNG_FREMD.find((x) => x.schluessel === schluessel);
|
||
if (!punkt) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
/* NUR AUS EINEM „DA HAKT ES“ WIRD EIN SCHRITT -- und nur aus dem
|
||
EIGENEN. Aus „läuft“ einen Schritt zu machen hieße, jemandem
|
||
Arbeit zu geben für etwas, das gut läuft; aus der Beobachtung
|
||
eines anderen hieße, in seinem Namen zu handeln. */
|
||
const stand = db().prepare(
|
||
`SELECT stufe, anlass FROM entwicklung_stand
|
||
WHERE person_id = ? AND schluessel = ? AND von_id = ?`)
|
||
.get(id, schluessel, req.person.id);
|
||
if (!stand || stand.stufe !== "hakt") {
|
||
return res.status(400).json({ fehler: "kein_hakt" });
|
||
}
|
||
|
||
/* EIN OFFENER SCHRITT REICHT. Zwei Aufgaben zum selben Punkt
|
||
wären zwei Erinnerungen an dieselbe Sache -- und die zweite
|
||
macht die erste wertlos. */
|
||
const offen = db().prepare(
|
||
`SELECT id FROM aufgaben
|
||
WHERE verantwortlich_id = ? AND aus_punkt = ?
|
||
AND status NOT IN ('erledigt','abgebrochen')`).get(id, schluessel);
|
||
if (offen) return res.status(400).json({ fehler: "schon_da", aufgabe_id: offen.id });
|
||
|
||
const frist = new Date(Date.now() + SCHRITT_TAGE * 86400000).toISOString().slice(0, 10);
|
||
const jetztIso = jetzt();
|
||
db().prepare(`INSERT INTO aufgaben
|
||
(titel, beschreibung, status, prioritaet, verantwortlich_id,
|
||
frist, erstellt, erstellt_von, aus_punkt)
|
||
VALUES (?,?,'offen','mittel',?,?,?,?,?)`)
|
||
.run(
|
||
punkt.titel,
|
||
/* DER ANLASS WANDERT MIT. Ohne ihn stünde auf dem Brett ein
|
||
Satz ohne Anlass, und die Aufgabe wäre ein Vorwurf. */
|
||
`${punkt.text}\n\nWoran es aufgefallen ist: ${stand.anlass || "–"}`,
|
||
id, frist, jetztIso, req.person.id, schluessel);
|
||
const neu = db().prepare("SELECT last_insert_rowid() AS id").get().id;
|
||
|
||
protokolliere("entwicklung_schritt", {
|
||
personId: req.person.id, ip: echteIp(req),
|
||
/* KEIN ANLASS IM PROTOKOLL. Dass ein Schritt entstanden ist,
|
||
gehört hinein; woran jemand etwas gemerkt hat, nicht. */
|
||
detail: `${punkt.titel} für ${p.name}`.slice(0, 120),
|
||
});
|
||
res.status(201).json({ id: neu, titel: punkt.titel, frist });
|
||
} catch (f) {
|
||
console.error("[entwicklung] Schritt:", 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.",
|
||
});
|
||
}
|
||
|
||
/* WAS VORHER DASTAND -- VOR dem Schreiben gelesen.
|
||
Danach ist es weg: Die Tabelle ueberschreibt. Genau deshalb
|
||
gibt es die Spur, und genau deshalb steht diese Zeile hier
|
||
oben und nicht unten. */
|
||
const vorher = db().prepare(
|
||
`SELECT stufe FROM entwicklung_stand
|
||
WHERE person_id = ? AND schluessel = ? AND von_id = ?`)
|
||
.get(id, schluessel, req.person.id)?.stufe || null;
|
||
|
||
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());
|
||
|
||
/* ERST SPEICHERN, DANN MITSCHREIBEN. Die Reihenfolge ist die
|
||
Aussage: Wenn die Spur scheitert, fehlt eine Zeile in einer
|
||
Auswertung. Wenn das Speichern scheitert, ist die Arbeit weg. */
|
||
spurLegen({
|
||
personId: id, schluessel, vonId: req.person.id, stufe, vorher,
|
||
});
|
||
|
||
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 s.stufe, s.seit, s.notiz, s.buddy_id, s.erste_schicht,
|
||
s.beendet_am, s.beendet_grund, p.name AS beendet_von_name,
|
||
s.person_id, w.name AS person_name, w.aktiv AS person_aktiv,
|
||
s.zustaendig_id, s.zustaendig_seit, z.name AS zustaendig_name
|
||
FROM talent_stufe s
|
||
LEFT JOIN personen p ON p.id = s.beendet_von
|
||
LEFT JOIN personen w ON w.id = s.person_id
|
||
LEFT JOIN personen z ON z.id = s.zustaendig_id
|
||
WHERE s.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. */
|
||
/* Ein beendeter Kandidat liegt nicht -- er ist fertig. Ohne diese
|
||
Ausnahme wuerde die Standzeit weiterlaufen und die Karte nach
|
||
einer Woche rot werden, obwohl niemand mehr etwas zu tun hat. */
|
||
liegt: !stand?.beendet_am && 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),
|
||
/* WER WAS GESEHEN HAT (17.09.2026).
|
||
|
||
Filipe: "analysiert werden von vanvan und mir."
|
||
|
||
`von_id` stand seit dem Bau in der Tabelle und wurde nie
|
||
ausgeliefert -- man sah, DASS ein Merkmal gesetzt ist, nicht von
|
||
wem. Bei zwei Leuten, die unabhaengig beobachten, ist genau das
|
||
die Auskunft: Was ihr BEIDE gesehen habt, ist mehr wert als was
|
||
einer von euch gesehen hat. */
|
||
gesehen_von: Object.fromEntries(merkmale
|
||
.filter((m) => m.eintrag_id === e.id && m.von_name)
|
||
.map((m) => [m.schluessel, m.von_name])),
|
||
/* DIE PROBE. Sie steht an der Karte und nicht hinter einem eigenen
|
||
Abruf -- sonst holt man sie erst, wenn man schon entschieden
|
||
hat. */
|
||
probe: probeVon(e.id, stufe.schluessel),
|
||
/* DER AUSGANG (17.09.2026).
|
||
|
||
Die Stufe bleibt stehen -- dass jemand raus ist, steht daneben,
|
||
nicht anstelle. "Beendet in der Probe" und "beendet nach dem
|
||
ersten Hinsehen" sind zwei verschiedene Auskuenfte, und bei
|
||
einem zweiten Anlauf in einem halben Jahr ist genau der
|
||
Unterschied die Frage.
|
||
|
||
DER GRUND WIRD MITGELIEFERT, NICHT NUR DAS DATUM. Ein Ausgang
|
||
ohne Satz waere dieselbe Sackgasse, gegen die der Satz beim
|
||
Ablehnen einer Anfrage verlangt wird. */
|
||
/* WER DARAUS GEWORDEN IST (17.09.2026).
|
||
|
||
`aktiv` kommt mit: Ein Zugang, der abgeschaltet wurde, soll an
|
||
der Karte nicht aussehen wie einer, der laeuft. Die Karte bleibt
|
||
trotzdem stehen -- sie erzaehlt, wie jemand gekommen ist, und das
|
||
bleibt wahr, auch wenn er wieder geht. */
|
||
/* WER SICH KUEMMERT -- oder niemand. `null` ist hier die wichtigere
|
||
Antwort von beiden: Eine Karte, um die sich niemand kuemmert,
|
||
soll das sagen. */
|
||
zustaendig: stand?.zustaendig_id && stand?.zustaendig_name ? {
|
||
id: stand.zustaendig_id,
|
||
name: stand.zustaendig_name,
|
||
seit: stand.zustaendig_seit,
|
||
tage: tageSeit(stand.zustaendig_seit),
|
||
} : null,
|
||
person: stand?.person_id && stand?.person_name ? {
|
||
id: stand.person_id,
|
||
name: stand.person_name,
|
||
aktiv: stand.person_aktiv === 1,
|
||
} : null,
|
||
beendet: stand?.beendet_am ? {
|
||
am: stand.beendet_am,
|
||
grund: stand.beendet_grund || null,
|
||
von: stand.beendet_von_name || null,
|
||
tage: tageSeit(stand.beendet_am),
|
||
} : null,
|
||
};
|
||
}
|
||
|
||
/* =====================================================================
|
||
DIE PROBEZEIT EINES KANDIDATEN
|
||
|
||
Sie wird nur fuer die Stufe "probe" (und danach) gefuellt. An einem
|
||
Kandidaten, der noch beobachtet wird, waere eine leere Zwoelferliste
|
||
nur Laerm -- und Laerm, den man dreimal wegliest, liest man auch
|
||
dann weg, wenn er gilt.
|
||
===================================================================== */
|
||
function probeVon(eintragId, stufe) {
|
||
if (stufe !== "probe" && stufe !== "imteam") return null;
|
||
const zeilen = db().prepare(`
|
||
SELECT p.schluessel, p.am, p.notiz, x.name AS von_name
|
||
FROM talent_probe p
|
||
LEFT JOIN personen x ON x.id = p.von_id
|
||
WHERE p.eintrag_id = ?`).all(eintragId);
|
||
const stand = probeStand(zeilen.map((z) => z.schluessel));
|
||
const je = new Map(zeilen.map((z) => [z.schluessel, z]));
|
||
return {
|
||
...stand,
|
||
schritte: PROBE_ALLE.map((s) => ({
|
||
...s,
|
||
wer_name: PROBE_WER[s.wer] || s.wer,
|
||
fertig: je.has(s.schluessel),
|
||
am: je.get(s.schluessel)?.am || null,
|
||
von: je.get(s.schluessel)?.von_name || null,
|
||
notiz: je.get(s.schluessel)?.notiz || null,
|
||
})),
|
||
fragen: PROBE_FRAGEN,
|
||
};
|
||
}
|
||
|
||
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 m.eintrag_id, m.schluessel, x.name AS von_name
|
||
FROM talent_merkmal m
|
||
LEFT JOIN personen x ON x.id = m.von_id
|
||
WHERE m.eintrag_id IN (${eintraege.map(() => "?").join(", ")})`)
|
||
.all(...eintraege.map((e) => e.id))
|
||
: [];
|
||
|
||
/* BEENDETE KOMMEN AUS DER ARBEITSLISTE HERAUS -- aber nicht aus
|
||
dem Haus (17.09.2026).
|
||
|
||
Wer einmal abgesagt hat, steht sonst fuer immer im Trichter,
|
||
mit wachsender Standzeit und rotem "liegt"-Zeichen. Nach einem
|
||
halben Jahr sind das mehr als die echten Kandidaten, und dann
|
||
schaut niemand mehr hin -- eine Liste, in der 20 von 25 Eintraege
|
||
erledigt sind, ist keine Liste mehr.
|
||
|
||
SIE WERDEN TROTZDEM MITGELIEFERT, in einem eigenen Feld. Das
|
||
Loeschen waere die bequeme Variante und die, nach der in sechs
|
||
Monaten niemand mehr weiss, dass es schon einmal einen Anlauf
|
||
gab. */
|
||
const alle = eintraege.map((e) => talentKarte(e, merkmale));
|
||
const karten = alle.filter((k) => !k.beendet);
|
||
const beendete = alle.filter((k) => k.beendet);
|
||
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,
|
||
/* WELCHEN ZUGANG DER LETZTE SCHRITT ANLEGT -- Schluessel und
|
||
Wort. Beides kommt von hier, damit im Browser kein fester Text
|
||
dazu steht; siehe ZUGANG_ROLLE oben. */
|
||
zugang: { rolle: ZUGANG_ROLLE, name: ROLLEN_NAME[ZUGANG_ROLLE] ?? ZUGANG_ROLLE },
|
||
/* WOMIT EIN NEUER ANFAENGT (17.09.2026).
|
||
|
||
Filipe: „wie talente bewertet werden, aufgaben bekommen,
|
||
analysiert werden von vanvan und mir, alles moegliche."
|
||
|
||
Der Trichter endete bisher beim Zugang. Wer im Team ist, hat
|
||
einen Code -- und keine einzige Aufgabe. Um ihm welche zu
|
||
geben, musste man auf eine andere Seite, die Person dort
|
||
heraussuchen, Kategorie und Stufe waehlen und uebernehmen.
|
||
Vier Schritte, die niemand macht, waehrend er gerade jemanden
|
||
aufnimmt. Genau dieses Muster hat heute schon einmal zu einer
|
||
Karte auf „Im Team“ ohne Menschen darin gefuehrt.
|
||
|
||
ES BLEIBT EIN ANGEBOT, KEINE AUTOMATIK. Filipes Entscheidung
|
||
bei der Live-Checkliste gilt hier genauso: „vierzehn Aufgaben,
|
||
die von selbst erscheinen, ueberrumpeln, und was ungefragt
|
||
Dinge anlegt, ist schwer wieder loszuwerden." Deshalb steht
|
||
hier nur, WAS es gaebe -- angelegt wird auf Klick, eine
|
||
Kategorie auf einmal.
|
||
|
||
KEIN ROLLENNAME, nirgends. Die Kategorien heissen „chat“,
|
||
„team“, „technik“ -- aus keiner davon laesst sich schliessen,
|
||
fuer wen sie gedacht sind. Wer den Katalog nicht bekommen
|
||
darf, bekommt `null` und die Seite baut nichts; ein leeres
|
||
Feld sagt nichts, ein Feld mit sprechendem Namen saehe jeder
|
||
im Netzwerkprotokoll seines eigenen Browsers. */
|
||
start_kategorien: kategorienFuer(req.person).length
|
||
? MODI_KATEGORIEN.map((k) => ({
|
||
wert: k.wert, name: k.name, text: k.text,
|
||
anzahl: MODI_AUFGABEN_FLACH
|
||
.filter((v) => v.kategorie === k.wert && v.stufe === "neu").length,
|
||
})).filter((k) => k.anzahl > 0)
|
||
: null,
|
||
/* WAS SIE SCHON HABEN -- je Person, in EINER Abfrage.
|
||
|
||
Ohne diese Angabe legt man beim zweiten Hinsehen dasselbe noch
|
||
einmal an; der Knopf sagt dann „6 Aufgaben“ und meint die
|
||
siebte bis zwoelfte. Der Server verhindert Doppelte nicht --
|
||
er soll es auch nicht, denn dieselbe Aufgabe ein zweites Mal
|
||
kann gewollt sein. Sichtbar muss es trotzdem sein. */
|
||
schon_vergeben: (() => {
|
||
const ids = karten.map((k) => k.person?.id).filter(Boolean);
|
||
if (!ids.length) return {};
|
||
const platz = ids.map(() => "?").join(", ");
|
||
const zeilen = db().prepare(
|
||
`SELECT verantwortlich_id AS wer, COUNT(*) AS n
|
||
FROM aufgaben
|
||
WHERE verantwortlich_id IN (${platz}) AND status NOT IN ('erledigt','abgebrochen')
|
||
GROUP BY verantwortlich_id`).all(...ids);
|
||
return Object.fromEntries(zeilen.map((z) => [z.wer, z.n]));
|
||
})(),
|
||
kandidaten: karten,
|
||
/* Nach Ausgangsdatum, das juengste zuerst -- wer gerade abgesagt
|
||
hat, ist der, an den man sich erinnert. */
|
||
beendete: beendete.sort((x, y) => (y.beendet.am > x.beendet.am ? 1 : -1)),
|
||
/* 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" });
|
||
}
|
||
});
|
||
|
||
/* =====================================================================
|
||
EINEN SCHRITT DER PROBE ABHAKEN (17.09.2026)
|
||
|
||
EIN KNOPF, ZWEI RICHTUNGEN -- wie bei den Merkmalen. Ein zweiter
|
||
Klick nimmt zurueck; ein eigener Weg zum Abwaehlen waere die Stelle,
|
||
an der die Rechtepruefung irgendwann fehlt.
|
||
|
||
NUR AUF DER STUFE "PROBE". Wer einen Schritt abhakt, bevor die Probe
|
||
laeuft, haekchen einen Zeitraum ab, den es nicht gibt -- und am Tag
|
||
30 stuende eine volle Liste da, die nichts bedeutet.
|
||
===================================================================== */
|
||
entwicklungRouter.put("/workspace/api/talente/:id/probe/:schluessel", gleicheHerkunft,
|
||
express.json({ limit: "8kb" }), (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 (!PROBE_NACH_SCHLUESSEL.has(schluessel)) {
|
||
return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
}
|
||
const stand = db().prepare("SELECT stufe FROM talent_stufe WHERE eintrag_id = ?").get(id);
|
||
if (stand?.stufe !== "probe") {
|
||
return res.status(409).json({
|
||
fehler: "Das gehört in die Probezeit – die läuft für ihn gerade nicht.",
|
||
});
|
||
}
|
||
|
||
const schon = db().prepare(
|
||
"SELECT 1 AS x FROM talent_probe WHERE eintrag_id = ? AND schluessel = ?")
|
||
.get(id, schluessel);
|
||
if (schon) {
|
||
db().prepare("DELETE FROM talent_probe WHERE eintrag_id = ? AND schluessel = ?")
|
||
.run(id, schluessel);
|
||
} else {
|
||
const notiz = String(req.body?.notiz ?? "").trim().slice(0, 400) || null;
|
||
db().prepare(
|
||
"INSERT INTO talent_probe (eintrag_id, schluessel, von_id, am, notiz)"
|
||
+ " VALUES (?,?,?,?,?)")
|
||
.run(id, schluessel, req.person.id, jetzt(), notiz);
|
||
}
|
||
res.json({ ok: true, fertig: !schon });
|
||
} catch (f) {
|
||
console.error("[talente] Probe:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* =====================================================================
|
||
DEN TRICHTER SAUBER VERLASSEN (17.09.2026)
|
||
|
||
Filipe: „wie talente bewertet werden, aufgaben bekommen, analysiert
|
||
werden ... alles moegliche, wie gesagt ich will hoch profissionel
|
||
arbeiten."
|
||
|
||
EIN GRUND IST PFLICHT, und zwar aus zwei Richtungen:
|
||
|
||
Nach vorn -- wenn dieselbe Person in einem halben Jahr wieder
|
||
auffaellt, ist die erste Frage: Was war damals? Ohne Satz
|
||
beantwortet sie niemand, und man faengt bei null an.
|
||
|
||
Nach innen -- wer einen Satz schreiben muss, entscheidet anders
|
||
als wer einen Knopf drueckt. "Passt nicht" laesst sich nicht
|
||
aufschreiben, ohne dass auffaellt, dass es keine Begruendung ist.
|
||
|
||
DER EINTRAG BLEIBT. Er wird nicht geloescht, sondern bekommt ein
|
||
Datum -- und verschwindet damit aus der Arbeitsliste, nicht aus dem
|
||
Gedaechtnis. Loeschen waere die bequeme Variante und die, nach der
|
||
in sechs Monaten niemand mehr weiss, dass es schon einmal einen
|
||
Anlauf gab.
|
||
===================================================================== */
|
||
entwicklungRouter.put("/workspace/api/talente/:id/beenden", gleicheHerkunft,
|
||
express.json({ limit: "8kb" }), (req, res) => {
|
||
try {
|
||
const id = nummer(req.params.id);
|
||
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" });
|
||
|
||
const grund = text(req.body?.grund, 600);
|
||
if (grund.length < BEENDEN_GRUND_MIN) {
|
||
return res.status(400).json({
|
||
fehler: "Schreib kurz dazu, woran es lag – in einem halben Jahr "
|
||
+ "weiß es sonst niemand mehr.",
|
||
});
|
||
}
|
||
/* WER IM TEAM IST, WIRD NICHT HIER BEENDET (17.09.2026).
|
||
|
||
Gefunden am Bildschirmfoto, nicht an einer Zahl: Auf einer
|
||
Karte auf "Im Team" stand woertlich "Nichts mehr zu tun -- der
|
||
Zugang steht" und direkt darunter "Passt doch nicht?".
|
||
|
||
Ein Beenden haette dort die KARTE stillgelegt und den ZUGANG
|
||
bestehen lassen -- die Person koennte sich weiter anmelden,
|
||
waehrend im Trichter steht, sie sei raus. Das ist schlimmer
|
||
als gar kein Ausgang: Man glaubt, gehandelt zu haben.
|
||
|
||
Der Riegel steht hier und nicht nur im Browser. Was der Browser
|
||
prueft, ist Hoeflichkeit; was der Server prueft, ist die Regel. */
|
||
const wo = db().prepare("SELECT stufe FROM talent_stufe WHERE eintrag_id = ?").get(id);
|
||
if (wo?.stufe === "imteam") {
|
||
return res.status(409).json({
|
||
fehler: "Der ist schon im Team. Wer aufhört, wird unter "
|
||
+ "„Personen & Zugänge“ abgeschaltet – sonst bleibt der "
|
||
+ "Zugang offen, während hier steht, er sei raus.",
|
||
});
|
||
}
|
||
const jetztZeit = jetzt();
|
||
/* Die STUFE bleibt stehen. Wo es geendet hat, ist die Auskunft --
|
||
"beendet in der Probe" und "beendet nach dem ersten Hinsehen"
|
||
sind zwei verschiedene Saetze. */
|
||
const da = db().prepare("SELECT eintrag_id FROM talent_stufe WHERE eintrag_id = ?").get(id);
|
||
if (da) {
|
||
db().prepare(`UPDATE talent_stufe
|
||
SET beendet_am = ?, beendet_grund = ?, beendet_von = ?
|
||
WHERE eintrag_id = ?`).run(jetztZeit, grund, req.person.id, id);
|
||
} else {
|
||
db().prepare(`INSERT INTO talent_stufe
|
||
(eintrag_id, stufe, seit, von_id, beendet_am, beendet_grund, beendet_von)
|
||
VALUES (?, 'aufgefallen', ?, ?, ?, ?, ?)`)
|
||
.run(id, jetztZeit, req.person.id, jetztZeit, grund, req.person.id);
|
||
}
|
||
protokolliere("talent_beendet", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `#${id}`,
|
||
});
|
||
res.json({ ok: true, beendet: true });
|
||
} catch (f) {
|
||
console.error("[talente] Beenden:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* =====================================================================
|
||
ICH KUEMMERE MICH (17.09.2026)
|
||
|
||
Dieselbe Frage wie bei den Anfragen, nur teurer: Ein Kandidat, fuer
|
||
den sich niemand zustaendig fuehlt, bleibt auf seiner Stufe liegen.
|
||
Die Standzeit sagt, DASS etwas liegt -- nicht, wer es aufheben
|
||
sollte.
|
||
|
||
EIN KNOPF, ZWEI RICHTUNGEN. Und eine fremde Uebernahme wird
|
||
abgewiesen statt ueberschrieben: Sonst nimmt einer dem anderen den
|
||
Kandidaten aus der Hand, ohne dass es jemand merkt.
|
||
===================================================================== */
|
||
entwicklungRouter.put("/workspace/api/talente/:id/kuemmern", gleicheHerkunft,
|
||
(req, res) => {
|
||
try {
|
||
const id = nummer(req.params.id);
|
||
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" });
|
||
|
||
const stand = db().prepare(
|
||
"SELECT zustaendig_id FROM talent_stufe WHERE eintrag_id = ?").get(id);
|
||
if (stand?.zustaendig_id && stand.zustaendig_id !== req.person.id) {
|
||
const wer = db().prepare("SELECT name FROM personen WHERE id = ?")
|
||
.get(stand.zustaendig_id);
|
||
return res.status(409).json({
|
||
fehler: `Darum kümmert sich schon ${wer?.name || "jemand"}.`,
|
||
});
|
||
}
|
||
|
||
const nehmen = !stand?.zustaendig_id;
|
||
const nun = jetzt();
|
||
if (stand) {
|
||
db().prepare(`UPDATE talent_stufe SET zustaendig_id = ?, zustaendig_seit = ?
|
||
WHERE eintrag_id = ?`)
|
||
.run(nehmen ? req.person.id : null, nehmen ? nun : null, id);
|
||
} else {
|
||
/* Noch keine Stufenzeile -- die entsteht erst beim ersten
|
||
Schritt. Wer sich vorher kuemmern will, soll das koennen:
|
||
„Ich sehe ihn mir an“ ist der haeufigste erste Schritt
|
||
ueberhaupt, und er faellt sonst durch. */
|
||
db().prepare(`INSERT INTO talent_stufe
|
||
(eintrag_id, stufe, seit, von_id, zustaendig_id, zustaendig_seit)
|
||
VALUES (?, 'aufgefallen', ?, ?, ?, ?)`)
|
||
.run(id, nun, req.person.id, req.person.id, nun);
|
||
}
|
||
protokolliere(nehmen ? "talent_uebernommen" : "talent_abgegeben", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `#${id}`,
|
||
});
|
||
res.json({ ok: true, zustaendig: nehmen });
|
||
} catch (f) {
|
||
console.error("[talente] Kuemmern:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* WIEDER AUFNEHMEN -- und der alte Grund bleibt stehen.
|
||
|
||
Menschen aendern sich; ein "damals zu wenig Zeit" ist in einem Jahr
|
||
keine Aussage mehr. Wer wieder aufgenommen wird, startet deshalb
|
||
wieder bei "aufgefallen" -- aber der Satz von damals wandert in die
|
||
Notiz, statt geloescht zu werden. Genau er ist beim zweiten Anlauf
|
||
das Wertvollste, was man hat. */
|
||
entwicklungRouter.put("/workspace/api/talente/:id/wieder", gleicheHerkunft,
|
||
(req, res) => {
|
||
try {
|
||
const id = nummer(req.params.id);
|
||
const stand = id && db().prepare(
|
||
`SELECT s.eintrag_id, s.beendet_am, s.beendet_grund, s.notiz
|
||
FROM talent_stufe s JOIN eintraege e ON e.id = s.eintrag_id
|
||
WHERE s.eintrag_id = ? AND e.bereich = 'talente'`).get(id);
|
||
if (!stand) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
if (!stand.beendet_am) {
|
||
return res.status(409).json({ fehler: "Der läuft doch noch." });
|
||
}
|
||
const alt = stand.beendet_grund
|
||
? `Beim ersten Anlauf beendet: ${stand.beendet_grund}` : null;
|
||
const notiz = [stand.notiz, alt].filter(Boolean).join("\n\n").slice(0, 2000) || null;
|
||
db().prepare(`UPDATE talent_stufe
|
||
SET stufe = 'aufgefallen', seit = ?, von_id = ?, notiz = ?,
|
||
beendet_am = NULL, beendet_grund = NULL, beendet_von = NULL,
|
||
buddy_id = NULL, erste_schicht = NULL
|
||
WHERE eintrag_id = ?`)
|
||
.run(jetzt(), req.person.id, notiz, id);
|
||
/* Die Probe faengt neu an -- alte Haken wuerden sonst eine
|
||
Probezeit beschreiben, die vier Wochen zurueckliegt. */
|
||
db().prepare("DELETE FROM talent_probe WHERE eintrag_id = ?").run(id);
|
||
protokolliere("talent_wieder", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `#${id}`,
|
||
});
|
||
res.json({ ok: true });
|
||
} catch (f) {
|
||
console.error("[talente] Wieder:", 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. */
|
||
/* WER AUS DEM TALENT GEWORDEN IST (17.09.2026).
|
||
|
||
Der letzte Schritt legt einen Zugang an. Bis heute war das eine
|
||
Einbahnstrasse: Die Person entstand, ihr Code wurde einmal
|
||
gezeigt -- und die Karte wusste danach nicht, wer daraus wurde.
|
||
|
||
GEPRUEFT WIRD, OB ES DIE PERSON GIBT, und nicht nur, ob eine
|
||
Zahl ankam. Eine erfundene Nummer wuerde die Karte sonst auf
|
||
jemanden zeigen lassen, den es nicht gibt -- und das faellt erst
|
||
auf, wenn jemand darauf klickt.
|
||
|
||
NUR SETZEN, NIE LOESCHEN: Kommt kein `person_id` mit (jeder
|
||
andere Stufenwechsel), bleibt die vorhandene stehen. Sonst
|
||
verloere die Karte ihre Person, sobald jemand sie auf eine
|
||
fruehere Stufe zuruecksetzt. */
|
||
let personId = null;
|
||
if (nummer(req.body?.person_id)) {
|
||
const wer = db().prepare("SELECT id FROM personen WHERE id = ? AND aktiv = 1")
|
||
.get(nummer(req.body.person_id));
|
||
if (!wer) return res.status(400).json({ fehler: "Diesen Zugang gibt es nicht." });
|
||
personId = wer.id;
|
||
}
|
||
|
||
db().prepare(`INSERT INTO talent_stufe
|
||
(eintrag_id, stufe, seit, von_id, notiz, buddy_id, erste_schicht, person_id)
|
||
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),
|
||
person_id = COALESCE(excluded.person_id, talent_stufe.person_id)`)
|
||
.run(id, stufe, jetzt(), req.person.id, notiz || null, p.buddyId, p.schicht, personId);
|
||
|
||
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" });
|
||
}
|
||
});
|