DogFatherGitandClaude Opus 5
2b74e40007
Nach dem Aufgabenblock und der dritten Zahl war noch ein Rest da, und
zwar der auffaelligste: In der Mitte der Seite stand gross
100 %
HEUTE NICHTS OFFEN
Der Ring zaehlt AUFGABEN -- was heute faellig war und was davon fertig
ist. Ein Mitglied hat keine, also stand dort dauerhaft 100 %. Dieselbe
tote Zahl wie "0 betreut" daneben, nur groesser.
Was ein Mitglied an dieser Stelle wissen will, ist etwas anderes:
Laeuft heute noch etwas? Der Ring zaehlt bei ihm jetzt die TERMINE des
Tages und faerbt, was davon vorbei ist. Bei null Terminen sagt er das
in Worten ("Heute steht nichts an") statt eine Null als Prozentzahl
auszugeben -- jede Prozentangabe waere da eine Behauptung ueber
nichts.
Dafuer kann der Server jetzt `mitte` schicken: einen Text fuer die
Ringmitte. Fehlt das Feld, bleibt alles wie bisher -- fuer alle
anderen aendert sich nichts.
UND DER FUSSTEXT ERKLAERTE EINEN KASTEN, DEN ES NICHT GAB. Unten stand
"„Was ist dran" fuehrt keine eigene Liste, sondern zeigt ..." -- der
Kasten selbst erscheint aber nur, wenn er etwas zu zeigen hat, und bei
einem Mitglied nie. Eine Erklaerung fuer etwas, das nicht da ist, ist
schlimmer als keine: Man sucht danach. Sie verschwindet jetzt mit ihm.
Gemessen (Handy): Startseite 1781 -> 1634 px.
pruef-community-sicht 10, pruef-zentrale-ring 14, pruef-vorlagen 24 --
alle ohne Fehler.
Co-Authored-By: Claude Opus 5 <[email protected]>
427 lines
20 KiB
JavaScript
427 lines
20 KiB
JavaScript
/* =====================================================================
|
||
workspace-zentrale.js — die Zahlen fuer den Ring auf der Startseite.
|
||
|
||
Wunsch Filipe (08.09.2026): die Begruessungskachel nach dem Vorbild
|
||
von VanVans Business Hub umbauen -- grosser Ring links, Text in der
|
||
Mitte, Uhr rechts. Dort zeigt der Ring "91 % deiner Produktakten":
|
||
ein Segment je Produkt, eingefaerbt nach Vollstaendigkeit.
|
||
|
||
---------------------------------------------------------------------
|
||
WARUM ES DIESELBE ZAHL HIER NICHT GIBT
|
||
|
||
Nachgemessen an der echten Datenbank am 08.09.2026:
|
||
|
||
Termine 31 · Wissen 7 · Schulungen 4 · Personen 9 · AUFGABEN 1
|
||
Leistung, Leads, Profile, Content-Saeulen, Dateien: jeweils 0
|
||
|
||
VanVans Kranz funktioniert, weil 253 Produkte ein BILD ergeben. Ein
|
||
Kranz aus einer Aufgabe ergibt keins. Die naheliegende Uebertragung
|
||
("dann eben Aufgaben") haette eine leere Scheibe erzeugt, die aussieht
|
||
wie ein Ladefehler.
|
||
|
||
Filipe hat deshalb DAS TEAM gewaehlt: ein Segment je Person, gefaerbt
|
||
danach, wie es um sie steht. Neun Segmente sind wenige, aber sie sind
|
||
ECHT und aendern sich taeglich -- und die Zahl waechst mit dem Team.
|
||
|
||
---------------------------------------------------------------------
|
||
UND WARUM DAS NICHT FUER JEDEN GEHT
|
||
|
||
Ein Creator darf die Teamliste nicht sehen. Das ist keine
|
||
Feinheit, sondern die Regel, die diesen ganzen Arbeitsplatz traegt
|
||
(Wunsch Filipe, 07.09.2026: "jeder soll und darf im kalender immer nur
|
||
seine eigenen eintraege nur sehen"). Ein Ring, der neun Namen
|
||
einfaerbt, waere fuer einen Creator ein Leck -- er koennte daran
|
||
ablesen, wer heute Termine hat und wer nicht.
|
||
|
||
Deshalb liefert diese Route ZWEI VERSCHIEDENE RINGE, je nach Rolle:
|
||
|
||
Leitung (DogFather, Manager, Scout, Spicy)
|
||
-> das Team: ein Segment je aktiver Person
|
||
Creator -> der eigene Tag: ein Segment je Stunde, plus die
|
||
eigenen Termine als Marken
|
||
|
||
Das ist keine Notloesung, sondern die richtige Antwort auf dieselbe
|
||
Frage: "Wie weit ist das, wofuer ich zustaendig bin?" Fuer DogFather
|
||
ist das sein Team, fuer eine Creatorin ihr Tag.
|
||
|
||
KEINE EIGENEN DATEN, wie bei den Hinweisen: Alles hier ist eine SICHT
|
||
auf Zeilen, die ohnehin existieren. Es gibt nichts zu pflegen und
|
||
nichts, was veralten kann.
|
||
===================================================================== */
|
||
|
||
import express from "express";
|
||
import { db, sitzungLesen, istLeitung, betreuteIds, scoutsVon, verborgeneIds, hausBedingung,
|
||
TEAM_DOGI_ROLLEN } from "./workspace.js";
|
||
import { freigabeBedingung } from "./workspace-treff.js";
|
||
|
||
export const zentraleRouter = express.Router();
|
||
|
||
function angemeldet(req, res, next) {
|
||
const person = sitzungLesen(req);
|
||
if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
|
||
req.person = person;
|
||
next();
|
||
}
|
||
zentraleRouter.use("/workspace/api/zentrale", angemeldet);
|
||
|
||
const p2 = (n) => String(n).padStart(2, "0");
|
||
/* ORTSZEIT, NICHT UTC. toISOString() liefert zwischen Mitternacht und
|
||
zwei Uhr noch den Vortag -- der Ring stuende dann auf den Terminen
|
||
von gestern. Derselbe Fehler ist mir am 08.09. zweimal an einem Abend
|
||
passiert; pruef-struktur.mjs sucht ihn inzwischen im ganzen Repo. */
|
||
function heuteLokal() {
|
||
const d = new Date();
|
||
return `${d.getFullYear()}-${p2(d.getMonth() + 1)}-${p2(d.getDate())}`;
|
||
}
|
||
|
||
zentraleRouter.get("/workspace/api/zentrale", (req, res) => {
|
||
try {
|
||
const d = db();
|
||
const heute = heuteLokal();
|
||
/* WESSEN LAGE WIRD GEZEIGT? -- EINE VARIABLE, NICHT ZWEI.
|
||
|
||
Hier standen bis zum 11.09.2026 ZWEI: `ich` (immer der
|
||
Angemeldete) fuer den Ring, und `zeigt` fuer die drei Zahlen
|
||
darunter. Gedacht war, dass beide der fremden Sicht folgen; im
|
||
Code stand dafuer `req.person.sicht` -- ein Feld, das es nicht
|
||
gibt. Der Ausdruck war also immer `undefined || req.person`.
|
||
|
||
Ergebnis: Sah DogFather sich den Arbeitsplatz eines Modis an,
|
||
zeigte der Ring seine eigene Lage ("Team versorgt", alle Creator
|
||
des Hauses), waehrend darunter die Zahlen der anderen Person
|
||
standen. Zwei Wahrheiten in einer Kachel -- und weil ein Tippfehler
|
||
in einer Variablen nichts kaputt macht, sondern nur nichts tut,
|
||
faellt so etwas nie von selbst auf. Gefunden, indem die Antwort in
|
||
fremder Sicht mit der verglichen wurde, die die Person SELBST
|
||
bekommt.
|
||
|
||
Deshalb jetzt genau ein Name fuer genau eine Frage. Alles in
|
||
dieser Route ist Anzeige, kein Recht: Es gibt nichts zu schreiben
|
||
und nichts zu pruefen. Und weil DogFather ohnehin alles sehen
|
||
darf, kann die Sicht hier nur WENIGER zeigen, nie mehr. */
|
||
const zeigt = req.sicht || req.person;
|
||
|
||
/* ================================================================
|
||
WESSEN TEAM? JEDE ROLLE SIEHT IHR EIGENES (08.09.2026)
|
||
|
||
Filipe, nachdem Managerin Schulle "2 Creator" angezeigt bekam,
|
||
obwohl sie einen hat: "die zahl die da angezeigt wird soll bitte
|
||
immer jedem genau zutreffend sein" -- und dazu, wer was sieht:
|
||
|
||
"dogfather und cigdem haben die zahl vom insgesamten. manager
|
||
sehen nur die gesamte zahl ihrer scouts und ihren creator die
|
||
ihnen zugeteilt sind, die scout sehen die zahl nur von ihren
|
||
creator und die creator da termine vom tag selber"
|
||
|
||
Vorher stand hier `SELECT ... FROM personen WHERE aktiv = 1` --
|
||
ALLE, fuer jeden aus der Leitung gleich. Deshalb sah Schulle das
|
||
ganze Haus statt ihres Teams. Die Zahl war nicht falsch berechnet,
|
||
sie beantwortete die falsche Frage.
|
||
|
||
Die Zuordnung selbst wird NICHT hier nachgebaut: `betreuteIds`
|
||
kennt die Kette Manager -> Scouts -> deren Creator bereits, und
|
||
`scoutsVon` die Scouts. Eine zweite Rechenvorschrift fuer
|
||
dieselbe Frage waere genau der Weg, auf dem zwei Wahrheiten
|
||
entstehen.
|
||
|
||
SCOUTS BEKOMMEN JETZT AUCH DIESEN RING. Sie zaehlen nicht zur
|
||
Leitung und sahen deshalb den Stundenring des eigenen Tages --
|
||
aber ein Scout hat ein Team, naemlich seine Creator. Genau danach
|
||
hat Filipe gefragt. */
|
||
const istTeamsicht = istLeitung(zeigt) || zeigt.rolle === "scout";
|
||
|
||
if (istTeamsicht) {
|
||
/* ---------- DAS TEAM ----------
|
||
Ein Segment je Person im eigenen Verantwortungsbereich. Der
|
||
Zustand einer Person ist bewusst GROB in drei Stufen -- mehr
|
||
taeuschte Genauigkeit vor, die es nicht gibt (dieselbe
|
||
Ueberlegung steht in VanVans Kranz).
|
||
|
||
frei - nichts Offenes, keine Termine heute -> ruhig
|
||
dran - hat heute Termine -> die sind versorgt
|
||
offen - hat unerledigte Termine aus der VERGANGENHEIT
|
||
-> das ist das, was liegen bleibt
|
||
*/
|
||
let leute;
|
||
if (zeigt.rolle === "admin" || zeigt.rolle === "spicy") {
|
||
/* Das ganze Haus -- und zwar ohne sich selbst: Wer den Ring
|
||
ansieht, ist die Person, die ihn liest; sich selbst als
|
||
Segment im eigenen Team zu zaehlen, verschiebt jede Prozent-
|
||
angabe um einen Platz. */
|
||
/* AUCH HIER GILT DIE VERBERGUNGSREGEL (09.09.2026).
|
||
|
||
Diese Abfrage geht als einzige NICHT durch die zentralen
|
||
Listenfunktionen -- sie holt sich das Haus selbst. Genau
|
||
deshalb war sie die eine Stelle, an der Spicy Media VanVan
|
||
noch gesehen hat, nachdem alle anderen Wege zu waren.
|
||
`server/pruef-verborgen.mjs` hat es beim ersten Lauf
|
||
gemeldet; ohne die Pruefung waere es nicht aufgefallen, denn
|
||
im Ring steht nur ein farbiges Segment mit einem Namen in
|
||
der Sprechblase. */
|
||
const weg = verborgeneIds(zeigt);
|
||
const zusatz = weg.length ? ` AND id NOT IN (${weg.map(() => "?").join(",")})` : "";
|
||
/* UND AUF DER TEAM-ADRESSE NUR DAS TEAM (10.09.2026).
|
||
|
||
Genau die Stelle, auf die Filipe im Bildschirmfoto gezeigt
|
||
hat: Im Ring stand "9 IM TEAM", obwohl sein Team drei Leute
|
||
hat -- gezaehlt wurde das ganze Haus. Der Kommentar darueber
|
||
sagt es selbst: Diese Abfrage ist die einzige, die sich die
|
||
Menschen selbst holt, statt durch die Listenfunktionen zu
|
||
gehen. Wer dort etwas aendert, muss hier daran denken; die
|
||
Bedingung kommt deshalb aus derselben Funktion. */
|
||
leute = d.prepare(
|
||
`SELECT id, name, rolle FROM personen
|
||
WHERE aktiv = 1 AND id <> ?${zusatz}${hausBedingung(zeigt)} ORDER BY rolle, name`)
|
||
.all(zeigt.id, ...weg);
|
||
} else {
|
||
/* Manager: seine Scouts UND die Creator (eigene wie die seiner
|
||
Scouts). Scout: nur seine Creator. */
|
||
const ids = [...new Set([
|
||
...(zeigt.rolle === "manager" ? scoutsVon(zeigt.id) : []),
|
||
...betreuteIds(zeigt),
|
||
])].filter((id) => id !== zeigt.id);
|
||
|
||
leute = ids.length
|
||
? d.prepare(
|
||
`SELECT id, name, rolle FROM personen
|
||
WHERE aktiv = 1 AND id IN (${ids.map(() => "?").join(",")})
|
||
ORDER BY rolle, name`).all(...ids)
|
||
: [];
|
||
}
|
||
|
||
const heuteZaehler = d.prepare(
|
||
`SELECT COUNT(*) AS n FROM termine t
|
||
WHERE t.erledigt = 0 AND substr(t.beginn, 1, 10) = ?
|
||
AND (t.creator_id = ? OR t.erstellt_von = ?
|
||
OR EXISTS (SELECT 1 FROM termin_teilnehmer x
|
||
WHERE x.termin_id = t.id AND x.person_id = ?))`);
|
||
const altZaehler = d.prepare(
|
||
`SELECT COUNT(*) AS n FROM termine t
|
||
WHERE t.erledigt = 0 AND substr(t.beginn, 1, 10) < ?
|
||
AND (t.creator_id = ? OR t.erstellt_von = ?
|
||
OR EXISTS (SELECT 1 FROM termin_teilnehmer x
|
||
WHERE x.termin_id = t.id AND x.person_id = ?))`);
|
||
|
||
const segmente = leute.map((p) => {
|
||
const heuteN = heuteZaehler.get(heute, p.id, p.id, p.id).n;
|
||
const altN = altZaehler.get(heute, p.id, p.id, p.id).n;
|
||
const stufe = altN > 0 ? "offen" : (heuteN > 0 ? "dran" : "frei");
|
||
/* NUR DER VORNAME nach aussen. Der Ring braucht ein Kuerzel fuer
|
||
die Sprechblase, nicht den Datensatz einer Person. */
|
||
return { name: String(p.name || "").trim().split(/\s+/)[0] || "?",
|
||
rolle: p.rolle, stufe, heute: heuteN, alt: altN };
|
||
});
|
||
|
||
const versorgt = segmente.filter((s) => s.stufe !== "offen").length;
|
||
|
||
/* Ein Scout fuehrt Creator, kein "Team" im Sinne des Hauses. Das
|
||
Wort auf dem Ring sagt deshalb, WEN er zaehlt -- sonst liest ein
|
||
Scout "Team versorgt" und sucht die anderen vier Rollen darin. */
|
||
const nurCreator = zeigt.rolle === "scout";
|
||
|
||
return res.json({
|
||
art: "team",
|
||
titel: nurCreator ? "Creator versorgt" : "Team versorgt",
|
||
prozent: segmente.length ? Math.round((versorgt / segmente.length) * 100) : 100,
|
||
segmente,
|
||
zahlen: [
|
||
{ wert: segmente.length, schild: nurCreator ? "meine Creator" : "im Team" },
|
||
{ wert: segmente.filter((s) => s.stufe === "dran").length, schild: "heute dran" },
|
||
/* "liegt liegen" stand hier und war nicht zu verstehen -- Filipe
|
||
wortwoertlich: "keine ahnung was das bedeuten soll". Gezaehlt
|
||
werden Personen mit unerledigten Terminen aus der
|
||
VERGANGENHEIT. "Ueberfaellig" sagt das in einem Wort und ist
|
||
der Begriff, der auch sonst im Haus dafuer steht. */
|
||
{ wert: segmente.filter((s) => s.stufe === "offen").length, schild: "überfällig" },
|
||
],
|
||
});
|
||
}
|
||
|
||
/* ---------- DER EIGENE TAG ----------
|
||
Fuer Creator. Ein Segment je Stunde von 6 bis 24 -- der Teil des
|
||
Tages, in dem gearbeitet wird. Nachts einen leeren Halbkreis zu
|
||
zeigen sagt nichts; 18 Segmente fuellen den Ring ordentlich.
|
||
|
||
Gefuellt sind die vergangenen Stunden, markiert die mit einem
|
||
eigenen Termin. Der Ring beantwortet damit "wie weit ist mein
|
||
Tag" -- dieselbe Frage wie bei VanVan, nur auf das bezogen,
|
||
wofuer eine Creatorin zustaendig ist. */
|
||
const VON = 6, BIS = 24;
|
||
const jetzt = new Date();
|
||
const stundeJetzt = jetzt.getHours();
|
||
|
||
const meine = d.prepare(
|
||
`SELECT t.beginn FROM termine t
|
||
WHERE substr(t.beginn, 1, 10) = ?
|
||
AND (t.creator_id = ? OR t.erstellt_von = ?
|
||
OR EXISTS (SELECT 1 FROM termin_teilnehmer x
|
||
WHERE x.termin_id = t.id AND x.person_id = ?))`)
|
||
.all(heute, zeigt.id, zeigt.id, zeigt.id);
|
||
const mitTermin = new Set(meine.map((t) => Number(String(t.beginn).slice(11, 13))));
|
||
|
||
const segmente = [];
|
||
for (let s = VON; s < BIS; s++) {
|
||
segmente.push({ name: `${p2(s)} Uhr`, rolle: "stunde",
|
||
stufe: mitTermin.has(s) ? "dran" : (s < stundeJetzt ? "frei" : "offen") });
|
||
}
|
||
/* ---------- DIE ZAHL IN DER MITTE (17.09.2026) ----------
|
||
|
||
HIER STAND DIE UHRZEIT, und sie nannte sich "Tag geschafft":
|
||
`(aktuelle Stunde - 6) / 18`. Um 9 Uhr also 17 %, um 23 Uhr
|
||
94 % -- unabhaengig davon, ob jemand auch nur eine Sache getan
|
||
hatte. Das groesste Element der Startseite, ganz oben, und es
|
||
beantwortete die Frage nicht, die es stellte.
|
||
|
||
Gesehen auf dem Bildschirmfoto eines Modis: "0 % TAG
|
||
GESCHAFFT", waehrend sie ueberhaupt nichts offen hatte. Beides
|
||
war "richtig" und zusammen war es Unsinn.
|
||
|
||
JETZT ZAEHLT ES ARBEIT. Nenner ist, was heute auf dem Tisch
|
||
liegt: was heute faellig ist ODER laenger offen steht -- denn
|
||
ein Ring, der bei drei ueberfaelligen Sachen "nichts faellig"
|
||
meldet, waere derselbe Fehler noch einmal. Zaehler ist, was
|
||
HEUTE fertig geworden ist (`erledigt_am`), nicht was irgendwann
|
||
einmal abgehakt wurde.
|
||
|
||
Liegt nichts an, sind es 100 % und der Titel sagt es in Worten.
|
||
Ein voller Ring ohne Erklaerung waere wieder eine Zahl, bei der
|
||
man raten muss. */
|
||
const meineAufgaben = d.prepare(
|
||
`SELECT status, frist, erledigt_am FROM aufgaben
|
||
WHERE verantwortlich_id = ?`).all(zeigt.id);
|
||
const nochOffen = (a) => ["offen", "arbeit", "review"].includes(a.status);
|
||
const offenDran = meineAufgaben.filter(
|
||
(a) => nochOffen(a) && a.frist && String(a.frist) <= heute).length;
|
||
const heuteFertig = meineAufgaben.filter(
|
||
(a) => String(a.erledigt_am || "").slice(0, 10) === heute).length;
|
||
const dran = offenDran + heuteFertig;
|
||
/* ---- UND FUER DIE COMMUNITY ZAEHLT DER RING ETWAS ANDERES ----
|
||
(18.09.2026)
|
||
|
||
Er zaehlt AUFGABEN: was heute faellig war und was davon fertig
|
||
ist. Ein Mitglied der Community hat keine -- bei ihm stand
|
||
deshalb immer „100 % HEUTE NICHTS OFFEN", gross und in der
|
||
Mitte der Seite. Dieselbe tote Zahl wie „0 betreut" daneben, nur
|
||
auffaelliger.
|
||
|
||
Was ein Mitglied an dieser Stelle wissen will, ist etwas
|
||
anderes: Laeuft heute noch etwas? Also zaehlt der Ring bei ihm
|
||
die TERMINE des Tages und faerbt, was davon schon vorbei ist.
|
||
Bei null Terminen sagt er das in Worten, statt eine Null als
|
||
Prozentzahl auszugeben.
|
||
|
||
Woran erkannt: `freigabeBedingung` gibt nur fuer Leute von
|
||
aussen etwas zurueck -- dieselbe Frage wie bei der dritten Zahl
|
||
weiter unten, und wieder ohne Rollennamen. */
|
||
if (freigabeBedingung(zeigt, "e")) {
|
||
const vorbei = meine.filter(
|
||
(t) => Number(String(t.beginn).slice(11, 13)) < stundeJetzt).length;
|
||
return res.json({
|
||
art: "tag",
|
||
titel: meine.length
|
||
? (vorbei === meine.length ? "Termine heute – alle vorbei" : "Termine heute")
|
||
: "Heute steht nichts an",
|
||
/* `mitte` statt einer Prozentzahl: „2" sagt hier mehr als
|
||
„50 %", und bei null Terminen ist jede Prozentangabe eine
|
||
Behauptung ueber nichts. */
|
||
mitte: meine.length ? String(meine.length) : "–",
|
||
prozent: meine.length ? Math.round((vorbei / meine.length) * 100) : 0,
|
||
segmente,
|
||
zahlen: [
|
||
{ wert: meine.length, schild: "Termine heute" },
|
||
{ wert: meine.filter(
|
||
(t) => Number(String(t.beginn).slice(11, 13)) >= stundeJetzt).length,
|
||
schild: "kommt noch" },
|
||
{ wert: db().prepare(
|
||
`SELECT COUNT(*) AS n FROM eintraege e
|
||
WHERE e.bereich = 'wunsch' AND e.status = 'offen' AND ${
|
||
freigabeBedingung(zeigt, "e").wo}`)
|
||
.get(...freigabeBedingung(zeigt, "e").werte).n,
|
||
schild: "Wünsche offen" },
|
||
],
|
||
});
|
||
}
|
||
|
||
return res.json({
|
||
art: "tag",
|
||
titel: dran ? "Heute geschafft" : "Heute nichts offen",
|
||
prozent: dran ? Math.round((heuteFertig / dran) * 100) : 100,
|
||
segmente,
|
||
zahlen: [
|
||
/* "TERMINE HEUTE", NICHT NUR "HEUTE" (17.09.2026).
|
||
|
||
Hier stand blosses "heute" -- und gezaehlt werden Termine.
|
||
Solange der Ring darueber die Uhrzeit zeigte, fiel das nicht
|
||
auf. Seit er "Heute geschafft" heisst und AUFGABEN zaehlt,
|
||
stehen zwei verschiedene "heute" uebereinander: eins meint
|
||
Aufgaben, eins Termine. Wer das liest, haelt die kleinere
|
||
Zahl fuer einen Fehler in der groesseren. */
|
||
{ wert: meine.length, schild: "Termine heute" },
|
||
/* UND HIER WURDEN STUNDEN GEZAEHLT, NICHT TERMINE.
|
||
|
||
`mitTermin` ist eine Menge von STUNDEN -- fuer den Ring
|
||
richtig, denn er faerbt Stundensegmente. Als Zahl daneben
|
||
war es falsch: Drei Termine um 20 Uhr ergaben "1 kommt
|
||
noch". Niemand haette das gemeldet, weil eine zu kleine Zahl
|
||
nicht auffaellt; man verlaesst sich nur darauf und wundert
|
||
sich spaeter. Gezaehlt wird jetzt, was es ist. */
|
||
{ wert: meine.filter(
|
||
(t) => Number(String(t.beginn).slice(11, 13)) >= stundeJetzt).length,
|
||
schild: "kommt noch" },
|
||
/* "BETREUT" IST FUER EINEN MODI IMMER NULL (10.09.2026).
|
||
|
||
Er betreut keine Creator -- das ist die Arbeit der Scouts und
|
||
Manager. Auf seiner Startseite stand deshalb dauerhaft "0
|
||
betreut": eine Zahl, die nie etwas anderes sagen kann, und
|
||
damit schlimmer als keine. Wer sie sieht, sucht nach dem
|
||
Fehler.
|
||
|
||
Stattdessen zaehlt sie, wie viele im Modi-Team sind. Das ist
|
||
die Zahl, die an dieser Stelle etwas bedeutet -- und sie
|
||
bekommt nur zu sehen, wer ohnehin weiss, dass es die Runde
|
||
gibt. */
|
||
/* UND FUER DIE COMMUNITY GILT DASSELBE (18.09.2026).
|
||
|
||
Der Absatz darueber loest dieses Problem seit dem 10.09. fuer
|
||
einen Modi -- fuer ein Mitglied der Community blieb es
|
||
stehen. Es betreut erst recht niemanden; auf seiner
|
||
Startseite stand dauerhaft „0 betreut", aus genau demselben
|
||
Grund und mit genau derselben Wirkung: Wer eine Zahl sieht,
|
||
die sich nie aendert, sucht den Fehler bei sich.
|
||
|
||
Stattdessen die Zahl, bei der es MITREDEN kann: offene
|
||
Wuensche. Dort entscheidet die Community mit, was als
|
||
Naechstes passiert -- eine Zahl, die zum Hingehen einlaedt,
|
||
statt eine, die nichts sagt.
|
||
|
||
WORAN ERKANNT: `freigabeBedingung` gibt nur fuer Leute von
|
||
aussen eine Bedingung zurueck, sonst null. Damit steht die
|
||
Frage „ist das jemand aus der Community" schon beantwortet,
|
||
ohne dass hier ein Rollenname steht -- und die Bedingung
|
||
sorgt zugleich dafuer, dass nur gezaehlt wird, was diese
|
||
Person auch sehen darf. Zwei Fliegen, eine Zeile. */
|
||
(() => {
|
||
if (TEAM_DOGI_ROLLEN.has(zeigt.rolle)) {
|
||
return { wert: db().prepare(
|
||
`SELECT COUNT(*) AS n FROM personen WHERE rolle IN (${
|
||
[...TEAM_DOGI_ROLLEN].map((r) => `'${r}'`).join(", ")}) AND aktiv = 1`).get().n,
|
||
schild: "im Team" };
|
||
}
|
||
const bed = freigabeBedingung(zeigt, "e");
|
||
if (bed) {
|
||
const n = db().prepare(
|
||
`SELECT COUNT(*) AS n FROM eintraege e
|
||
WHERE e.bereich = 'wunsch' AND e.status = 'offen' AND ${bed.wo}`)
|
||
.get(...bed.werte).n;
|
||
return { wert: n, schild: "Wünsche offen" };
|
||
}
|
||
return { wert: betreuteIds(zeigt).length, schild: "betreut" };
|
||
})(),
|
||
],
|
||
});
|
||
} catch (fehler) {
|
||
console.error("[workspace] Zentrale:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|