DogFatherGitandClaude Opus 5
da49a227f1
Wunsch vom 01.09.2026: "verbessere die Aufgabenseite auch bei Manager,
Scout und Creator. Die Scouts und Manager sollen vielleicht ein bisschen
mehr Optionen haben, wie ihre zugeteilten Creator. Aber auch die Creator
sollen es besser und detaillierter sehen. ABER NUR DIE ROLLE DOGFATHER
SOLL WIRKLICH WEITERHIN ALLEINE ALLES SEHEN KOENNEN."
(Nachgereicht: "die Seite Aufgabe auch bei DogFather machen bitte.")
ZWEI FEHLER IN DEN RECHTEN, die beim Nachsehen herausfielen:
1. Ein MANAGER sah auf dem Aufgabenbrett GAR NICHTS. Die Regel kannte
nur admin, creator und scout; er fiel in den Zweig "unbekannte
Rolle sieht nichts". Ein leeres Brett sieht aus wie "nichts zu
tun", nicht wie ein Fehler -- deshalb ist das lange niemandem
aufgefallen.
2. In Kalender, Dateien, Bereichen und Content sah derselbe Manager
dagegen ALLES (istLeitung). Zwei entgegengesetzte Antworten auf
dieselbe Frage, in einem Programm.
Jetzt gilt ueberall dasselbe: NUR DogFather sieht alles. Manager und
Scout sehen ihre eigenen Sachen plus die Creator, die ihnen zugeteilt
sind. Dafuer arbeitet betreuteIds() jetzt auch fuer Manager -- die
Datenbank konnte das laengst (in `betreuung` steht eine beliebige
Person), nur diese eine Funktion hat alle ausser Scouts abgewiesen.
GEAENDERT WURDE NUR, WER WAS SIEHT. Was ein Manager DARF -- freigeben,
aendern, Personen verwalten -- haengt weiterhin an istLeitung und ist
unberuehrt. Ohne diese Trennung haette ein Wunsch nach weniger Sicht
stillschweigend die halben Rechte mitgenommen; die Pruefung haelt beides
ausdruecklich fest.
DIE SEITE SELBST bekommt drei Zeilen ueber dem Brett, und die
Reihenfolge ist die Aussage:
1. WAS BRENNT -- ein Satz beim Reinkommen. Ein Brett aus vier Spalten
beantwortet das nicht; man muesste alle vier durchsehen, um zu
wissen, dass nichts brennt.
2. AUSSCHNITTE -- "Nur meine", "Heute faellig", "Ueberfaellig", jeder
mit seiner Zahl am Knopf. Ein Filter, der sich erst nach dem Klick
als leer herausstellt, kostet zweimal Aufmerksamkeit. Sie filtern
das Brett, statt eine zweite Liste aufzumachen: Vier Spalten
nebeneinander sind der Wert dieser Seite.
3. DIE CREATOR -- fuer Betreuer und DogFather, je mit offener Anzahl
und einer Warnzahl fuer Ueberfaelliges. Bei DogFather heisst die
Reihe "Alle Creator", sonst "Deine Creator": "deine" waere bei ihm
eine falsche Auskunft.
Ein Creator bekommt weder "Nur meine" noch die Creator-Reihe -- bei ihm
ist ohnehin alles seins, und ein Filter mit einem einzigen Eintrag ist
ein Knopf, der nichts tut. Die Liste der Creator stammt aus den
Aufgaben selbst und nicht aus einer Personenabfrage: Dann stehen dort
genau die, die man ohnehin sehen darf, und niemals einer mehr.
NEBENBEI (Screen 1): In der Betreuer-Auswahl stand "Dogfather
(DogFather)" -- zweimal dasselbe Wort, nur anders geschrieben. Die
Klammer entfaellt jetzt, wenn sie dasselbe sagt wie der Name.
pruef-aufgabenbrett.mjs prueft die ABGRENZUNG zuerst und an konkreten
Aufgaben, deren Titel verraten, wem sie gehoeren -- eine huebschere
Filterleiste ist eine Annehmlichkeit, eine Rechteregel, die zu viel
zeigt, ist ein Schaden. Dazu eine Gegenprobe zur alten Regel (der
Manager sieht ueberhaupt etwas) und die ausdrueckliche Bestaetigung,
dass er weiterhin anlegen darf.
Ein Fehler steckte in der Pruefung selbst: Sie erwartete beim Creator
eine feste Zahl und haing damit von ihrer eigenen Reihenfolge ab -- der
Abschnitt davor legt eine weitere Aufgabe an. Sie vergleicht jetzt gegen
die Schnittstelle. Das ist ohnehin die bessere Frage: nicht "sind es
drei", sondern "verschluckt die Seite etwas".
Co-Authored-By: Claude Opus 5 <[email protected]>
486 lines
21 KiB
JavaScript
486 lines
21 KiB
JavaScript
/* =====================================================================
|
||
workspace-bereiche.js — LIVE, Content, Technik, Community und Schutz.
|
||
|
||
Diese fuenf Bereiche aus Phase 2 haben im Konzept dieselbe Grundform:
|
||
Eintraege zu einem Creator, mit Art, Datum, Titel, Text und Status.
|
||
Sie unterscheiden sich nur darin, WELCHE Arten es gibt und ob eine
|
||
Bewertung oder eine Dringlichkeit dazugehoert.
|
||
|
||
Deshalb ein gemeinsamer Unterbau statt fuenf fast gleicher Module:
|
||
eine Tabelle, eine Sichtbarkeitsregel, eine Pruefung. Ein Fehler laesst
|
||
sich damit an einer Stelle beheben statt an fuenf, und ein neuer
|
||
Bereich ist ein Eintrag in BEREICHE -- kein neues Modul.
|
||
|
||
Die Feldnamen und Arten stammen woertlich aus dem Deck (Seiten 7-12).
|
||
===================================================================== */
|
||
|
||
import express from "express";
|
||
import {
|
||
db, protokolliere, echteIp, sitzungLesen, betreutWo, darfCreator, betreuteIds, istLeitung, istDogFather,
|
||
} from "./workspace.js";
|
||
|
||
export const bereicheRouter = express.Router();
|
||
|
||
/* Die Bereiche und ihre Arten. Bewusst hier und nicht in der Datenbank:
|
||
Es sind Festlegungen aus dem Konzept, keine Nutzdaten. */
|
||
export const BEREICHE = {
|
||
live: {
|
||
name: "LIVE-Analyse",
|
||
arten: { vorbereitung: "Vorbereitung", mitschrift: "Während LIVE", auswertung: "Auswertung" },
|
||
bewertung: true, // Review-Score aus dem Konzept, Seite 7
|
||
dringlichkeit: false,
|
||
},
|
||
/* Content ist der einzige Bereich mit einer STRECKE statt einer Liste:
|
||
Die Arten sind hier Stufen, die ein Video der Reihe nach durchlaeuft.
|
||
Grundlage ist der Satz aus dem Konzept ("Hook bis Upload") und die
|
||
Recherche vom 31.08.2026: Eine Redaktionsplanung ist eine Strecke,
|
||
kein Kalender -- ein Kalender voller Termine verbirgt genau die drei
|
||
Stellen, an denen es klemmt.
|
||
|
||
Fuenf Stufen, nicht drei: Zwischen "Idee" und "Veroeffentlicht" lag
|
||
vorher alles, was den Unterschied macht. Und nicht mehr als fuenf --
|
||
jede weitere Spalte ist eine, die auf dem Handy nicht mehr passt. */
|
||
content: {
|
||
/* Umbenannt am 01.09.2026: "Planung" klang nach Terminen und
|
||
Tabellen. Was hier wirklich passiert, ist das Sammeln und
|
||
Weiterentwickeln von IDEEN -- der Kalender daneben plant. */
|
||
name: "Content-Ideen",
|
||
arten: {
|
||
idee: "Idee",
|
||
skript: "Hook & Skript",
|
||
gedreht: "Gedreht",
|
||
fertig: "Fertig & geplant",
|
||
veroeffentlicht: "Veröffentlicht",
|
||
},
|
||
bewertung: false,
|
||
dringlichkeit: false,
|
||
strecke: true, // hat eine Reihenfolge, nicht nur Kategorien
|
||
},
|
||
technik: {
|
||
name: "Technik",
|
||
arten: { setup: "Setup", problem: "Problem", loesung: "Lösung", anleitung: "Anleitung" },
|
||
bewertung: false,
|
||
dringlichkeit: true,
|
||
},
|
||
community: {
|
||
name: "Community",
|
||
arten: { moderation: "Moderation", aktion: "Aktion", konflikt: "Konflikt" },
|
||
bewertung: false,
|
||
dringlichkeit: true,
|
||
},
|
||
schutz: {
|
||
name: "Schutz & Regeln",
|
||
arten: { richtlinie: "Richtlinie", vorfall: "Vorfall", eskalation: "Eskalation", gelernt: "Gelernt" },
|
||
bewertung: false,
|
||
dringlichkeit: true,
|
||
},
|
||
};
|
||
|
||
const DRINGLICHKEITEN = ["hoch", "mittel", "niedrig"];
|
||
const STATUS = ["offen", "erledigt"];
|
||
const TITEL_MAX = 160;
|
||
const TEXT_MAX = 6000;
|
||
|
||
const jetzt = () => new Date().toISOString();
|
||
|
||
function angemeldet(req, res, next) {
|
||
const person = sitzungLesen(req);
|
||
if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
|
||
req.person = person;
|
||
next();
|
||
}
|
||
|
||
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();
|
||
}
|
||
|
||
bereicheRouter.use("/workspace/api/bereich", angemeldet);
|
||
|
||
/* ---------- Die Bereiche sind fuer Creator zum LESEN da ----------------
|
||
|
||
Wunsch Filipe, 31.08.2026: "die creator sollen da nur die sehen die wir
|
||
ihnen eintragen, also dogfather manager und scout."
|
||
|
||
Vorher durfte ein Creator hier selbst Eintraege anlegen, aendern und
|
||
die eigenen wieder loeschen. Das klingt harmlos, hebelt aber den Zweck
|
||
dieser Bereiche aus: Sie sind die Betreuungsakte -- LIVE-Auswertungen,
|
||
Technikbefunde, Konfliktverlaeufe, Schutzvorfaelle. Was dort steht,
|
||
muss der Stand der Betreuung sein und nicht das, was jemand ueber sich
|
||
selbst notiert hat. Ein Creator, der eine Auswertung umschreiben oder
|
||
eine unbequeme Notiz loeschen kann, macht die Akte wertlos.
|
||
|
||
Der Creator SIEHT weiterhin alles, was zu ihm gehoert -- vollstaendig,
|
||
nichts wird ihm vorenthalten. Er kann es nur nicht veraendern.
|
||
|
||
Bewusst 403 mit klarem Text und nicht 404: Der Bereich existiert fuer
|
||
ihn ja, er steht sogar davor. Ein 404 wuerde hier luegen. (Bei etwas,
|
||
das er gar nicht sehen darf, bleibt es weiterhin 404.)
|
||
|
||
Steht als EINE Schranke vor allen schreibenden Wegen. Die Alternative
|
||
-- in jeder der drei Stellen einzeln pruefen -- ist genau die Bauweise,
|
||
durch die am 31.08.2026 schon einmal ein Loch entstanden ist: Zwei von
|
||
drei Stellen waren abgesichert, die dritte vergessen. */
|
||
/* Ein Creator schreibt hier nicht -- MIT EINER AUSNAHME, die am
|
||
01.09.2026 dazukam: Was er SELBST angelegt hat, darf er auch
|
||
aendern und loeschen.
|
||
|
||
Die urspruengliche Regel ("hier tragen deine Betreuer ein") bleibt
|
||
damit unangetastet: Er kann weiterhin nichts an dem aendern, was
|
||
ueber ihn geschrieben wurde -- keine Bewertung, keine Notiz, keinen
|
||
Eintrag seines Managers.
|
||
|
||
Noetig wurde die Ausnahme durch die fertigen Vorlagen: Wenn ein
|
||
Creator sich eine Content-Idee uebernimmt, ist das SEINE Idee. Sie
|
||
danach nicht umbenennen zu duerfen waere absurd -- er haette einen
|
||
Eintrag erzeugt, den nur ein anderer bearbeiten kann.
|
||
|
||
Entscheidend ist erstellt_von, nicht creator_id: Ein Eintrag, den
|
||
sein Betreuer ueber ihn angelegt hat, traegt zwar seine creator_id,
|
||
gehoert ihm aber nicht. */
|
||
function nichtSchreibendFuerCreator(req, res, next) {
|
||
if (req.person?.rolle !== "creator") return next();
|
||
|
||
/* Neu anlegen bleibt gesperrt -- der Weg dafuer ist "Vorlage
|
||
uebernehmen", und der prueft eigene Regeln. */
|
||
/* NUR im Bereich content. Das ist der Bereich, in dem der Creator
|
||
selbst arbeitet -- seine Ideen, sein Material. LIVE, Technik,
|
||
Community und Schutz sind die BETREUUNGSAKTE: Dort schreiben die
|
||
Betreuer ueber ihn, und daran aendert er nichts, auch nicht an
|
||
etwas, das frueher einmal von ihm stammte. Das war am 31.08.2026
|
||
ausdruecklich so entschieden und bleibt so.
|
||
|
||
Ein erster Anlauf hatte die Ausnahme fuer ALLE Bereiche erlaubt --
|
||
die Pruefung pruef-bereiche-lesend hat das sofort gemeldet. */
|
||
const bereich = String(req.path).split("/")[4] || "";
|
||
if (bereich !== "content") {
|
||
return res.status(403).json({
|
||
fehler: "Hier tragen deine Betreuer ein. Du siehst alles, was zu dir gehört.",
|
||
});
|
||
}
|
||
|
||
const id = Number(String(req.path).split("/").pop());
|
||
if (Number.isInteger(id) && id > 0) {
|
||
try {
|
||
const e = db().prepare("SELECT erstellt_von FROM eintraege WHERE id = ?").get(id);
|
||
if (e && e.erstellt_von === req.person.id) return next();
|
||
} catch { /* faellt unten auf die Sperre zurueck */ }
|
||
}
|
||
|
||
return res.status(403).json({
|
||
fehler: "Das hat deine Betreuung eingetragen – ändern können sie es. "
|
||
+ "Was du selbst angelegt hast, kannst du bearbeiten.",
|
||
});
|
||
}
|
||
|
||
/* Express 4 -- dort ist der Platzhalter `*`, nicht `*name` wie in
|
||
Fassung 5. Mit der Fassung-5-Schreibweise haette der Pfad wortwoertlich
|
||
gepasst werden muessen und die Schranke waere NIE gegriffen: kein
|
||
Fehler, keine Warnung, nur eine Sperre, die stumm nichts tut. */
|
||
for (const weg of ["post", "patch", "delete", "put"]) {
|
||
bereicheRouter[weg]("/workspace/api/bereich/*", nichtSchreibendFuerCreator);
|
||
}
|
||
|
||
/* Scouts haben mit der Creator-Betreuung nichts zu tun -- sie sehen hier
|
||
nichts. Creator sehen ihren eigenen Bereich, das Management alles. */
|
||
export function sichtbar(person) {
|
||
/* NUR DogFather sieht alles (01.09.2026). Vorher stand hier
|
||
istLeitung() -- damit sah auch jeder Manager jeden Creator. Ein
|
||
Manager faellt jetzt in dieselbe Regel wie ein Scout: nur die
|
||
Creator, die ihm zugeteilt sind. Ausdruecklicher Wunsch:
|
||
"NUR DIE ROLLE DOGFATHER SOLL WIRKLICH ALLEINE ALLES SEHEN."
|
||
|
||
Geaendert wird ausschliesslich, wer was SIEHT. Was ein Manager
|
||
darf (freigeben, aendern, Personen verwalten), haengt weiterhin an
|
||
istLeitung und bleibt unveraendert -- sonst haette dieser eine
|
||
Wunsch stillschweigend seine halben Rechte mitgenommen. */
|
||
if (istDogFather(person)) return { wo: "1=1", werte: [] };
|
||
if (person.rolle === "creator") return { wo: "e.creator_id = ?", werte: [person.id] };
|
||
/* Ein Scout sieht die Bereiche der Creator, die er betreut -- und ohne
|
||
Zuteilung gar nichts (null heisst: Bereich existiert fuer dich nicht). */
|
||
return betreutWo(person, "e.creator_id");
|
||
}
|
||
|
||
const SPALTEN = `
|
||
e.id, e.bereich, e.art, e.titel, e.text, e.datum, e.bewertung,
|
||
e.dringlichkeit, e.status, e.creator_id, e.erstellt, e.erstellt_von, e.geaendert,
|
||
e.hook, e.format, e.saeule_id, e.geplant,
|
||
pc.name AS creator_name, pe.name AS erstellt_name,
|
||
(SELECT name FROM content_saeulen s WHERE s.id = e.saeule_id) AS saeule_name,
|
||
(SELECT slot FROM content_saeulen s WHERE s.id = e.saeule_id) AS saeule_slot`;
|
||
|
||
/* Passt die gewaehlte Saeule zu dem Creator, um den es geht? Gibt einen
|
||
Fehlertext zurueck oder null, wenn alles stimmt. */
|
||
function saeulePasst(saeuleId, creatorId) {
|
||
if (!saeuleId) return null;
|
||
const s = db().prepare("SELECT creator_id FROM content_saeulen WHERE id = ?").get(saeuleId);
|
||
if (!s) return "Diese Säule gibt es nicht.";
|
||
if (creatorId && s.creator_id !== creatorId) return "Diese Säule gehört zu einem anderen Creator.";
|
||
return null;
|
||
}
|
||
|
||
const VERBUND = `
|
||
FROM eintraege e
|
||
LEFT JOIN personen pc ON pc.id = e.creator_id
|
||
LEFT JOIN personen pe ON pe.id = e.erstellt_von`;
|
||
|
||
/* ---------- Lesen ------------------------------------------------------- */
|
||
|
||
bereicheRouter.get("/workspace/api/bereich/:bereich", (req, res) => {
|
||
try {
|
||
const bereich = String(req.params.bereich);
|
||
const einstellung = BEREICHE[bereich];
|
||
if (!einstellung) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
const regel = sichtbar(req.sicht || req.person);
|
||
if (!regel) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
const eintraege = db().prepare(`
|
||
SELECT ${SPALTEN} ${VERBUND}
|
||
WHERE ${regel.wo} AND e.bereich = ?
|
||
ORDER BY
|
||
CASE e.status WHEN 'offen' THEN 0 ELSE 1 END,
|
||
CASE e.dringlichkeit WHEN 'hoch' THEN 0 WHEN 'mittel' THEN 1 ELSE 2 END,
|
||
e.datum DESC, e.id DESC`).all(...regel.werte, bereich);
|
||
|
||
res.json({ bereich, einstellung, eintraege });
|
||
} catch (fehler) {
|
||
console.error("[workspace] Bereich lesen:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* ---------- Prüfen ------------------------------------------------------- */
|
||
|
||
function pruefe(bereich, körper, { neu }) {
|
||
const einstellung = BEREICHE[bereich];
|
||
const fehler = [];
|
||
const aus = {};
|
||
|
||
if (neu || körper.titel !== undefined) {
|
||
const t = String(körper.titel ?? "").trim();
|
||
if (t.length < 2) fehler.push("Titel fehlt.");
|
||
else if (t.length > TITEL_MAX) fehler.push("Titel ist zu lang.");
|
||
else aus.titel = t;
|
||
}
|
||
if (neu || körper.art !== undefined) {
|
||
const a = String(körper.art ?? "");
|
||
if (!Object.hasOwn(einstellung.arten, a)) fehler.push("Unbekannte Art.");
|
||
else aus.art = a;
|
||
}
|
||
if (körper.text !== undefined) {
|
||
const t = String(körper.text ?? "").trim();
|
||
if (t.length > TEXT_MAX) fehler.push("Text ist zu lang.");
|
||
else aus.text = t || null;
|
||
}
|
||
if (neu || körper.datum !== undefined) {
|
||
const d = String(körper.datum ?? "").trim();
|
||
if (!d) aus.datum = jetzt().slice(0, 10);
|
||
else if (!/^\d{4}-\d{2}-\d{2}$/.test(d) || Number.isNaN(Date.parse(d))) {
|
||
fehler.push("Datum ist ungültig.");
|
||
} else aus.datum = d;
|
||
}
|
||
if (körper.status !== undefined) {
|
||
if (!STATUS.includes(körper.status)) fehler.push("Unbekannter Status.");
|
||
else aus.status = körper.status;
|
||
}
|
||
/* Bewertung und Dringlichkeit gibt es nur dort, wo der Bereich sie
|
||
vorsieht -- sonst werden sie stillschweigend verworfen. */
|
||
if (einstellung.bewertung && körper.bewertung !== undefined) {
|
||
if (körper.bewertung === null || körper.bewertung === "") aus.bewertung = null;
|
||
else {
|
||
const b = Number(körper.bewertung);
|
||
if (!Number.isInteger(b) || b < 1 || b > 5) fehler.push("Bewertung muss 1 bis 5 sein.");
|
||
else aus.bewertung = b;
|
||
}
|
||
}
|
||
if (einstellung.dringlichkeit && körper.dringlichkeit !== undefined) {
|
||
if (!DRINGLICHKEITEN.includes(körper.dringlichkeit)) fehler.push("Unbekannte Dringlichkeit.");
|
||
else aus.dringlichkeit = körper.dringlichkeit;
|
||
}
|
||
|
||
/* Die vier Content-Felder gibt es nur in der Content-Planung. In jedem
|
||
anderen Bereich werden sie stillschweigend verworfen -- wie Bewertung
|
||
und Dringlichkeit auch. Sonst stuende irgendwann ein Aufhaenger an
|
||
einem Schutzvorfall. */
|
||
if (bereich === "content") {
|
||
if (körper.hook !== undefined) {
|
||
const h = String(körper.hook ?? "").trim();
|
||
if (h.length > 300) fehler.push("Der Hook ist zu lang.");
|
||
else aus.hook = h || null;
|
||
}
|
||
if (körper.format !== undefined) {
|
||
const f = String(körper.format ?? "").trim();
|
||
if (f.length > 60) fehler.push("Das Format ist zu lang.");
|
||
else aus.format = f || null;
|
||
}
|
||
if (körper.saeule_id !== undefined) {
|
||
if (körper.saeule_id === null || körper.saeule_id === "") aus.saeule_id = null;
|
||
else {
|
||
const s = Number(körper.saeule_id);
|
||
if (!Number.isInteger(s) || s < 1) fehler.push("Unbekannte Säule.");
|
||
else aus.saeule_id = s;
|
||
}
|
||
}
|
||
if (körper.geplant !== undefined) {
|
||
const g = String(körper.geplant ?? "").trim();
|
||
if (!g) aus.geplant = null;
|
||
/* Datum ODER Datum mit Uhrzeit -- wer nur den Tag weiss, soll nicht
|
||
zu einer erfundenen Uhrzeit gezwungen werden. */
|
||
else if (!/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2})?$/.test(g) || Number.isNaN(Date.parse(g))) {
|
||
fehler.push("Der geplante Zeitpunkt ist ungültig.");
|
||
} else aus.geplant = g;
|
||
}
|
||
}
|
||
if (körper.creator_id !== undefined) {
|
||
const w = körper.creator_id;
|
||
if (w === null || w === "") aus.creator_id = null;
|
||
else {
|
||
const z = Number(w);
|
||
if (!Number.isInteger(z) || z < 1) fehler.push("Ungültige Zuordnung.");
|
||
else aus.creator_id = z;
|
||
}
|
||
}
|
||
return { aus, fehler };
|
||
}
|
||
|
||
/* ---------- Anlegen ------------------------------------------------------ */
|
||
|
||
bereicheRouter.post("/workspace/api/bereich/:bereich", gleicheHerkunft, (req, res) => {
|
||
try {
|
||
const bereich = String(req.params.bereich);
|
||
if (!BEREICHE[bereich]) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
const regel = sichtbar(req.person);
|
||
if (!regel) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
const { aus, fehler } = pruefe(bereich, req.body || {}, { neu: true });
|
||
if (fehler.length) return res.status(400).json({ fehler: fehler.join(" ") });
|
||
|
||
/* Ein Creator schreibt immer in den eigenen Bereich, egal was im
|
||
Aufruf steht. Ein Scout in den eines Creators, den er betreut --
|
||
niemals in einen fremden und niemals "auf sich selbst", denn ein
|
||
Scout hat gar keinen eigenen Betreuungsbereich. */
|
||
if (req.person.rolle === "creator") {
|
||
aus.creator_id = req.person.id;
|
||
} else if (req.person.rolle === "scout") {
|
||
const w = Number(aus.creator_id);
|
||
if (!darfCreator(req.person, w)) {
|
||
const erster = betreuteIds(req.person)[0];
|
||
if (!erster) return res.status(403).json({ fehler: "Dir ist kein Creator zugeteilt." });
|
||
aus.creator_id = erster;
|
||
}
|
||
}
|
||
if (aus.creator_id
|
||
&& !db().prepare("SELECT 1 FROM personen WHERE id = ? AND rolle = 'creator'").get(aus.creator_id)) {
|
||
return res.status(400).json({ fehler: "Zugeordneter Creator existiert nicht." });
|
||
}
|
||
|
||
/* Eine Saeule gehoert immer GENAU EINEM Creator. Ohne diese Pruefung
|
||
koennte man ein Video an die Saeule eines fremden Creators haengen
|
||
-- und darueber in der Balance-Auswertung Namen sehen, die einen
|
||
nichts angehen. Die Sichtbarkeitsregel oben schuetzt die Eintraege,
|
||
nicht die Verweise zwischen ihnen. */
|
||
const saeuleFehler = saeulePasst(aus.saeule_id, aus.creator_id);
|
||
if (saeuleFehler) return res.status(400).json({ fehler: saeuleFehler });
|
||
|
||
const { lastInsertRowid } = db().prepare(`
|
||
INSERT INTO eintraege
|
||
(bereich, art, titel, text, datum, bewertung, dringlichkeit, status,
|
||
creator_id, erstellt, erstellt_von, hook, format, saeule_id, geplant)
|
||
VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(
|
||
bereich, aus.art, aus.titel, aus.text ?? null, aus.datum,
|
||
aus.bewertung ?? null, aus.dringlichkeit ?? "mittel", aus.status ?? "offen",
|
||
aus.creator_id ?? null, jetzt(), req.person.id,
|
||
aus.hook ?? null, aus.format ?? null, aus.saeule_id ?? null, aus.geplant ?? null);
|
||
|
||
protokolliere("eintrag_angelegt", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `${bereich} #${lastInsertRowid} ${aus.titel}`.slice(0, 120),
|
||
});
|
||
res.status(201).json({ id: Number(lastInsertRowid) });
|
||
} catch (fehler) {
|
||
console.error("[workspace] Eintrag anlegen:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* ---------- Ändern und Löschen ------------------------------------------- */
|
||
|
||
function holen(req, id) {
|
||
const regel = sichtbar(req.person);
|
||
if (!regel) return null;
|
||
return db().prepare(`SELECT e.* ${VERBUND} WHERE ${regel.wo} AND e.id = ?`)
|
||
.get(...regel.werte, id);
|
||
}
|
||
|
||
bereicheRouter.patch("/workspace/api/bereich/:bereich/:id", gleicheHerkunft, (req, res) => {
|
||
try {
|
||
const bereich = String(req.params.bereich);
|
||
const id = Number(req.params.id);
|
||
if (!BEREICHE[bereich] || !Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
|
||
|
||
const eintrag = holen(req, id);
|
||
if (!eintrag || eintrag.bereich !== bereich) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
const { aus, fehler } = pruefe(bereich, req.body || {}, { neu: false });
|
||
if (fehler.length) return res.status(400).json({ fehler: fehler.join(" ") });
|
||
if (!istLeitung(req.person)) delete aus.creator_id;
|
||
|
||
/* Beim Aendern gilt dieselbe Regel -- sonst waere die Pruefung beim
|
||
Anlegen wertlos: Man legt ohne Saeule an und haengt sie danach an. */
|
||
if (aus.saeule_id !== undefined) {
|
||
const zuWem = aus.creator_id !== undefined ? aus.creator_id : eintrag.creator_id;
|
||
const saeuleFehler = saeulePasst(aus.saeule_id, zuWem);
|
||
if (saeuleFehler) return res.status(400).json({ fehler: saeuleFehler });
|
||
}
|
||
|
||
const felder = Object.keys(aus);
|
||
if (!felder.length) return res.status(400).json({ fehler: "nichts_zu_aendern" });
|
||
|
||
db().prepare(
|
||
`UPDATE eintraege SET ${felder.map((f) => `${f} = ?`).join(", ")}, geaendert = ? WHERE id = ?`
|
||
).run(...felder.map((f) => aus[f]), jetzt(), id);
|
||
|
||
protokolliere("eintrag_geaendert", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `${bereich} #${id} ${felder.join(",")}`.slice(0, 120),
|
||
});
|
||
res.json({ ok: true });
|
||
} catch (fehler) {
|
||
console.error("[workspace] Eintrag ändern:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
bereicheRouter.delete("/workspace/api/bereich/:bereich/:id", gleicheHerkunft, (req, res) => {
|
||
try {
|
||
const bereich = String(req.params.bereich);
|
||
const id = Number(req.params.id);
|
||
if (!BEREICHE[bereich] || !Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
|
||
|
||
const eintrag = holen(req, id);
|
||
if (!eintrag || eintrag.bereich !== bereich) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
/* Löschen darf das Management und wer den Eintrag selbst geschrieben
|
||
hat -- sonst könnte ein Creator eine Notiz des Managements über
|
||
seinen eigenen Bereich verschwinden lassen. */
|
||
if (!istLeitung(req.person) && eintrag.erstellt_von !== req.person.id) {
|
||
return res.status(403).json({ fehler: "nicht_erlaubt" });
|
||
}
|
||
|
||
db().prepare("DELETE FROM eintraege WHERE id = ?").run(id);
|
||
protokolliere("eintrag_geloescht", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `${bereich} #${id} ${eintrag.titel}`.slice(0, 120),
|
||
});
|
||
res.json({ ok: true });
|
||
} catch (fehler) {
|
||
console.error("[workspace] Eintrag löschen:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|