DogFatherGit
04cfb06d33
pruef-meldungen war rot, und zwar schon vor der Arbeit dieser Woche
(mit einer zweiten Arbeitskopie auf HEAD belegt). Gemeldet waren "27
Kennungen ohne deutschen Satz" und drei Seiten, die eine Kennung roh
anzeigen. Nachgemessen war die Lage anders -- und das ist der Kern:
18 Kennungen hatten NIRGENDS einen Satz. Wer sie traf, las den
Ersatzsatz "Das hat nicht geklappt" und erfuhr damit nicht, dass
die Karte entfernt wurde oder dass es zu einer Kachel nur eine
geben kann.
9 hatten einen Satz -- aber nur in einer privaten Tabelle in
manager-ziele.js. Ueber ihr stand als Begruendung woertlich: "An
EINER Stelle: Stuende jeder dort, wo er gebraucht wird, hiesse
dieselbe Absage an zwei Stellen verschieden." Der Satz war
richtig; nur war diese Tabelle selbst inzwischen die zweite
Stelle. Drei Kennungen standen in BEIDEN mit verschiedenem
Wortlaut.
ZWEI DER DREI ROHANZEIGEN WAREN FEHLALARME: manager-ziele.js:888 und
:1322 riefen satzZu(d.fehler) -- eine echte Uebersetzung, die die
Pruefung nur nicht kannte. Echt war chat.js:3542 mit
`Ging nicht: ${d.fehler}`.
Gemacht:
- 27 Saetze nach meldung.js (157 -> 184). Der Wortlaut der neun ist
aus manager-ziele.js uebernommen, nicht neu erfunden.
- Zwei Haussaetze seitenneutral gemacht: name_fehlt sprach von einer
"Karte", nicht_deins von einem "Stueck" -- beide Kennungen kommen
gemessen von Seiten, die weder Karte noch Stueck haben. Ohne das
waere das Aufloesen der Zweittabelle eine VERSCHLECHTERUNG gewesen.
- FEHLERTEXT und satzZu in manager-ziele.js weg, 8 Aufrufe auf
sagWas umgestellt (gleiche Form: sagWas(fehler, ersatz)).
manager-ziele.html laedt meldung.js jetzt vor der Seite.
- chat.js zeigt einen Satz statt der Kennung.
An der Pruefung:
- PRUEFUNG 4 (neu): Nur die Haustabelle uebersetzt Serverkennungen.
Ausnahmen werden benannt, mit Gegenwache, dass jede noch existiert.
Der Sucher ist eng gefasst, weil ein weicherer vier Treffer meldete
und zwei davon Fehlalarme waren (`leer:` in den Spaltenlisten von
aufgaben.js und chat.js) sowie einer kein Fehler war (reaktion.js
uebersetzt schreib_grund in einen Platzhaltertext, nicht fehler:).
- PRUEFUNG 1 nennt jetzt die Zweitstelle. Ohne das schickt der Befund
in die falsche Richtung -- wer "27 ohne Satz" liest, schreibt 27
neue und hat danach drei Tabellen.
- Die Kommentar-Entfernung steht auf Modulebene, mit Selbsttest und
drittem Ausgang: raeumt sie alles weg, ist jede Suche darueber
gruen.
10 Pruefungen, 0 Fehler (vorher 8 mit 2 Fehlschlaegen) -- die Zahl ist
gestiegen, nichts ist stillschweigend weggefallen.
SECHS GEGENPROBEN, alle sechs schlagen an. Drei waren im ersten Lauf
falsch gebaut (CRLF-Anker, Variable statt Schluessel umbenannt, eine
Sabotage die nichts tat) -- das ist jeweils als Begruendung vermerkt,
weil eine blinde Sabotage genauso aussieht wie eine blinde Pruefung.
Gegenprobe 1 hat dabei einen ECHTEN Fehler in meinem neuen Pruefcode
gefunden: woSonst() griff auf `skripte` zu, das erst spaeter angelegt
wird. Im gruenen Zustand laeuft diese Zeile nie -- der Absturz waere
genau dann gekommen, wenn ein Satz fehlt, also wenn man die Meldung am
noetigsten braucht.
Geprueft: meldungen 10, manager-ziele 229, struktur 102, chat 80,
chat-optik 84, chat-anhaenge 168, workspace-seiten 37, formulare 23,
entwicklung 79, xlsx 75, lesbarkeit 14, zeichen 8, deutsche-texte 12 --
alle gruen, keine Zahl gesunken.
1414 lines
57 KiB
JavaScript
1414 lines
57 KiB
JavaScript
/* =====================================================================
|
||
manager-ziele.js — die vier festen Monatsaufgaben (02.10.2026)
|
||
=====================================================================
|
||
|
||
WAS DIESE DATEI NICHT TUT, und das ist Absicht:
|
||
|
||
SIE RECHNET NICHTS. Keine Zielzahl, keine Ampel, kein Fortschritt
|
||
entsteht hier. Alles kommt fertig vom Server (`standFuer()` in
|
||
workspace-manager-ziele.js). Der Grund ist derselbe wie überall im
|
||
Haus: Zwei Rechnungen über dieselbe Sache laufen auseinander, und
|
||
zwar lautlos — die Seite zeigt dann Grün, während die Erinnerung
|
||
per Push noch mahnt, und niemand weiß, welche von beiden recht hat.
|
||
|
||
SIE ENTSCHEIDET NICHTS ÜBER RECHTE. Ein ausgeblendeter Knopf ist
|
||
Aufräumen, keine Sicherung. Wer die Zielzahlen nicht ändern darf,
|
||
bekommt vom Server eine Absage — auch wenn er den Knopf mit den
|
||
Entwicklerwerkzeugen wieder sichtbar macht.
|
||
|
||
---------------------------------------------------------------------
|
||
EINE EINGABE GEHT NIE VERLOREN
|
||
|
||
Aus der Vorlage: „Bei Speicherfehlern geht keine Eingabe verloren."
|
||
Deshalb bleibt der Dialog bei einem Fehler OFFEN und behält seinen
|
||
Inhalt; geschlossen wird er erst, wenn der Server bestätigt hat.
|
||
Das ist der Unterschied zwischen einer Fehlermeldung und einem
|
||
verlorenen Abend.
|
||
===================================================================== */
|
||
(() => {
|
||
'use strict';
|
||
|
||
const BASIS = '/workspace/api/manager-ziele';
|
||
|
||
const el = (tag, klasse, text) => {
|
||
const k = document.createElement(tag);
|
||
if (klasse) k.className = klasse;
|
||
if (text !== undefined) k.textContent = text;
|
||
return k;
|
||
};
|
||
const $ = (id) => document.getElementById(id);
|
||
|
||
async function hole(pfad, einst = {}) {
|
||
const a = await fetch(pfad, { credentials: 'same-origin', ...einst });
|
||
/* Abgemeldet heißt zurück zur Anmeldung — nicht eine leere Seite
|
||
mit einer Fehlermeldung, die niemand einordnen kann. */
|
||
if (a.status === 401) { location.assign('/workspace/'); throw new Error('abgemeldet'); }
|
||
return a;
|
||
}
|
||
const alsJson = (einst, rumpf) => ({
|
||
...einst,
|
||
headers: { 'Content-Type': 'application/json', ...(einst.headers || {}) },
|
||
body: JSON.stringify(rumpf),
|
||
});
|
||
|
||
/* ---- DIE SÄTZE STEHEN IM HAUS, NICHT HIER (08.10.2026) -------
|
||
|
||
Hier stand eine eigene Tabelle `FEHLERTEXT` mit zwölf Sätzen,
|
||
und über ihr als Begründung: „An EINER Stelle: Stünde jeder
|
||
dort, wo er gebraucht wird, hieße dieselbe Absage an zwei
|
||
Stellen verschieden." Der Satz war richtig -- nur war die
|
||
Tabelle selbst inzwischen die zweite Stelle: Das Haus hat seit
|
||
dem 19.09.2026 `meldung.js` mit 184 Sätzen.
|
||
|
||
WAS DAS GEKOSTET HAT, GEMESSEN: Neun Kennungen hatten ihren
|
||
Satz NUR hier. `pruef-meldungen` vergleicht gegen die
|
||
Haustabelle und meldete sie deshalb als „ohne Satz" -- zu
|
||
Recht, denn jede andere Seite, die dieselbe Absage bekommt,
|
||
hätte den Ersatzsatz gezeigt. Drei weitere (`name_fehlt`,
|
||
`nicht_deins`, `nicht_erlaubt`) standen in BEIDEN Tabellen, mit
|
||
verschiedenem Wortlaut -- dieselbe Absage hieß auf zwei Seiten
|
||
Verschiedenes, genau das, was der alte Kommentar verhindern
|
||
wollte.
|
||
|
||
`sagWas(fehler, ersatz)` hat dieselbe Form wie das frühere
|
||
`sagWas(schluessel, ersatz)`: zweites Argument ist der Satz für
|
||
den Fall, dass die Kennung unbekannt ist. Der Tausch ist also
|
||
kein Umbau, sondern eine Abschrift weniger. `manager-ziele.html`
|
||
lädt `meldung.js` dafür vor dieser Datei -- ohne sie wäre
|
||
`sagWas` nicht definiert und aus einer Absage ein Absturz. */
|
||
|
||
const MONATSNAME = ['Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli',
|
||
'August', 'September', 'Oktober', 'November', 'Dezember'];
|
||
const monatText = (m) => {
|
||
const [j, n] = String(m).split('-');
|
||
return `${MONATSNAME[Number(n) - 1] || m} ${j}`;
|
||
};
|
||
/** Derselbe Tag, um `versatz` Tage verschoben. Gerechnet in UTC und
|
||
* um 12 Uhr angesetzt, damit die Sommerzeitumstellung nicht
|
||
* einen Tag verschiebt -- an zwei Nächten im Jahr hat ein Tag
|
||
* 23 oder 25 Stunden. */
|
||
const tagVersatz = (tag, versatz) => {
|
||
const d = new Date(`${tag}T12:00:00Z`);
|
||
d.setUTCDate(d.getUTCDate() + versatz);
|
||
return d.toISOString().slice(0, 10);
|
||
};
|
||
|
||
const tagText = (d) => {
|
||
const [, m, t] = String(d).split('-');
|
||
return `${t}.${m}.`;
|
||
};
|
||
|
||
/* Das Zeichen zur Stufe. FARBE NIE ALLEIN — wer Farben nicht
|
||
unterscheidet, liest hier trotzdem, woran er ist. */
|
||
/* JEDE AUFGABE HAT IHR EIGENES ZEICHEN (Vorlage, Punkt 04: „4
|
||
Aufgabenzeilen, jede mit Icon").
|
||
|
||
GENOMMEN AUS DEM HAUS, nicht neu gezeichnet: `window.Bereiche`
|
||
liefert dieselben Zeichen, die auf den Kacheln stehen
|
||
(bereiche.js laedt vor dieser Datei). Vier eigene SVG waeren vier
|
||
Formen, die bei der naechsten Stilaenderung nicht mitwandern.
|
||
|
||
Die Zuordnung ist nicht beliebig:
|
||
Creator rekrutieren -> „scouting" (der Trichter der Pipeline,
|
||
und genau dort kommen die Leute her)
|
||
Manager Meeting -> „calls" (das Zeichen fuer Gespraeche)
|
||
Schulung / Talk -> „wissen" (die aufgeschlagenen Seiten)
|
||
Werbung auf TikTok -> „content" (der Rahmen fuer Veroeffentlichtes) */
|
||
const AUFGABEN_ZEICHEN = {
|
||
creator: 'scouting', meeting: 'calls', schulung: 'wissen', werbung: 'content',
|
||
};
|
||
|
||
/* Gemessen am Bildschirmfoto vom 02.10.2026: Der Mittelpunkt „·" war
|
||
bei 412 px praktisch unsichtbar — die Zeile sah aus, als fehle das
|
||
Zeichen. Jedes Zeichen ist jetzt eine eigene, deutlich
|
||
unterscheidbare Form; „‼" ist EIN Zeichen, nicht zwei
|
||
Ausrufezeichen nebeneinander. */
|
||
const ZEICHEN = { gruen: '✓', orange: '!', rot: '‼', neutral: '○', aus: '–' };
|
||
|
||
let stand = null; // der zuletzt geladene Stand
|
||
let ichDarfZiele = false;
|
||
let ichDarfKorrigieren = false;
|
||
const offen = new Set(); // welche Zeilen aufgeklappt sind
|
||
|
||
/* =====================================================================
|
||
DIE KURZE ERFOLGSMELDUNG
|
||
===================================================================== */
|
||
let meldungWeg = null;
|
||
/** Die kurze Meldung unten.
|
||
*
|
||
* MIT „RUECKGAENGIG", wenn etwas entstanden ist. Das ist der
|
||
* Tausch, der den Schnell-Eintrag erst moeglich macht: Statt vor
|
||
* JEDEM Eintrag zu fragen („wirklich?"), kann man danach einmal
|
||
* zuruecknehmen. Die Nachfrage kostet jeden Klick, das
|
||
* Zuruecknehmen nur den, der sich vertippt hat.
|
||
*
|
||
* ACHT SEKUNDEN, nicht drei: Lange genug, um es zu lesen, zu
|
||
* verstehen und zu treffen -- auch mit einem Daumen auf einem
|
||
* Handy. */
|
||
function gelungen(text, ids) {
|
||
const alt = document.querySelector('.mz-gelungen');
|
||
if (alt) alt.remove();
|
||
clearTimeout(meldungWeg);
|
||
const k = el('p', 'mz-gelungen');
|
||
k.setAttribute('role', 'status');
|
||
k.append(document.createTextNode(text));
|
||
if (Array.isArray(ids) && ids.length) {
|
||
const zurueck = el('button', 'mz-gelungen__zurueck',
|
||
ids.length === 1 ? 'Rückgängig' : `Alle ${ids.length} zurücknehmen`);
|
||
zurueck.type = 'button';
|
||
zurueck.addEventListener('click', async () => {
|
||
zurueck.disabled = true;
|
||
let letzte = null;
|
||
for (const id of ids) {
|
||
try {
|
||
const a = await hole(`${BASIS}/eintrag/${id}`, { method: 'DELETE' });
|
||
if (a.ok) letzte = (await a.json().catch(() => ({}))).stand || letzte;
|
||
} catch { /* der naechste darf es trotzdem versuchen */ }
|
||
}
|
||
k.remove();
|
||
if (letzte) standSetzen(letzte); else laden();
|
||
gelungen(ids.length === 1 ? 'Zurückgenommen.' : `${ids.length} zurückgenommen.`);
|
||
verlaufLaden();
|
||
});
|
||
k.append(zurueck);
|
||
}
|
||
document.body.append(k);
|
||
meldungWeg = setTimeout(() => k.remove(), ids?.length ? 8000 : 2800);
|
||
}
|
||
|
||
/* =====================================================================
|
||
DER KOPF
|
||
===================================================================== */
|
||
function kopfZeichnen(s) {
|
||
$('kopf').hidden = false;
|
||
const ring = $('ring');
|
||
ring.dataset.stufe = s.stufe;
|
||
ring.style.setProperty('--mz-anteil', String(s.gesamt.anteil));
|
||
/* Die Beschriftung für die Sprachausgabe steht weiter unten, dort
|
||
wo auch das Plus gesetzt wird -- sie stand hier schon einmal und
|
||
wäre damit zweimal dagewesen, ohne das "zusätzlich". */
|
||
$('ring-zahl').textContent = String(s.gesamt.erledigt);
|
||
$('ring-von').textContent = `von ${s.gesamt.ziel}`;
|
||
|
||
/* MEHR ALS GEFORDERT -- gezählt und sichtbar (07.10.2026).
|
||
|
||
Die Zahl im Ring bleibt der Pflichtstand, das Plus steht daneben.
|
||
Beides kommt fertig vom Server (`gesamt.extra`); hier wird nichts
|
||
nachgerechnet, sonst gäbe es zwei Rechenwege für dieselbe Zahl. */
|
||
const plus = $('ring-plus');
|
||
plus.hidden = !s.gesamt.extra;
|
||
if (s.gesamt.extra) {
|
||
plus.textContent = `+${s.gesamt.extra}`;
|
||
plus.title = `${s.gesamt.extra} mehr als gefordert – zählt mit.`;
|
||
}
|
||
ring.setAttribute('aria-label', s.gesamt.extra
|
||
? `${s.gesamt.erledigt} von ${s.gesamt.ziel} erledigt, ${s.gesamt.extra} zusätzlich`
|
||
: `${s.gesamt.erledigt} von ${s.gesamt.ziel} erledigt`);
|
||
|
||
$('kopf-monat').textContent = monatText(s.monat);
|
||
$('kopf-stand').textContent = s.gesamt.ziel === 0
|
||
? 'Für deine Rolle sind diesen Monat keine Ziele gesetzt.'
|
||
: `${s.gesamt.erledigt} von ${s.gesamt.ziel} erledigt`
|
||
+ (s.gesamt.extra ? ` · ${s.gesamt.extra} zusätzlich` : '');
|
||
|
||
const rest = $('kopf-rest');
|
||
if (s.monat !== s.jetztMonat) {
|
||
rest.textContent = 'Abgeschlossener Monat – nur zum Nachlesen.';
|
||
rest.dataset.stufe = 'neutral';
|
||
} else if (!s.pflichtig) {
|
||
rest.textContent = 'Du bist diesen Monat dazugekommen – es gibt noch keine Warnungen für dich.';
|
||
rest.dataset.stufe = 'neutral';
|
||
} else {
|
||
rest.textContent = s.bisEnde <= 0
|
||
? 'Heute ist der letzte Tag des Monats.'
|
||
: `Noch ${s.bisEnde} ${s.bisEnde === 1 ? 'Tag' : 'Tage'} bis Monatsende.`;
|
||
rest.dataset.stufe = s.gesamt.offen ? s.stufe : 'gruen';
|
||
}
|
||
}
|
||
|
||
/* =====================================================================
|
||
DIE VIER ZEILEN
|
||
===================================================================== */
|
||
function zeileBauen(a, s) {
|
||
const li = el('li', 'mz-zeile');
|
||
li.dataset.stufe = a.stufe;
|
||
li.dataset.aufgabe = a.schluessel;
|
||
if (offen.has(a.schluessel)) li.dataset.auf = 'ja';
|
||
|
||
const kopf = el('button', 'mz-zeile__kopf');
|
||
kopf.type = 'button';
|
||
kopf.setAttribute('aria-expanded', offen.has(a.schluessel) ? 'true' : 'false');
|
||
|
||
/* Das Zeichen der AUFGABE, eingefaerbt in der Farbe ihrer Stufe.
|
||
Faellt window.Bereiche aus (die Datei laedt vor dieser), bleibt
|
||
das Statuszeichen als Text stehen -- eine Zeile ohne Zeichen
|
||
ist besser als eine Zeile, die gar nicht kommt. */
|
||
const zeichen = el('span', 'mz-zeile__zeichen');
|
||
zeichen.setAttribute('aria-hidden', 'true');
|
||
const svgName = AUFGABEN_ZEICHEN[a.schluessel];
|
||
if (svgName && window.Bereiche?.zeichenBauen) {
|
||
/* `dran__svg` und keine eigene Klasse: An dieser Klasse haengt
|
||
im Haus die ganze Gestaltung der kleinen Zeichen -- drei
|
||
Tiefenlagen, Deckflaeche, Glanz, 20 Pixel. Eine eigene Klasse
|
||
bekaeme nichts davon und waere eine flache Kontur neben
|
||
lauter koerperlichen Zeichen (genau der Fehler, der am
|
||
07.09.2026 in der Hinweisliste stand). */
|
||
try { zeichen.append(window.Bereiche.zeichenBauen(svgName, 'dran__svg')); }
|
||
catch { zeichen.textContent = ZEICHEN[a.stufe] || '○'; }
|
||
} else {
|
||
zeichen.textContent = ZEICHEN[a.stufe] || '○';
|
||
}
|
||
kopf.append(zeichen);
|
||
|
||
const text = el('span', 'mz-zeile__text');
|
||
text.append(el('span', 'mz-zeile__name', a.name));
|
||
/* DAS STATUSZEICHEN STEHT JETZT VOR DEM SATZ und nicht mehr
|
||
links in der Zeile -- dort sitzt seit heute das Zeichen der
|
||
Aufgabe. Es musste bleiben: „Farbe nie allein" heisst, dass
|
||
die Stufe auch ohne Farbe erkennbar ist, und ein eingefaerbtes
|
||
Aufgabenzeichen allein leistet das nicht. */
|
||
const lage = el('span', 'mz-zeile__lage');
|
||
lage.append(el('span', 'mz-zeile__stufe', ZEICHEN[a.stufe] || '○'));
|
||
lage.append(document.createTextNode(
|
||
a.text || `${a.zahl} von ${a.ziel} – ${a.hinweis}`));
|
||
lage.dataset.stufe = a.stufe;
|
||
text.append(lage);
|
||
kopf.append(text);
|
||
|
||
const zahl = el('span', 'mz-zeile__zahl', `${a.zahl}/${a.ziel}`);
|
||
/* Vorleseprogramme bekommen einen Satz statt „2 Schrägstrich 3". */
|
||
zahl.setAttribute('aria-label',
|
||
`${a.zahl} von ${a.ziel} ${a.ziel === 1 ? a.einheit[0] : a.einheit[1]}`);
|
||
kopf.append(zahl);
|
||
/* DAS PLUS ÜBER DEM ZIEL (07.10.2026).
|
||
|
||
Als EIGENES Zeichen neben der Zahl, nicht in sie hinein: Die
|
||
geforderte Zahl soll gleich bleiben, auch wenn jemand darüber
|
||
hinausgeht ("die zahl die die leute erreichen sollen sollen aber
|
||
immer gleich bleiben"). „5/2" allein liest sich wie ein Fehler
|
||
im Ziel; „5/2 +3" liest sich als das, was es ist. */
|
||
if (a.extra > 0) {
|
||
const mehr = el('span', 'mz-zeile__plus', `+${a.extra}`);
|
||
mehr.setAttribute('aria-label',
|
||
`${a.extra} mehr als gefordert, zählt mit`);
|
||
mehr.title = `${a.extra} mehr als gefordert – zählt mit.`;
|
||
kopf.append(mehr);
|
||
}
|
||
kopf.append(el('span', 'mz-zeile__pfeil', '›'));
|
||
|
||
/* NUR DIESE ZEILE AUF- UND ZUKLAPPEN, nicht die ganze Liste neu
|
||
bauen.
|
||
|
||
Der erste Entwurf rief hier `zeichnen(s)` und baute damit alle
|
||
vier Zeilen neu. Das sieht gleich aus und ist es nicht: Der
|
||
Knopf, auf den gerade getippt wurde, existiert danach nicht
|
||
mehr -- der Fokus springt an den Seitenanfang, und wer mit der
|
||
Tastatur arbeitet, verliert seine Stelle. Gefunden hat es die
|
||
Bildmessung, der die Schaltfläche unter der Hand wegbrach
|
||
(„Element is not attached to the DOM"). */
|
||
kopf.addEventListener('click', () => {
|
||
const jetztAuf = !offen.has(a.schluessel);
|
||
if (jetztAuf) offen.add(a.schluessel); else offen.delete(a.schluessel);
|
||
kopf.setAttribute('aria-expanded', jetztAuf ? 'true' : 'false');
|
||
if (jetztAuf) li.dataset.auf = 'ja'; else delete li.dataset.auf;
|
||
|
||
const alteListe = li.querySelector('.mz-eintraege');
|
||
if (!jetztAuf) { alteListe?.remove(); return; }
|
||
if (alteListe) return;
|
||
const kasten = el('div', 'mz-eintraege');
|
||
kasten.dataset.liste = a.schluessel;
|
||
kasten.append(el('p', 'mz-leer', 'Wird geladen …'));
|
||
li.append(kasten);
|
||
eintraegeLaden(a.schluessel);
|
||
});
|
||
li.append(kopf);
|
||
|
||
const balken = el('div', 'mz-balken');
|
||
const fuell = el('span', 'mz-balken__fuell');
|
||
fuell.style.setProperty('--mz-anteil',
|
||
String(a.ziel ? Math.min(100, Math.round((a.zahl / a.ziel) * 100)) : 0));
|
||
/* DER BALKEN BLEIBT BEI 100 % STEHEN -- und sagt trotzdem, dass es
|
||
mehr war. Ein Balken, der über seinen Kasten hinauswächst, hat
|
||
keine Skala mehr: Bei 10 von 1 wären alle anderen Aufgaben
|
||
optisch platt. Stattdessen bekommt er eine zweite, hellere Kappe
|
||
am Ende; die ZAHL steht als „+N" oben in der Zeile. */
|
||
if (a.extra > 0) balken.dataset.ueber = 'ja';
|
||
balken.append(fuell);
|
||
li.append(balken);
|
||
|
||
/* Die Vorschläge aus der Pipeline hängen nur an der Rekrutierung
|
||
und nur im laufenden Monat. */
|
||
if (a.schluessel === 'creator' && s.eigen && s.monat === s.jetztMonat) {
|
||
const platz = el('div');
|
||
platz.dataset.vorschlaege = 'creator';
|
||
li.append(platz);
|
||
}
|
||
|
||
const fuss = el('div', 'mz-zeile__fuss');
|
||
if (s.eigen && s.monat === s.jetztMonat) fuss.append(schnellBauen(a));
|
||
li.append(fuss);
|
||
|
||
if (offen.has(a.schluessel)) {
|
||
const kasten = el('div', 'mz-eintraege');
|
||
kasten.dataset.liste = a.schluessel;
|
||
kasten.append(el('p', 'mz-leer', 'Wird geladen …'));
|
||
li.append(kasten);
|
||
}
|
||
return li;
|
||
}
|
||
|
||
/* =====================================================================
|
||
DER SCHNELL-EINTRAG
|
||
=====================================================================
|
||
|
||
Filipe am 02.10.2026: „will dass es viel einfacher ist. am besten
|
||
so wenig wie moeglich zu tippen. fertige sachen, bereit um ab zu
|
||
gehen."
|
||
|
||
GEZAEHLT, WAS ES VORHER KOSTETE -- und das war der Punkt:
|
||
|
||
Manager Meeting Knopf, Dialog, Speichern 2 Klicks + Fenster
|
||
Schulung dazu die Art waehlen 3 Klicks + Fenster
|
||
Werbung dazu den Link tippen 2 Klicks + tippen
|
||
Creator dazu den Namen tippen 2 Klicks + tippen
|
||
|
||
Ein Fenster fuer die Aussage „ich war heute im Meeting" ist drei
|
||
Handgriffe fuer null Angaben. Jetzt:
|
||
|
||
Manager Meeting EIN Klick
|
||
Schulung EIN Klick (zwei fertige Knoepfe)
|
||
Werbung Einfuegen + Eintragen, kein Tippen
|
||
Creator ein Klick je Lead -- oder mehrere Namen auf
|
||
einmal einwerfen
|
||
|
||
DER DIALOG BLEIBT, aber als Ausnahme: „Mehr Angaben" fuer eine
|
||
Notiz oder ein anderes Datum. Er wird nicht mehr gebraucht, um
|
||
etwas Normales einzutragen -- und genau das war sein Fehler.
|
||
|
||
KEINE SICHERHEITSABFRAGE VOR DEM EINTRAGEN, sondern „Rueckgaengig"
|
||
danach. Eine Nachfrage bei jedem Klick waere der Handgriff, den
|
||
wir gerade abgeschafft haben, in neuer Verkleidung. Rueckgaengig
|
||
kostet nur den, der sich wirklich vertippt hat. */
|
||
|
||
/** Ein Feld, das auf Enter absendet -- und beim Einfuegen aus der
|
||
* Zwischenablage gleich mitnimmt, was dort steht. */
|
||
function schnellFeld(platzhalter, senden) {
|
||
const feld = el('input', 'mz-schnell__feld');
|
||
feld.type = 'text';
|
||
feld.placeholder = platzhalter;
|
||
feld.autocomplete = 'off';
|
||
feld.addEventListener('keydown', (e) => {
|
||
if (e.key === 'Enter') { e.preventDefault(); senden(); }
|
||
});
|
||
return feld;
|
||
}
|
||
|
||
/** „Einfügen" aus der Zwischenablage.
|
||
*
|
||
* DREI AUSGAENGE, wie ueberall im Haus: ging / ging nicht / der
|
||
* Browser laesst es gar nicht zu. Der dritte ist der haeufige --
|
||
* Firefox gibt die Zwischenablage ohne Erweiterung nicht her.
|
||
* Dann wird das gesagt, statt dass ein Knopf stumm bleibt. */
|
||
async function ausZwischenablage(feld) {
|
||
try {
|
||
if (!navigator.clipboard?.readText) {
|
||
gelungen('Dein Browser gibt die Zwischenablage nicht her – bitte einfügen mit Strg+V.');
|
||
feld.focus();
|
||
return;
|
||
}
|
||
const text = (await navigator.clipboard.readText()).trim();
|
||
if (!text) { gelungen('In der Zwischenablage steht nichts.'); feld.focus(); return; }
|
||
feld.value = text;
|
||
feld.focus();
|
||
} catch {
|
||
gelungen('Einfügen ging nicht – bitte mit Strg+V in das Feld.');
|
||
feld.focus();
|
||
}
|
||
}
|
||
|
||
/** Mehrere Namen aus einem Wurf: Komma, Semikolon, Zeilenumbruch
|
||
* oder Leerzeichen vor einem @ trennen. Wer drei Namen aus
|
||
* Discord kopiert, soll sie nicht einzeln eintippen muessen. */
|
||
function teilen(text) {
|
||
return String(text || '')
|
||
.split(/[,;\n\r]+|\s+(?=@)/)
|
||
.map((t) => t.trim())
|
||
.filter(Boolean);
|
||
}
|
||
|
||
/** Schickt den Schnell-Eintrag ab und meldet, was daraus wurde. */
|
||
async function schnellSenden(a, rumpf, knopf, feld) {
|
||
if (knopf) knopf.disabled = true;
|
||
try {
|
||
const antwort = await hole(`${BASIS}/eintraege`,
|
||
alsJson({ method: 'POST' }, { aufgabe: a.schluessel, datum: stand.heute, ...rumpf }));
|
||
const d = await antwort.json().catch(() => ({}));
|
||
|
||
if (!antwort.ok && !d.angelegt?.length) {
|
||
const erster = d.abgelehnt?.[0];
|
||
gelungen(erster?.text || sagWas(erster?.fehler || d.fehler));
|
||
return;
|
||
}
|
||
|
||
standSetzen(d.stand);
|
||
if (feld) { feld.value = ''; feld.focus(); }
|
||
|
||
/* WAS GEMELDET WIRD, haengt davon ab, was wirklich passiert ist
|
||
-- eine Erfolgsmeldung ueber vier Namen, von denen zwei
|
||
abgelehnt wurden, waere eine Luege. */
|
||
const n = d.angelegt.length;
|
||
const teile = [n === 1 ? 'Eingetragen' : `${n} eingetragen`];
|
||
if (d.abgelehnt?.length) {
|
||
teile.push(d.abgelehnt.length === 1
|
||
? `1 nicht: ${d.abgelehnt[0].text || sagWas(d.abgelehnt[0].fehler)}`
|
||
: `${d.abgelehnt.length} nicht übernommen (schon vorhanden oder ungültig)`);
|
||
}
|
||
if (d.warnungen?.length) teile.push(d.warnungen[0].text);
|
||
if (d.zuviel) teile.push(d.zuviel);
|
||
|
||
gelungen(teile.join(' · '), d.angelegt.map((x) => x.id));
|
||
verlaufLaden();
|
||
} catch {
|
||
gelungen('Keine Verbindung – nichts gespeichert. Bitte erneut versuchen.');
|
||
} finally {
|
||
if (knopf) knopf.disabled = false;
|
||
}
|
||
}
|
||
|
||
/** Baut die Schnellbedienung einer Aufgabe. */
|
||
function schnellBauen(a) {
|
||
const kasten = el('div', 'mz-schnell');
|
||
|
||
/* ---- Ohne Pflichtangabe: EIN Knopf, und zwar fertig ---------- */
|
||
if (!a.feld || a.feld === 'art') {
|
||
const arten = a.arten || [{ wert: null, name: 'Heute eingetragen' }];
|
||
for (const art of arten) {
|
||
/* Der Knopf sagt, was danach dasteht -- nicht „Speichern".
|
||
„Schulung heute" ist eine Handlung, „Speichern" ist eine
|
||
Rueckfrage an sich selbst. */
|
||
const text = art.wert ? `${art.name} heute` : 'Heute eingetragen';
|
||
const k = el('button', 'knopf', text);
|
||
k.type = 'button';
|
||
k.addEventListener('click', () => schnellSenden(a, art.wert ? { art: art.wert } : {}, k));
|
||
kasten.append(k);
|
||
}
|
||
}
|
||
|
||
/* ---- Mit Pflichtangabe: ein Feld, Enter reicht --------------- */
|
||
if (a.feld === 'name' || a.feld === 'link') {
|
||
const istName = a.feld === 'name';
|
||
const feld = schnellFeld(
|
||
istName ? '@name – mehrere mit Komma' : 'Link einfügen',
|
||
() => abschicken());
|
||
if (!istName) feld.type = 'url';
|
||
feld.setAttribute('aria-label', istName ? a.hinweis : 'Link zum Video');
|
||
|
||
const abschicken = () => {
|
||
const roh = feld.value.trim();
|
||
if (!roh) { feld.focus(); return; }
|
||
const teileListe = teilen(roh);
|
||
const rumpf = istName ? { namen: teileListe } : { links: teileListe };
|
||
if (a.arten) rumpf.art = artWahl.value;
|
||
schnellSenden(a, rumpf, los, feld);
|
||
};
|
||
|
||
const einfuegen = el('button', 'schritt', 'Einfügen');
|
||
einfuegen.type = 'button';
|
||
einfuegen.title = 'Aus der Zwischenablage einfügen';
|
||
einfuegen.addEventListener('click', () => ausZwischenablage(feld));
|
||
|
||
/* Die Art als fertige Auswahl mit der zuletzt benutzten vorn --
|
||
abgeleitet aus dem letzten Eintrag, nicht gespeichert. Damit
|
||
ist „Werbung für die Agentur" beim zweiten Mal ein Klick
|
||
weniger. */
|
||
let artWahl = null;
|
||
if (a.arten) {
|
||
artWahl = el('select', 'mz-schnell__art');
|
||
artWahl.setAttribute('aria-label', 'Wofür?');
|
||
for (const art of a.arten) {
|
||
const o = el('option', null, art.name);
|
||
o.value = art.wert;
|
||
artWahl.append(o);
|
||
}
|
||
artWahl.value = a.letzteArt || a.arten[0].wert;
|
||
}
|
||
|
||
const los = el('button', 'knopf', 'Eintragen');
|
||
los.type = 'button';
|
||
los.addEventListener('click', abschicken);
|
||
|
||
kasten.append(feld, einfuegen);
|
||
if (artWahl) kasten.append(artWahl);
|
||
kasten.append(los);
|
||
}
|
||
|
||
const mehr = el('button', 'schritt', 'Mehr Angaben');
|
||
mehr.type = 'button';
|
||
mehr.title = 'Mit Notiz oder einem anderen Datum eintragen';
|
||
mehr.addEventListener('click', () => formOeffnen(a, null));
|
||
kasten.append(mehr);
|
||
return kasten;
|
||
}
|
||
|
||
/* =====================================================================
|
||
DEN STAND SETZEN, OHNE DIE ZEILEN NEU ZU BAUEN
|
||
=====================================================================
|
||
|
||
`zeichnen()` baut alles neu. Fuer den Schnell-Eintrag waere das
|
||
falsch: Das Feld, in dem man gerade tippt, verschwaende unter der
|
||
Hand, und der Fokus spraenge an den Seitenanfang -- genau der
|
||
Fehler, den die Bildmessung heute schon einmal gefunden hat.
|
||
|
||
Hier werden deshalb nur die ZAHLEN nachgezogen. Was sich nie
|
||
aendert (Name, Feld, Knoepfe), bleibt stehen. */
|
||
function standSetzen(neu) {
|
||
if (!neu || !Array.isArray(neu.aufgaben)) return;
|
||
stand = { ...stand, ...neu };
|
||
kopfZeichnen(stand);
|
||
|
||
for (const a of stand.aufgaben) {
|
||
const li = document.querySelector(`.mz-zeile[data-aufgabe="${a.schluessel}"]`);
|
||
if (!li) continue;
|
||
li.dataset.stufe = a.stufe;
|
||
const zahl = li.querySelector('.mz-zeile__zahl');
|
||
if (zahl) {
|
||
zahl.textContent = `${a.zahl}/${a.ziel}`;
|
||
zahl.setAttribute('aria-label',
|
||
`${a.zahl} von ${a.ziel} ${a.ziel === 1 ? a.einheit[0] : a.einheit[1]}`);
|
||
}
|
||
const lage = li.querySelector('.mz-zeile__lage');
|
||
if (lage) {
|
||
lage.dataset.stufe = a.stufe;
|
||
lage.textContent = '';
|
||
lage.append(el('span', 'mz-zeile__stufe', ZEICHEN[a.stufe] || '○'));
|
||
lage.append(document.createTextNode(
|
||
a.text || `${a.zahl} von ${a.ziel} – ${a.hinweis}`));
|
||
}
|
||
const fuell = li.querySelector('.mz-balken__fuell');
|
||
if (fuell) {
|
||
fuell.style.setProperty('--mz-anteil',
|
||
String(a.ziel ? Math.min(100, Math.round((a.zahl / a.ziel) * 100)) : 0));
|
||
}
|
||
/* Die aufgeklappte Liste darunter zeigt jetzt etwas anderes. */
|
||
if (offen.has(a.schluessel)) eintraegeLaden(a.schluessel);
|
||
}
|
||
if (stand.eigen && stand.monat === stand.jetztMonat) vorschlaegeLaden();
|
||
}
|
||
|
||
function zeichnen(s) {
|
||
stand = s;
|
||
kopfZeichnen(s);
|
||
const liste = $('liste');
|
||
liste.textContent = '';
|
||
for (const a of s.aufgaben) liste.append(zeileBauen(a, s));
|
||
/* Die offenen Listen und die Vorschläge wieder füllen — sie
|
||
hängen an Zeilen, die eben neu gebaut wurden. */
|
||
for (const schluessel of offen) eintraegeLaden(schluessel);
|
||
if (s.eigen && s.monat === s.jetztMonat) vorschlaegeLaden();
|
||
}
|
||
|
||
/* =====================================================================
|
||
DIE EIGENEN EINTRÄGE EINER AUFGABE
|
||
===================================================================== */
|
||
async function eintraegeLaden(aufgabe) {
|
||
const kasten = document.querySelector(`[data-liste="${aufgabe}"]`);
|
||
if (!kasten || !stand) return;
|
||
try {
|
||
const frage = new URLSearchParams({ monat: stand.monat, aufgabe });
|
||
if (!stand.eigen) frage.set('person', String(stand.person.id));
|
||
const a = await hole(`${BASIS}/eintraege?${frage}`);
|
||
if (!a.ok) throw new Error('fehler');
|
||
const d = await a.json();
|
||
kasten.textContent = '';
|
||
if (!d.eintraege.length) {
|
||
kasten.append(el('p', 'mz-leer',
|
||
'Noch nichts eingetragen – starte mit deinem ersten Eintrag.'));
|
||
return;
|
||
}
|
||
for (const e of d.eintraege) kasten.append(eintragBauen(e, aufgabe, d.bearbeitbar));
|
||
} catch {
|
||
kasten.textContent = '';
|
||
const p = el('p', 'mz-leer', 'Die Liste konnte nicht geladen werden. ');
|
||
const k = el('button', 'schritt', 'Erneut versuchen');
|
||
k.type = 'button';
|
||
k.addEventListener('click', () => eintraegeLaden(aufgabe));
|
||
p.append(k);
|
||
kasten.append(p);
|
||
}
|
||
}
|
||
|
||
function eintragBauen(e, aufgabe, bearbeitbar) {
|
||
const zeile = el('div', 'mz-eintrag');
|
||
zeile.append(el('span', 'mz-eintrag__datum', tagText(e.datum)));
|
||
|
||
const was = el('span', 'mz-eintrag__was');
|
||
if (e.name) {
|
||
was.append(document.createTextNode(e.name));
|
||
if (e.lead_id) {
|
||
const marke = el('span', 'mz-eintrag__marke', 'aus Pipeline');
|
||
marke.title = 'Dieser Eintrag ist mit einem Lead im Scout-CRM verbunden.';
|
||
was.append(marke);
|
||
}
|
||
} else if (e.link) {
|
||
const a = el('a', null, kurzLink(e.link));
|
||
a.href = e.link; a.target = '_blank'; a.rel = 'noopener noreferrer';
|
||
was.append(a);
|
||
} else {
|
||
/* Der Name der Aufgabe statt des Wortes „Eintrag" -- bei einem
|
||
Meeting steht sonst „02.10. Eintrag" da, und das sagt nichts. */
|
||
const ohneFeld = stand?.aufgaben.find((x) => x.schluessel === aufgabe);
|
||
was.append(document.createTextNode(
|
||
artName(aufgabe, e.art) || ohneFeld?.einheit?.[0] || ohneFeld?.kurz || 'Eintrag'));
|
||
}
|
||
if (e.art && (e.name || e.link)) {
|
||
was.append(el('span', 'mz-eintrag__marke', artName(aufgabe, e.art)));
|
||
}
|
||
if (e.doppelt_bei) {
|
||
const m = el('span', 'mz-eintrag__marke',
|
||
`auch bei ${e.doppelt_name || 'jemand anderem'}`);
|
||
was.append(m);
|
||
}
|
||
if (e.notiz) was.append(el('span', 'mz-eintrag__notiz', e.notiz));
|
||
zeile.append(was);
|
||
|
||
if (bearbeitbar) {
|
||
const knoepfe = el('div', 'mz-eintrag__knoepfe');
|
||
const bearbeiten = el('button', 'schritt', 'Bearbeiten');
|
||
bearbeiten.type = 'button';
|
||
bearbeiten.addEventListener('click', () => {
|
||
const a = stand.aufgaben.find((x) => x.schluessel === aufgabe);
|
||
formOeffnen(a, e);
|
||
});
|
||
const loeschen = el('button', 'schritt', 'Löschen');
|
||
loeschen.type = 'button';
|
||
loeschen.addEventListener('click', () => eintragLoeschen(e, aufgabe));
|
||
knoepfe.append(bearbeiten, loeschen);
|
||
zeile.append(knoepfe);
|
||
}
|
||
return zeile;
|
||
}
|
||
|
||
function kurzLink(w) {
|
||
try {
|
||
const u = new URL(w);
|
||
const kurz = u.host.replace(/^www\./, '') + u.pathname;
|
||
return kurz.length > 44 ? kurz.slice(0, 42) + '…' : kurz;
|
||
} catch { return w; }
|
||
}
|
||
function artName(aufgabe, wert) {
|
||
const a = stand?.aufgaben.find((x) => x.schluessel === aufgabe);
|
||
return a?.arten?.find((x) => x.wert === wert)?.name || '';
|
||
}
|
||
|
||
async function eintragLoeschen(e, aufgabe) {
|
||
const was = e.name || (e.link ? kurzLink(e.link) : tagText(e.datum));
|
||
/* ==== KEIN ZWEITER NOTNAGEL (02.10.2026) =======================
|
||
|
||
Hier stand `window.frageNach ? … : window.confirm(…)`. Der
|
||
Hintergedanke war richtig -- es soll etwas passieren, auch wenn
|
||
die Datei fehlt. Nur hat `nachfrage.js` genau diesen Notnagel
|
||
SCHON, und zwar mit demselben Text wie der richtige Dialog
|
||
(siehe den Kopf dieser Datei: „wer den Notnagel bekommt, soll
|
||
dieselbe Auskunft haben wie alle anderen").
|
||
|
||
Der Rückfall hier war der zweite -- und der schlechtere: nur
|
||
„‚X' löschen?", ohne den Satz, was verschwindet, und ohne den
|
||
Hinweis, dass der Lead im Scout-CRM bleibt. Zwei Antworten auf
|
||
dieselbe Frage, und die kürzere hätte gewonnen.
|
||
|
||
`pruef-nachfrage` hat es gemeldet („keine Seite benutzt noch
|
||
confirm() oder prompt()"); die Seite lädt `nachfrage.js`, das
|
||
prüft dieselbe Datei eine Zeile weiter. */
|
||
const frage = await window.frageNach({
|
||
titel: `„${was}“ löschen?`,
|
||
was: 'Der Eintrag verschwindet aus deinem Monatszähler.',
|
||
bleibt: e.lead_id ? 'Der Lead im Scout-CRM bleibt bestehen.' : '',
|
||
endgueltig: true, ja: 'Löschen',
|
||
});
|
||
if (!frage) return;
|
||
try {
|
||
const a = await hole(`${BASIS}/eintrag/${e.id}`, { method: 'DELETE' });
|
||
const d = await a.json().catch(() => ({}));
|
||
if (!a.ok) { gelungen(sagWas(d.fehler)); return; }
|
||
standSetzen(d.stand);
|
||
gelungen('Eintrag gelöscht.');
|
||
} catch {
|
||
gelungen('Löschen hat nicht geklappt.');
|
||
}
|
||
}
|
||
|
||
/* =====================================================================
|
||
DIE VORSCHLÄGE AUS DER PIPELINE
|
||
===================================================================== */
|
||
async function vorschlaegeLaden() {
|
||
const platz = document.querySelector('[data-vorschlaege="creator"]');
|
||
if (!platz) return;
|
||
try {
|
||
const a = await hole(`${BASIS}/vorschlaege`);
|
||
if (!a.ok) return;
|
||
const d = await a.json();
|
||
platz.textContent = '';
|
||
if (!d.vorschlaege.length) return;
|
||
|
||
const kasten = el('div', 'mz-vorschlag');
|
||
kasten.append(el('p', 'mz-vorschlag__titel',
|
||
d.vorschlaege.length === 1
|
||
? 'Aus deiner Pipeline: 1 übergebener Lead ist noch nicht eingetragen'
|
||
: `Aus deiner Pipeline: ${d.vorschlaege.length} übergebene Leads sind noch nicht eingetragen`));
|
||
const reihe = el('div', 'mz-vorschlag__reihe');
|
||
for (const v of d.vorschlaege) {
|
||
const k = el('button', 'schritt mz-vorschlag__knopf',
|
||
`+ ${v.handle || v.name}`);
|
||
k.type = 'button';
|
||
k.addEventListener('click', () => {
|
||
const a2 = stand.aufgaben.find((x) => x.schluessel === 'creator');
|
||
formOeffnen(a2, null, {
|
||
name: v.handle || v.name,
|
||
lead_id: v.id,
|
||
datum: (v.uebergeben_am || '').slice(0, 10) || undefined,
|
||
});
|
||
});
|
||
reihe.append(k);
|
||
}
|
||
kasten.append(reihe);
|
||
platz.append(kasten);
|
||
} catch { /* Vorschläge sind ein Angebot – ihr Ausfall darf die Seite nicht stören. */ }
|
||
}
|
||
|
||
/* =====================================================================
|
||
DAS FORMULAR
|
||
===================================================================== */
|
||
const dlg = $('form-dialog');
|
||
let formAufgabe = null;
|
||
let formEintrag = null;
|
||
let formLead = null;
|
||
|
||
function formOeffnen(aufgabe, eintrag, vorbelegt = {}) {
|
||
formAufgabe = aufgabe;
|
||
formEintrag = eintrag;
|
||
formLead = eintrag?.lead_id || vorbelegt.lead_id || null;
|
||
|
||
$('form-titel').textContent = eintrag ? 'Eintrag bearbeiten' : aufgabe.name;
|
||
/* NICHT der Feldhinweis -- der steht zwei Zeilen tiefer noch
|
||
einmal am Feld selbst. Eine Zeile, die dasselbe sagt wie die
|
||
darunter, kostet Platz und erklaert nichts (gesehen auf dem
|
||
Bildschirmfoto vom 02.10.2026). Hier steht stattdessen, WOFUER
|
||
der Eintrag zaehlt und was schon ausgefuellt ist. */
|
||
$('form-unter').textContent =
|
||
`Zählt für ${monatText(stand.monat)} · Datum ist auf heute vorausgefüllt`;
|
||
$('form-fehler').textContent = '';
|
||
|
||
$('feld-name').hidden = aufgabe.feld !== 'name';
|
||
$('feld-link').hidden = aufgabe.feld !== 'link';
|
||
$('feld-art').hidden = !aufgabe.arten;
|
||
$('treffer').hidden = true;
|
||
|
||
$('e-name').value = eintrag?.name || vorbelegt.name || '';
|
||
$('e-link').value = eintrag?.link || '';
|
||
$('e-notiz').value = eintrag?.notiz || '';
|
||
|
||
if (aufgabe.arten) {
|
||
const auswahl = $('e-art');
|
||
auswahl.textContent = '';
|
||
for (const art of aufgabe.arten) {
|
||
const o = el('option', null, art.name);
|
||
o.value = art.wert;
|
||
auswahl.append(o);
|
||
}
|
||
auswahl.value = eintrag?.art || aufgabe.arten[0].wert;
|
||
$('art-schild').textContent = aufgabe.schluessel === 'werbung' ? 'Wofür?' : 'Art';
|
||
}
|
||
|
||
/* DATUM: heute vorausgefüllt, und die Grenzen stehen am Feld.
|
||
Das ist mehr als Bequemlichkeit — der Kalender des Handys lässt
|
||
dann gar nichts Falsches erst zu, und die Absage vom Server
|
||
wird zur zweiten Sicherung statt zur ersten Begegnung. */
|
||
const datum = $('e-datum');
|
||
datum.min = `${stand.monat}-01`;
|
||
datum.max = stand.heute;
|
||
datum.value = eintrag?.datum || vorbelegt.datum || stand.heute;
|
||
|
||
/* DREI FERTIGE TAGE STATT EINES KALENDERS.
|
||
„Heute" ist ohnehin vorbelegt; „Gestern" und „Vorgestern" sind
|
||
die beiden Faelle, die in der Praxis vorkommen (man traegt
|
||
abends oder am naechsten Morgen nach). Alles weiter zurueck
|
||
geht weiterhin ueber das Datumsfeld -- aber niemand muss mehr
|
||
einen Kalender aufmachen, um „gestern" zu sagen. */
|
||
const schnelltage = $('datum-schnell');
|
||
schnelltage.textContent = '';
|
||
for (const [versatz, text] of [[0, 'Heute'], [-1, 'Gestern'], [-2, 'Vorgestern']]) {
|
||
const tag = tagVersatz(stand.heute, versatz);
|
||
/* Was nicht mehr in diesen Monat gehoert, wird gar nicht erst
|
||
angeboten -- ein Knopf, der eine Absage holt, ist schlimmer
|
||
als kein Knopf. Am 1. und 2. des Monats fallen deshalb
|
||
welche weg, und das ist richtig so. */
|
||
if (tag.slice(0, 7) !== stand.monat) continue;
|
||
const k = el('button', 'schritt', text);
|
||
k.type = 'button';
|
||
k.addEventListener('click', () => {
|
||
datum.value = tag;
|
||
for (const x of schnelltage.children) x.removeAttribute('data-an');
|
||
k.dataset.an = 'ja';
|
||
});
|
||
if (tag === datum.value) k.dataset.an = 'ja';
|
||
schnelltage.append(k);
|
||
}
|
||
|
||
dlg.showModal();
|
||
setTimeout(() => {
|
||
const erstes = aufgabe.feld === 'name' ? $('e-name')
|
||
: (aufgabe.feld === 'link' ? $('e-link') : datum);
|
||
erstes.focus();
|
||
}, 40);
|
||
}
|
||
|
||
$('form-abbruch').addEventListener('click', () => dlg.close());
|
||
|
||
$('form').addEventListener('submit', async (ereignis) => {
|
||
ereignis.preventDefault();
|
||
const fehler = $('form-fehler');
|
||
fehler.textContent = '';
|
||
const knopf = $('form-speichern');
|
||
knopf.disabled = true;
|
||
|
||
const rumpf = {
|
||
aufgabe: formAufgabe.schluessel,
|
||
datum: $('e-datum').value,
|
||
notiz: $('e-notiz').value,
|
||
};
|
||
if (formAufgabe.feld === 'name') rumpf.name = $('e-name').value;
|
||
if (formAufgabe.feld === 'link') rumpf.link = $('e-link').value;
|
||
if (formAufgabe.arten) rumpf.art = $('e-art').value;
|
||
if (formLead) rumpf.lead_id = formLead;
|
||
|
||
try {
|
||
const a = formEintrag
|
||
? await hole(`${BASIS}/eintrag/${formEintrag.id}`,
|
||
alsJson({ method: 'PATCH' }, rumpf))
|
||
: await hole(`${BASIS}/eintrag`, alsJson({ method: 'POST' }, rumpf));
|
||
const d = await a.json().catch(() => ({}));
|
||
|
||
if (!a.ok) {
|
||
/* DER DIALOG BLEIBT OFFEN und behält alles. Vorlage: „Bei
|
||
Speicherfehlern geht keine Eingabe verloren." */
|
||
fehler.textContent = d.text || sagWas(d.fehler);
|
||
knopf.disabled = false;
|
||
return;
|
||
}
|
||
|
||
dlg.close();
|
||
/* `standSetzen` statt `zeichnen`: nur die Zahlen nachziehen.
|
||
Ein Neuaufbau wuerde die aufgeklappte Liste wegwerfen und den
|
||
Fokus an den Seitenanfang schicken. */
|
||
standSetzen(d.stand);
|
||
if (!formEintrag && d.id) offen.add(formAufgabe.schluessel);
|
||
gelungen(d.warnung ? d.warnung.text : 'Gespeichert.',
|
||
formEintrag ? null : (d.id ? [d.id] : null));
|
||
verlaufLaden();
|
||
} catch {
|
||
fehler.textContent = 'Keine Verbindung. Deine Eingabe steht noch da – bitte erneut versuchen.';
|
||
} finally {
|
||
knopf.disabled = false;
|
||
}
|
||
});
|
||
|
||
/* ---------- Namensvorschläge beim Tippen ------------------------- */
|
||
let tippUhr = null;
|
||
$('e-name').addEventListener('input', () => {
|
||
/* Mit dem Tippen löst sich die Verbindung zum Lead: Wer den Namen
|
||
ändert, meint einen anderen Menschen. Eine Verbindung, die
|
||
stehen bleibt, wäre schlimmer als keine. */
|
||
formLead = null;
|
||
clearTimeout(tippUhr);
|
||
tippUhr = setTimeout(trefferLaden, 220);
|
||
});
|
||
$('e-name').addEventListener('blur', () => {
|
||
/* Erst nach dem Klick schließen — sonst verschwindet die Liste,
|
||
bevor der Finger sie trifft. */
|
||
setTimeout(() => { $('treffer').hidden = true; }, 160);
|
||
});
|
||
|
||
async function trefferLaden() {
|
||
const liste = $('treffer');
|
||
const q = $('e-name').value.trim();
|
||
if (q.length < 2) { liste.hidden = true; return; }
|
||
try {
|
||
const a = await hole(`${BASIS}/namen?q=${encodeURIComponent(q)}`);
|
||
if (!a.ok) { liste.hidden = true; return; }
|
||
const d = await a.json();
|
||
liste.textContent = '';
|
||
if (!d.treffer.length) { liste.hidden = true; return; }
|
||
for (const t of d.treffer) {
|
||
const li = el('li');
|
||
const k = el('button', null);
|
||
k.type = 'button';
|
||
k.append(document.createTextNode(t.handle || t.name));
|
||
k.append(el('span', 'mz-treffer__lage', `aus der Pipeline · ${t.status}`));
|
||
k.addEventListener('click', () => {
|
||
$('e-name').value = t.handle || t.name;
|
||
formLead = t.id;
|
||
liste.hidden = true;
|
||
});
|
||
li.append(k);
|
||
liste.append(li);
|
||
}
|
||
liste.hidden = false;
|
||
} catch { liste.hidden = true; }
|
||
}
|
||
|
||
/* =====================================================================
|
||
DER VERLAUF
|
||
===================================================================== */
|
||
async function verlaufLaden() {
|
||
try {
|
||
const frage = stand && !stand.eigen ? `?person=${stand.person.id}` : '';
|
||
const a = await hole(`${BASIS}/verlauf${frage}`);
|
||
if (!a.ok) return;
|
||
const d = await a.json();
|
||
const block = $('verlauf-block');
|
||
const platz = $('verlauf');
|
||
platz.textContent = '';
|
||
if (!d.monate.length) { block.hidden = true; return; }
|
||
block.hidden = false;
|
||
|
||
const tabelle = el('table', 'mz-tabelle');
|
||
const kopf = el('thead');
|
||
const kz = el('tr');
|
||
kz.append(el('th', null, 'Monat'));
|
||
for (const a2 of (stand?.aufgaben || [])) kz.append(el('th', null, a2.kurz));
|
||
kz.append(el('th', null, 'Gesamt'));
|
||
kopf.append(kz);
|
||
tabelle.append(kopf);
|
||
|
||
const koerper = el('tbody');
|
||
for (const m of d.monate) {
|
||
const tr = el('tr');
|
||
const geschafft = m.aufgaben.every((x) => x.erreicht !== false);
|
||
tr.dataset.stufe = geschafft ? 'gruen' : 'rot';
|
||
const t1 = el('td', null, monatText(m.monat));
|
||
t1.dataset.schild = 'Monat';
|
||
tr.append(t1);
|
||
for (const x of m.aufgaben) {
|
||
const td = el('td', 'mz-wert');
|
||
td.dataset.schild = x.kurz;
|
||
const punkt = el('span', 'mz-punkt');
|
||
punkt.dataset.stufe = x.erreicht === null ? 'aus' : (x.erreicht ? 'gruen' : 'rot');
|
||
td.append(punkt);
|
||
td.append(document.createTextNode(
|
||
x.erreicht === null ? 'nicht gefordert' : `${x.zahl}/${x.ziel}`));
|
||
/* Auch im Verlauf: Was über dem Ziel lag, bleibt sichtbar.
|
||
Sonst sieht ein Monat mit Mehrarbeit später genauso aus wie
|
||
einer, der gerade so gereicht hat. */
|
||
if (x.extra > 0) td.append(el('span', 'mz-zeile__plus', `+${x.extra}`));
|
||
tr.append(td);
|
||
}
|
||
const tg = el('td', 'mz-wert', `${m.gesamt.erledigt}/${m.gesamt.ziel}`);
|
||
if (m.gesamt.extra > 0) tg.append(el('span', 'mz-zeile__plus', `+${m.gesamt.extra}`));
|
||
tg.dataset.schild = 'Gesamt';
|
||
tr.append(tg);
|
||
koerper.append(tr);
|
||
}
|
||
tabelle.append(koerper);
|
||
platz.append(tabelle);
|
||
} catch { /* Der Verlauf ist eine Zugabe – sein Ausfall darf den Monat nicht verdecken. */ }
|
||
}
|
||
|
||
/* =====================================================================
|
||
DIE TEAM-ÜBERSICHT
|
||
===================================================================== */
|
||
/* WONACH DIE TEAM-TABELLE SORTIERT IST.
|
||
|
||
Vorgabe: die Dringlichsten zuerst. Wer die Uebersicht aufmacht,
|
||
will zuerst wissen, wo es klemmt -- nicht, wer im Alphabet vorn
|
||
steht. Ein Klick auf eine Spalte dreht die Reihenfolge um. */
|
||
let teamSortierung = { spalte: 'ampel', ab: false };
|
||
|
||
const RANG_STUFE = { rot: 0, orange: 1, neutral: 2, gruen: 3, aus: 4 };
|
||
|
||
const AMPEL_WORT = {
|
||
gruen: 'erreicht', orange: 'Monatsmitte', rot: 'dringend',
|
||
neutral: 'offen', aus: '—',
|
||
};
|
||
const spaltenName = (schluessel, d) => {
|
||
if (schluessel === 'name') return 'Person';
|
||
if (schluessel === 'gesamt') return 'Gesamt';
|
||
if (schluessel === 'ampel') return 'Ampel';
|
||
return d.aufgaben.find((x) => x.schluessel === schluessel)?.kurz || schluessel;
|
||
};
|
||
|
||
function teamSortieren(leute) {
|
||
const { spalte, ab } = teamSortierung;
|
||
const wert = (p) => {
|
||
if (spalte === 'name') return p.name.toLowerCase();
|
||
if (spalte === 'ampel') return RANG_STUFE[p.stufe] ?? 9;
|
||
if (spalte === 'gesamt') return p.gesamt.ziel ? p.gesamt.erledigt / p.gesamt.ziel : 2;
|
||
const a = p.aufgaben.find((x) => x.schluessel === spalte);
|
||
/* DER ANTEIL UND NICHT DIE NACKTE ZAHL: 2 von 3 ist weiter als
|
||
2 von 8, und eine Spalte, die das nicht unterscheidet,
|
||
sortiert die Falschen nach oben. Ohne Ziel (0) steht die
|
||
Zeile ganz hinten -- sie ist nicht gefordert. */
|
||
if (!a) return 9;
|
||
return a.ziel ? a.zahl / a.ziel : 2;
|
||
};
|
||
return [...leute].sort((x, y) => {
|
||
const wx = wert(x), wy = wert(y);
|
||
let v = 0;
|
||
if (wx < wy) v = -1; else if (wx > wy) v = 1;
|
||
/* Bei Gleichstand der Name -- sonst springen Zeilen bei jedem
|
||
Neuladen, und man glaubt, es habe sich etwas geaendert. */
|
||
if (!v) v = x.name.localeCompare(y.name, 'de');
|
||
return ab ? -v : v;
|
||
});
|
||
}
|
||
|
||
async function teamLaden() {
|
||
if (!ichDarfZiele) return;
|
||
const monat = $('team-monat').value || stand.jetztMonat;
|
||
try {
|
||
const a = await hole(`${BASIS}/team?monat=${encodeURIComponent(monat)}`);
|
||
if (!a.ok) return;
|
||
const d = await a.json();
|
||
const platz = $('team');
|
||
platz.textContent = '';
|
||
|
||
const filter = $('team-filter').value;
|
||
const gefiltert = d.leute.filter((p) => {
|
||
if (filter === 'rot') return p.stufe === 'rot';
|
||
if (filter === 'orange') return p.stufe === 'rot' || p.stufe === 'orange';
|
||
if (filter === 'offen') return p.gesamt.offen > 0;
|
||
return true;
|
||
});
|
||
const leute = teamSortieren(gefiltert);
|
||
|
||
if (!leute.length) {
|
||
platz.append(el('p', 'mz-leer', 'Niemand passt auf diesen Filter – das ist eine gute Nachricht.'));
|
||
return;
|
||
}
|
||
|
||
const tabelle = el('table', 'mz-tabelle');
|
||
const kopf = el('thead');
|
||
const kz = el('tr');
|
||
|
||
/* JEDE SPALTENUEBERSCHRIFT IST EIN KNOPF, nicht ein anklickbares
|
||
<th>. Ein <th> mit einem Klickzuhoerer erreicht man mit der
|
||
Tastatur nicht, und ein Vorleseprogramm nennt es nicht als
|
||
bedienbar -- es sieht nur so aus, als ginge es. */
|
||
const spalte = (schluessel, text) => {
|
||
const th = el('th');
|
||
th.scope = 'col';
|
||
const aktiv = teamSortierung.spalte === schluessel;
|
||
/* `aria-sort` sagt Vorleseprogrammen, wonach gerade sortiert
|
||
ist. Ohne das ist eine sortierte Tabelle fuer sie eine
|
||
beliebig gemischte. */
|
||
th.setAttribute('aria-sort',
|
||
aktiv ? (teamSortierung.ab ? 'descending' : 'ascending') : 'none');
|
||
const k = el('button', 'mz-sort');
|
||
k.type = 'button';
|
||
k.append(document.createTextNode(text));
|
||
k.append(el('span', 'mz-sort__pfeil', aktiv ? (teamSortierung.ab ? '▾' : '▴') : ''));
|
||
k.title = 'Nach ' + text + ' sortieren';
|
||
k.addEventListener('click', () => {
|
||
if (teamSortierung.spalte === schluessel) teamSortierung.ab = !teamSortierung.ab;
|
||
else teamSortierung = { spalte: schluessel, ab: false };
|
||
teamLaden();
|
||
});
|
||
th.append(k);
|
||
return th;
|
||
};
|
||
|
||
/* Die Liste in der Leiste wird aus DENSELBEN Spalten gebaut
|
||
wie die Ueberschriften -- einmal, beim ersten Zeichnen. Zwei
|
||
Listen waeren die Stelle, an der eine Aufgabe fehlt, sobald
|
||
eine fuenfte dazukommt. */
|
||
sortListeFuellen(d);
|
||
|
||
kz.append(spalte('name', 'Person'));
|
||
for (const a2 of d.aufgaben) kz.append(spalte(a2.schluessel, a2.kurz));
|
||
kz.append(spalte('gesamt', 'Gesamt'));
|
||
kz.append(spalte('ampel', 'Ampel'));
|
||
kopf.append(kz);
|
||
tabelle.append(kopf);
|
||
|
||
const koerper = el('tbody');
|
||
for (const p of leute) {
|
||
const tr = el('tr');
|
||
tr.dataset.stufe = p.stufe;
|
||
|
||
const td1 = el('td');
|
||
td1.dataset.schild = 'Person';
|
||
/* „Spicy Media · Spicy Media" stand hier beim ersten Bild --
|
||
bei dieser Rolle ist der Anzeigename gleich dem Rollennamen.
|
||
Der Zusatz hilft nur, wenn er etwas hinzufuegt. */
|
||
const beschriftung = p.name === p.rollenName
|
||
? p.name : `${p.name} · ${p.rollenName}`;
|
||
if (p.id === null) {
|
||
/* Ein geloeschter Zugang hat keine Nummer mehr -- es gibt
|
||
nichts zum Aufmachen. Ein Knopf, der nichts tut, ist
|
||
schlimmer als kein Knopf. */
|
||
td1.append(el('span', 'mz-ehemalig', beschriftung));
|
||
} else {
|
||
const name = el('button', 'schritt', beschriftung);
|
||
name.type = 'button';
|
||
name.addEventListener('click', () => personAnsehen(p.id, monat));
|
||
td1.append(name);
|
||
}
|
||
/* DREI ZUSTAENDE, DREI SAETZE. „nicht mehr dabei" und „neu"
|
||
sahen vorher gleich aus (beide ohne Warnung) -- und wer die
|
||
Tabelle liest, haette den Unterschied raten muessen. */
|
||
if (p.ehemalig) {
|
||
td1.append(el('span', 'mz-eintrag__marke', 'nicht mehr dabei'));
|
||
} else if (!p.pflichtig) {
|
||
td1.append(el('span', 'mz-eintrag__marke', 'neu – ohne Warnung'));
|
||
}
|
||
tr.append(td1);
|
||
|
||
for (const a2 of p.aufgaben) {
|
||
const td = el('td', 'mz-wert');
|
||
td.dataset.schild = d.aufgaben.find((x) => x.schluessel === a2.schluessel)?.kurz || '';
|
||
const punkt = el('span', 'mz-punkt');
|
||
punkt.dataset.stufe = a2.stufe;
|
||
td.append(punkt);
|
||
td.append(document.createTextNode(`${a2.zahl}/${a2.ziel}`));
|
||
tr.append(td);
|
||
}
|
||
const tg = el('td', 'mz-wert', `${p.gesamt.erledigt}/${p.gesamt.ziel}`);
|
||
tg.dataset.schild = 'Gesamt';
|
||
tr.append(tg);
|
||
|
||
/* Die Ampel als eigene Spalte -- mit Punkt UND Wort. Nur so
|
||
kann man danach sortieren, ohne die Farbe zu sehen. */
|
||
const ta = el('td', 'mz-wert');
|
||
ta.dataset.schild = 'Ampel';
|
||
const ap = el('span', 'mz-punkt');
|
||
ap.dataset.stufe = p.stufe;
|
||
ta.append(ap);
|
||
ta.append(document.createTextNode(AMPEL_WORT[p.stufe] || p.stufe));
|
||
tr.append(ta);
|
||
|
||
koerper.append(tr);
|
||
}
|
||
tabelle.append(koerper);
|
||
platz.append(tabelle);
|
||
platz.append(el('p', 'mz-ziele__gilt',
|
||
`${leute.length} von ${d.leute.length} Personen · sortiert nach `
|
||
+ `„${spaltenName(teamSortierung.spalte, d)}“`));
|
||
} catch {
|
||
$('team').textContent = '';
|
||
$('team').append(el('p', 'mz-leer', 'Die Übersicht konnte nicht geladen werden.'));
|
||
}
|
||
}
|
||
|
||
/** Fuellt die Sortier-Auswahl in der Leiste und haelt sie mit der
|
||
* Spaltensortierung gleich. Wer oben an einer Spalte sortiert,
|
||
* sieht es unten im Feld -- und umgekehrt. Zwei Bedienelemente,
|
||
* die verschiedene Dinge behaupten, sind schlimmer als eines. */
|
||
function sortListeFuellen(d) {
|
||
const auswahl = $('team-sort');
|
||
if (!auswahl) return;
|
||
const spalten = [
|
||
['ampel', 'Ampel (dringendste zuerst)'],
|
||
['name', 'Person'],
|
||
...d.aufgaben.map((a) => [a.schluessel, a.kurz]),
|
||
['gesamt', 'Gesamt'],
|
||
];
|
||
const gleich = auswahl.options.length === spalten.length
|
||
&& [...auswahl.options].every((o, i) => o.value === spalten[i][0]);
|
||
if (!gleich) {
|
||
auswahl.textContent = '';
|
||
for (const [wert, text] of spalten) {
|
||
const o = el('option', null, text);
|
||
o.value = wert;
|
||
auswahl.append(o);
|
||
}
|
||
}
|
||
auswahl.value = teamSortierung.spalte;
|
||
const knopf = $('team-richtung');
|
||
if (knopf) {
|
||
knopf.textContent = teamSortierung.ab ? 'absteigend ▾' : 'aufsteigend ▴';
|
||
knopf.setAttribute('aria-pressed', teamSortierung.ab ? 'true' : 'false');
|
||
}
|
||
}
|
||
|
||
async function personAnsehen(id, monat) {
|
||
try {
|
||
const a = await hole(`${BASIS}/stand?person=${id}&monat=${encodeURIComponent(monat)}`);
|
||
if (!a.ok) return;
|
||
const s = await a.json();
|
||
/* ALLE VIER ZEILEN AUFKLAPPEN. Vorlage, Punkt 08: „Klick auf
|
||
eine Person zeigt deren Einträge und Verlauf." Blieben sie
|
||
zu, zeigte der Klick nur Zahlen -- und man müsste viermal
|
||
weiterklicken, um das zu sehen, was versprochen war. */
|
||
offen.clear();
|
||
for (const a2 of s.aufgaben) offen.add(a2.schluessel);
|
||
zeichnen(s);
|
||
$('seiten-titel').textContent = `${s.person.name} · ${monatText(s.monat)}`;
|
||
/* Fremde Einträge korrigieren dürfen DogFather und Spicy Media
|
||
(Filipe, 02.10.2026: „ja spicy und dogfather"). Der Satz
|
||
steht hier, damit niemand erst durch Ausprobieren
|
||
herausfindet, ob die Knöpfe etwas tun -- entschieden wird es
|
||
ohnehin auf dem Server. */
|
||
$('kopf-rest').textContent = ichDarfKorrigieren
|
||
? 'Du siehst eine fremde Übersicht. Korrekturen werden mit deinem Namen protokolliert.'
|
||
: 'Du siehst eine fremde Übersicht – nur zum Nachlesen.';
|
||
verlaufLaden();
|
||
window.scrollTo({ top: 0, behavior: 'smooth' });
|
||
} catch { /* still */ }
|
||
}
|
||
|
||
/* =====================================================================
|
||
DIE ZIELZAHLEN
|
||
===================================================================== */
|
||
const zieleDlg = $('ziele-dialog');
|
||
|
||
async function zieleOeffnen() {
|
||
try {
|
||
const a = await hole(`${BASIS}/ziele`);
|
||
if (!a.ok) { gelungen(sagWas('nicht_erlaubt')); return; }
|
||
const d = await a.json();
|
||
$('ziele-gilt').textContent =
|
||
`Die Zahlen gelten ab ${monatText(d.naechsterMonat)}. Der laufende Monat bleibt, wie er ist.`;
|
||
const platz = $('ziele-felder');
|
||
platz.textContent = '';
|
||
|
||
const tabelle = el('table', 'mz-tabelle');
|
||
const kopf = el('thead');
|
||
const kz = el('tr');
|
||
kz.append(el('th', null, 'Rolle'));
|
||
for (const a2 of d.aufgaben) kz.append(el('th', null, a2.kurz));
|
||
kopf.append(kz);
|
||
tabelle.append(kopf);
|
||
const koerper = el('tbody');
|
||
for (const r of d.naechster) {
|
||
const tr = el('tr');
|
||
const td1 = el('td', null, r.rollenName);
|
||
td1.dataset.schild = 'Rolle';
|
||
tr.append(td1);
|
||
for (const a2 of d.aufgaben) {
|
||
const td = el('td');
|
||
td.dataset.schild = a2.kurz;
|
||
const feld = el('input', 'mz-ziele__zahl');
|
||
feld.type = 'number'; feld.min = '0'; feld.max = '99'; feld.step = '1';
|
||
feld.value = String(r.ziele[a2.schluessel] ?? a2.vorgabe);
|
||
feld.dataset.rolle = r.rolle;
|
||
feld.dataset.aufgabe = a2.schluessel;
|
||
feld.setAttribute('aria-label', `${r.rollenName}: ${a2.name}`);
|
||
td.append(feld);
|
||
tr.append(td);
|
||
}
|
||
koerper.append(tr);
|
||
}
|
||
tabelle.append(koerper);
|
||
platz.append(tabelle);
|
||
platz.append(el('p', 'mz-ziele__gilt',
|
||
'0 heißt: Für diese Rolle ist die Aufgabe nicht gefordert – sie warnt dann nie.'));
|
||
$('ziele-fehler').textContent = '';
|
||
zieleDlg.showModal();
|
||
} catch { gelungen('Die Zielzahlen konnten nicht geladen werden.'); }
|
||
}
|
||
|
||
$('ziele-abbruch')?.addEventListener('click', () => zieleDlg.close());
|
||
|
||
$('ziele-form')?.addEventListener('submit', async (ereignis) => {
|
||
ereignis.preventDefault();
|
||
const fehler = $('ziele-fehler');
|
||
fehler.textContent = '';
|
||
const ziele = {};
|
||
for (const feld of $('ziele-felder').querySelectorAll('input[data-rolle]')) {
|
||
const wert = Number(feld.value);
|
||
if (!Number.isInteger(wert) || wert < 0 || wert > 99) {
|
||
fehler.textContent = sagWas('ziel_ungueltig');
|
||
feld.focus();
|
||
return;
|
||
}
|
||
(ziele[feld.dataset.rolle] ||= {})[feld.dataset.aufgabe] = wert;
|
||
}
|
||
try {
|
||
const a = await hole(`${BASIS}/ziele`, alsJson({ method: 'PUT' }, { ziele }));
|
||
const d = await a.json().catch(() => ({}));
|
||
if (!a.ok) { fehler.textContent = sagWas(d.fehler); return; }
|
||
zieleDlg.close();
|
||
gelungen(`Gilt ab ${monatText(d.monat)}.`);
|
||
} catch {
|
||
fehler.textContent = 'Keine Verbindung. Deine Zahlen stehen noch da – bitte erneut versuchen.';
|
||
}
|
||
});
|
||
|
||
/* =====================================================================
|
||
START
|
||
===================================================================== */
|
||
async function laden() {
|
||
$('ladefehler').hidden = true;
|
||
try {
|
||
const a = await hole(`${BASIS}/stand`);
|
||
if (a.status === 404) {
|
||
/* Diese Seite gibt es für diese Rolle oder auf dieser Adresse
|
||
nicht. Zurück zur Startseite statt eines leeren Gerüsts —
|
||
eine Seite, die lädt und dann leer bleibt, sieht aus wie ein
|
||
Fehler und ist einer. */
|
||
location.assign('/workspace/start.html');
|
||
return;
|
||
}
|
||
if (!a.ok) throw new Error(`HTTP ${a.status}`);
|
||
const s = await a.json();
|
||
|
||
if (s.vorErstemMonat) {
|
||
$('kopf').hidden = true;
|
||
$('liste').append(el('li', 'mz-leer',
|
||
`Es geht erst mit ${monatText(s.erster)} los – vorher gibt es nichts einzutragen.`));
|
||
return;
|
||
}
|
||
|
||
ichDarfZiele = !!s.darfZiele;
|
||
ichDarfKorrigieren = !!s.darfKorrigieren;
|
||
zeichnen(s);
|
||
verlaufLaden();
|
||
|
||
if (ichDarfZiele) {
|
||
$('team-block').hidden = false;
|
||
monatsAuswahlFuellen(s);
|
||
teamLaden();
|
||
}
|
||
} catch (fehler) {
|
||
$('ladefehler').hidden = false;
|
||
$('ladefehler-grund').textContent =
|
||
String(fehler?.message || '').startsWith('HTTP')
|
||
? 'Der Server hat nicht geantwortet.'
|
||
: 'Keine Verbindung zum Server.';
|
||
}
|
||
}
|
||
|
||
function monatsAuswahlFuellen(s) {
|
||
const auswahl = $('team-monat');
|
||
auswahl.textContent = '';
|
||
let m = s.jetztMonat;
|
||
for (let i = 0; i < 18 && m >= s.erster; i++) {
|
||
const o = el('option', null, monatText(m));
|
||
o.value = m;
|
||
auswahl.append(o);
|
||
const [j, n] = m.split('-').map(Number);
|
||
const d = new Date(Date.UTC(j, n - 2, 1));
|
||
m = `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, '0')}`;
|
||
}
|
||
auswahl.value = s.monat;
|
||
}
|
||
|
||
$('team-monat')?.addEventListener('change', teamLaden);
|
||
$('team-filter')?.addEventListener('change', teamLaden);
|
||
$('team-sort')?.addEventListener('change', (e) => {
|
||
teamSortierung = { spalte: e.target.value, ab: teamSortierung.ab };
|
||
teamLaden();
|
||
});
|
||
$('team-richtung')?.addEventListener('click', () => {
|
||
teamSortierung = { ...teamSortierung, ab: !teamSortierung.ab };
|
||
teamLaden();
|
||
});
|
||
$('ziele-auf')?.addEventListener('click', zieleOeffnen);
|
||
$('team-csv')?.addEventListener('click', () => {
|
||
const monat = $('team-monat').value || stand.jetztMonat;
|
||
location.assign(`${BASIS}/export.csv?monat=${encodeURIComponent(monat)}`);
|
||
});
|
||
$('nochmal')?.addEventListener('click', laden);
|
||
|
||
laden();
|
||
})();
|