DogFatherGit/dogfather-universe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7a6749630cc77780d5e24ba16f8bae74460268ca
dogfather-universe/server/workspace-chat.js
T
DogFatherGitandClaude Opus 5 7a6749630c Das Rudel meint den ganzen Raum -- und die Kachelfarbe wird ein Ring 
Zwei Auftraege vom 23.09.2026.

SCREEN 1: "da steht links immer noch der treff anstatt das rudel"

Und er hatte recht, auf eine Art, die niemand sehen konnte:
TREFF_NAME stand schon seit der Umbenennung auf "Das Rudel". Nur
setzt treffRaumId() den Namen ausschliesslich BEIM ANLEGEN -- der
Raum existierte laengst, also blieb die Zeile in der Datenbank auf
"Der Treff" stehen. Im Code das eine, auf dem Bildschirm das andere.

Dieselbe Falle stand direkt nebenan schon beschrieben ("drei Stellen,
von denen die dritte vergessen wird") -- die Vorsorge galt aber nur
fuer die Teilnehmer, nicht fuer den Namen. Eine halbe Selbstheilung
heilt die andere Haelfte nicht. Jetzt gleicht treffAngleichen() auch
den Namen ab; eine kuenftige Umbenennung ist wieder eine Zeile.
(IS NOT statt !=: Bei NULL ergaebe != in SQLite NULL, und die Zeile
bliebe unveraendert liegen.)

"und wenn wir da im chat @rudel machen will ich dass jeder in dem
chat markiert wird. nicht nur team ... und sehr wichtig ich rede nur
von dem chat wo die ganze community auch drin ist."

Bis heute erreichte der Ruf ueberall nur Team Dogi. Die Begruendung
stand im Code und war nicht falsch -- im Rudel-Raum sitzt die
Community. Genau das will Filipe jetzt, und zwar nur dort:

  im Rudel-Raum   -> alle, die drin sind
  ueberall sonst  -> Team Dogi, unveraendert

Was die alte Sorge entschaerft: RUFEN darf weiterhin nur Team Dogi --
kein Zuschauer kann alle wecken. Und die Nachtruhe gilt dort ohnehin.

darf_rudel folgt derselben Frage. Sonst entstuende ein stiller
Widerspruch: Ein Modi mit neun Zuschauern und ohne zweites
Teammitglied traefe mit @rudel neun Leute -- der Vorschlag beim
Tippen waere aber ausgeblendet. Die Funktion gaebe es, und niemand
faende sie.

Das Schild sagt jetzt die Wahrheit: "alle in diesem Chat" statt
"alle im Team". Stuende dort weiter das alte, waere es im Rudel-Raum
gelogen -- und zwar nach unten, also in die Richtung, in der man
leichtfertig drueckt.

Gegenprobe in pruef-erwaehnung: In der Testgruppe sitzen DogFather
und zwei Scouts; ein @rudel dort ruft NIEMANDEN. Waere die Regel
versehentlich im ganzen Haus aktiv, waeren die Scouts markiert.
"sonst nichts anfassen" ist damit gemessen, nicht versprochen.

SCREEN 2: "so eine art diagramm, wo man mit einem kreis herum gehen
kann und die farbe ganz genau selber auswaehlen kann"

Der Haken daran ist nicht die Optik. Die zwoelf Kacheln waren
GERECHNET, damit niemand sich unlesbar machen kann -- alle auf
derselben Leuchtdichte. Ein Farbkreis, der einfach den Farbton dreht,
wirft das weg: Ein gesaettigtes Gelb ist um ein Vielfaches heller als
ein gesaettigtes Blau, und helle Schrift ist darauf nicht mehr zu
lesen.

Der Ring ist deshalb KEINE neue Rechnung, sondern dieselbe in 360
Schritten statt in zwoelf. tools/chat-kacheln-rechnen.mjs --kreis
schreibt server/chat-kreis.js; buntest() und die Kontrastpruefung
darin gelten unveraendert. Ergebnis: ein Ring gleicher Helligkeit --
kein blendendes Gelb, kein abgesoffenes Blau. Das sieht ruhiger aus
als der uebliche Farbkreis, und genau das ist der Punkt.

Der Browser rechnet nichts. Er bekommt die 360 fertigen Farben und
legt sie in dieselbe Tabelle wie die Kacheln -- ab da ist "ton-214"
ein Schluessel wie "veilchen", und jede Stelle, die eine Farbe
nachschlaegt, funktioniert unveraendert.

Welche Kacheln neben dem Ring bleiben, wird ABGELEITET statt
aufgezaehlt: Grau hat keinen Farbton, Babyblau ist die eine helle mit
eigener Schrift. Nachgemessen liegen die elf bunten zwischen 0,0 und
2,4 von ihrer Ringfarbe entfernt, Grau bei 75,4 und Babyblau bei
192,9 -- zwischen 2,4 und 75 ist so viel Luft, dass die Schwelle
nicht knapp ist.

Gespeichert wird erst beim Loslassen. Wer einmal um den Ring fuehrt,
erzeugte sonst dreihundert Anfragen.

Gemessen (pruef-chat-neu, jetzt 32 Pruefungen, als Modi auf crew. mit
dem Finger): 265 px gross, aus 361 Farben gemalt, touch-action none
(sonst schiebt das Handy die Seite weg statt zu drehen), Drehen auf
drei Uhr ergibt genau Winkel 90, die Mitte zeigt exakt #675102,
vorgelesen als "Goldbraun, 90 Grad", in der Datenbank steht ton-90,
Pfeiltaste dreht ein Grad weiter. Und das eigentliche Versprechen:
alle 360 Toene tragen die Schrift der Blase, knappster Faktor 1,000.

Dabei zwei eigene Fehler, beide aufgeschrieben: Der erste Anlauf
wartete 30 Sekunden auf den Farbknopf -- am Handy weicht die Spalte
mit den Gespraechen zur Seite, sobald ein Chat offen ist. "Ist im
HTML" und "ist erreichbar" sind zwei Aussagen. Und die Schriftfarben
wurden an der falschen Klasse gemessen, was einen roten Haken an
einer heilen Stelle ergab.

Ausserdem: Das native confirm() beim Herausnehmen eines GIFs ist
weg -- meine eigene Abkuerzung vom Morgen. Gemeldet hat es
pruef-nachfrage, allerdings erst, nachdem der verlorene Backslash in
derselben Datei repariert war.

Zahlen: pruef-erwaehnung 122 (vorher 119), pruef-chat-neu 32
(vorher 19), pruef-nachfrage 46 bestanden.

Co-Authored-By: Claude Opus 5 <[email protected]>
2026-09-23 14:30:02 +02:00

3425 lines
157 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* =====================================================================
workspace-chat.js — Gespräche zwischen den Leuten im Workspace.
Wunsch Filipe, 06.09.2026: *"eine kategorie chat, wo die creator mit
ihren manager nachrichten austauschen können, wie erinnerungen,
fragen und noch vieles mehr, wo jeder immer mit denen schreiben kann
wie verbindung auch läuft, und jeder kann dann eine nachricht
reinschreiben, die andere person bekommt eine benachrichtigung und
kann dann antworten."*
Auf Nachfrage entschieden: Zweier-Gespräche UND Gruppen; Manager und
Scouts dürfen sich auch ohne gemeinsamen Creator schreiben.
---------------------------------------------------------------------
DIE DREI REGELN, die alles andere tragen
1. WER MIT WEM steht an EINER Stelle: schreibbareIds() in
workspace.js. Nicht hier, nicht in der Oberfläche. Jede Route
fragt dieselbe Funktion -- eine zweite Regel wäre die sichere
Zusage, dass beide irgendwann auseinanderlaufen.
2. WER IM RAUM IST, entscheidet über den Verlauf. Die Mitgliedschaft
wird bei JEDEM Zugriff geprüft, nicht nur beim Öffnen. Sonst
könnte man eine Raumnummer erraten und mitlesen.
3. EINE NACHRICHT WIRD NICHT GELÖSCHT, sondern geleert. Ein Loch im
Verlauf wirft mehr Fragen auf als der Hinweis, dass jemand etwas
zurückgenommen hat -- und in einem Gespräch, in dem Absprachen
stehen, ist Nachvollziehbarkeit mehr wert als ein sauberer Schnitt.
---------------------------------------------------------------------
WAS BEWUSST FEHLT
Kein Bearbeiten einer abgeschickten Nachricht. Wer eine Absprache
nachträglich umschreiben kann, macht den Verlauf wertlos --
zurücknehmen und neu schreiben ist ehrlicher und hinterlässt eine
Spur. (Zurücknehmen selbst ist da, siehe weg_am.)
===================================================================== */
import express from "express";
import { randomBytes, createHash } from "node:crypto";
import { join, extname, basename } from "node:path";
import { mkdirSync, writeFileSync, createReadStream, statSync, unlinkSync,
copyFileSync } from "node:fs";
import {
db, protokolliere, echteIp, sitzungLesen, istDogFather,
schreibbareIds, darfSchreibenMit, ROLLEN_SORTIERUNG, DATEN_ORDNER,
fuehrtTeamDogi, MODI_KATEGORIEN, ROLLEN_GRUPPE, TEAM_DOGI_ROLLEN,
istTeamDogi,
} from "./workspace.js";
import { erwaehnteIds, rudelGerufen, RUDEL_WORT } from "./chat-erwaehnung.js";
import { KREIS, winkelAus } from "./chat-kreis.js";
import { KATALOG, ERLAUBT, VORSCHLAG, FAVORITEN_MAX } from "./workspace-reaktionen.js";
/* Der Treff-Chat: eigener Raum, eigene Nachtruhe, keine Anrufe.
Eigene Datei, weil er eigene Regeln hat -- und weil diese hier
mit 2000 Zeilen schon gross genug ist. */
import {
TREFF_KATEGORIE, TREFF_NAME, istTreffRaum, treffAngleichen,
gehoertInTreff, nachtruheStand, istNachtruhe, darfTelefonieren,
} from "./workspace-treffchat.js";
export const chatRouter = express.Router();
const TEXT_MAX = 4000;
const NAME_MAX = 80;
/* ---------- Anhänge ------------------------------------------------------
Derselbe Weg wie in der Dateiablage, und aus denselben Gründen:
Der Browser schickt die Datei roh im Rumpf, der Name steht im Kopf.
express.raw() nimmt das entgegen -- multipart/form-data von Hand zu
zerlegen wäre an dieser Stelle die gefährlichere Übung.
12 MB und nicht 25 wie in der Ablage: Ein Chat sammelt viele kleine
Dateien, kein Archiv grosser. Ein Handyfoto liegt bei 2 bis 5 MB,
ein PDF mit Bildern selten über 10. */
const ANHANG_MAX = 12 * 1024 * 1024;
const ANHANG_ORDNER = join(DATEN_ORDNER, "chat-anhaenge");
const ANHANG_NAME_MAX = 200;
/* EIGENE GRENZE FUER TON (23.09.2026).
Zwoelf Megabyte sind fuer ein Foto richtig und fuer eine
Sprachnachricht sinnlos: Bei Opus mit 32 kbit/s waeren das rund
fuenfzig Minuten am Stueck. Vier Megabyte reichen fuer etwa zwanzig
Minuten -- mehr als genug fuer „hoer mal kurz" und immer noch eine
echte Schranke.
SIE WIRD NACH DEM EMPFANG GEPRUEFT, und das ist kein Versehen: Ob
etwas Ton ist, sagen erst die ersten Bytes. Vorher weiss niemand,
welche Grenze gilt. Gespeichert wird trotzdem nichts -- abgelehnt
wird, bevor die Datei die Platte sieht.
DIE LAENGE IN MINUTEN STEHT IM BROWSER (chat.js) und stoppt die
Aufnahme von selbst. Hier zaehlen Bytes, weil nur die hier messbar
sind -- eine Dauer waere eine Behauptung des Absenders. */
const TON_MAX = 4 * 1024 * 1024;
/* DIE GIF-KISTE DES RUDELS (23.09.2026) -- eigener Ordner, und das ist
kein Ordnungssinn.
Eine Nachricht loeschen entfernt ihre Datei von der Platte (siehe
das Zuruecknehmen weiter unten). Laege ein Kachel-GIF in demselben
Ordner und mehrere Nachrichten zeigten darauf, wuerde das Loeschen
EINER Nachricht das GIF fuer alle anderen mitnehmen -- und in drei
Gespraechen stuende ab da ein kaputtes Bild. Deshalb liegt die
Kiste fuer sich, und beim Verschicken wird KOPIERT. Ein GIF ist
klein genug, dass die Kopie nichts kostet; ein kaputtes Bild in
einem fremden Gespraech ist teuer.
Der Ordner steht ueber join(DATEN_ORDNER, ...) -- genau dieses
Muster liest tools/wiederherstellung-proben.mjs aus, um zu pruefen,
ob die Sicherung ihn mitnimmt. Eine gepflegte Liste waere die, die
beim naechsten Ordner vergessen wird. */
const GIF_ORDNER = join(DATEN_ORDNER, "chat-gifs");
/* ACHT MEGABYTE. Ein GIF darueber ist kein GIF mehr, sondern ein
Video mit einem falschen Hut auf -- und es laeuft in der Auswahl
dauerhaft im Kreis, waehrend das Handy heiss wird. */
const GIF_MAX = 8 * 1024 * 1024;
/** Alle GIFs der Kiste, das Neueste zuerst.
* An einer Stelle, weil drei danach fragen: die Liste, das
* Hineinlegen (es gibt die frische zurueck) und das Herausnehmen. */
function gifListe() {
return db().prepare(`SELECT g.id, g.name, g.groesse, g.breite, g.hoehe,
g.erstellt, p.name AS von
FROM chat_gifs g LEFT JOIN personen p ON p.id = g.von_id
ORDER BY g.id DESC LIMIT 200`).all()
.map((g) => ({
id: g.id, name: g.name, groesse: g.groesse,
breite: g.breite || 0, hoehe: g.hoehe || 0,
von: g.von || null, erstellt: g.erstellt,
/* Als fertige ADRESSE, nicht als Dateiname -- sonst setzt jede
Stelle im Browser denselben Pfad zusammen, und eine davon
setzt ihn irgendwann anders. Dieselbe Entscheidung wie beim
Anhang. */
weg: `/workspace/api/chat/gifs/${g.id}/bild`,
}));
}
const jetzt = () => new Date().toISOString();
/* ---------- Schranke ---------------------------------------------------- */
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();
}
chatRouter.use("/workspace/api/chat", angemeldet);
/* =====================================================================
Bausteine
===================================================================== */
/** Ist die Person in diesem Raum -- und nicht ausgetreten?
*
* DIE WICHTIGSTE FUNKTION DER DATEI. Jede Route, die einen Verlauf
* liest oder etwas hineinschreibt, geht hier durch. Wer sie umgeht,
* macht aus einer Raumnummer einen Schlüssel. */
/* SIE NIMMT DIE PERSON, NICHT IHRE NUMMER (10.09.2026, Kapitel 7.2).
*
* Seit es Kanaele gibt, haengt die Antwort auch an der ROLLE. Eine
* Nummer allein koennte die Frage nicht mehr beantworten -- und haette
* sie trotzdem beantwortet, mit "nein", ohne ein Wort dazu. Deshalb
* wirft ein Aufruf mit einer Nummer einen Fehler statt weiterzulaufen:
* Er faellt beim ersten Durchgang auf, nicht im Betrieb. */
function istDrin(raumId, person) {
if (!person || typeof person !== "object") {
throw new TypeError("istDrin() braucht die Person, nicht ihre Nummer.");
}
try {
const z = db().prepare(
"SELECT 1 FROM chat_teilnehmer WHERE raum_id = ? AND person_id = ? AND raus_am IS NULL")
.get(raumId, person.id);
if (z) return true;
/* KANAELE STEHEN DER TEAMFUEHRUNG OFFEN -- Kapitel 7.2: "Owner/
rechte Hand haben Zugriff auf alle Kanaele."
DIE AUSNAHME STEHT HIER und nicht in den sieben Routen darueber.
Dort waere sie in sechs davon gelandet und in der siebten nicht,
und die siebte waere die gewesen, die keiner ausprobiert.
SIE GILT NUR FUER 'kanal'. Zweier-Gespraeche bleiben zu, auch
fuer DogFather -- Kapitel 7.2 sagt das ausdruecklich: "Private
1:1-Chats: ausschliesslich fuer die beteiligten Personen
sichtbar - kein Zugriff durch Owner/rechte Hand." Und Gruppen
bleiben ebenfalls zu: Wer eine Gruppe aufmacht, hat sich fuer
einen geschlossenen Kreis entschieden, und den nachtraeglich
still zu oeffnen waere das Gegenteil dessen, was er getan hat.
Ein Kanal ist etwas anderes: Er gehoert dem Team, nicht den
Anwesenden. */
if (!fuehrtTeamDogi(person)) return false;
const raum = db().prepare("SELECT art FROM chat_raeume WHERE id = ?").get(raumId);
return raum?.art === "kanal";
} catch { return false; }
}
/** Alle (noch aktiven) Teilnehmer eines Raums. */
/* Das Profilbild gehoert dazu (07.09.2026). Ohne es zeigt die
Gespraechsliste Initialen, obwohl ein Bild hochgeladen ist -- der
Fehler liegt dann nicht in der Anzeige, sondern in der Abfrage. Die
fertige ADRESSE wird danach gebaut, nicht der Dateiname
weitergereicht: Sonst setzt jede Stelle im Browser denselben Pfad
zusammen.
UND DER KOMMENTAR STEHT AUSSERHALB DER ABFRAGE. Beim ersten Anlauf
stand er darin -- mit dem Wort `bild` in schraegen Anfuehrungszeichen.
Die beenden in JavaScript eine Vorlagenzeichenkette; die halbe SQL
wurde damit zu Programmtext, und die Datei liess sich nicht mehr
lesen. Ein Kommentar, der die Zeichenkette schliesst, in der er
steht. */
/** Der Weg zum Profilbild dieser Person -- oder null.
*
* ALS EIGENE FUNKTION, weil die Zeile
* `bild ? "/workspace/api/steckbrief/bild/" + bild : null`
* sonst an drei Stellen steht. Die dritte Abschrift ist die, die
* den Pfad falsch schreibt, und ein kaputter Bildpfad sieht aus wie
* "die Person hat halt kein Bild". */
function bildWegFuer(personId) {
try {
const z = db().prepare("SELECT bild FROM personen WHERE id = ?").get(personId);
return z?.bild ? `/workspace/api/steckbrief/bild/${z.bild}` : null;
} catch { return null; }
}
/* =====================================================================
JEDER ACCOUNT SEINE EIGENE KACHEL (20.09.2026)
Filipe: „jeder account soll seine kachel personalisieren koennen."
---------------------------------------------------------------------
EINE AUSWAHL, KEIN FARBWAEHLER
Ein freier Farbwaehler klingt grosszuegiger und ist die schlechtere
Loesung: Mit ihm laesst sich Schwarz auf Schwarz einstellen, oder
Neongelb, das jedem anderen im Gespraech in die Augen sticht. Die
Kachel gehoert einem selbst, GESEHEN wird sie von allen anderen --
deshalb ist sie kein Platz fuer etwas, das man nicht abschalten kann.
Die zwoelf Toene hier liegen alle auf DERSELBEN LEUCHTDICHTE. Sie
unterscheiden sich im Farbton und in sonst nichts. Damit ist der
Kontrast zur Schrift bei jedem gleich -- er muss nicht bei jedem
einzeln geprueft werden, und niemand kann sich unlesbar machen.
Augenschonend ist hier keine Geschmacksfrage: Ein Chat ist die
Seite, auf der am laengsten gelesen wird.
KEINE der zwoelf ist hell. Das ist Absicht und nicht Sparsamkeit --
die Schrift ist hell, und eine helle Kachel waere fuer die Person,
die sie waehlt, huebsch und fuer alle anderen unlesbar.
---------------------------------------------------------------------
DIESE LISTE IST GERECHNET, NICHT GEWAEHLT (22.09.2026)
Filipe: „ich will dass die farben viel klarer und stärker sind ...
die kachel von den texten von den leuten im chat soll auch klarer
und stärker sein bitte."
Bis heute lagen alle zwoelf bei einer Buntheit zwischen 0,002 und
0,048 -- auf dem Bildschirm zwoelf Grautoene mit einem Hauch Farbe.
Das lag nicht an fehlendem Mut, sondern an der Fusszeile der Blase:
Sie stand auf der leisen Hausschrift, und gegen die darf die Flaeche
kaum Farbe haben.
Geaendert wurde deshalb ZUERST die Schrift der Blase (--blase-text /
--blase-leise in chat.css, beide heller als die der Seite) und DANN
die Flaeche. Andersherum waere es der Fehler vom selben Vormittag
gewesen, als 27 von 31 Startkacheln unlesbar wurden.
NICHT VON HAND AENDERN. Die Werte kommen aus
`tools/chat-kacheln-rechnen.mjs`; es liest die beiden Schriftfarben
aus dem CSS und rechnet daraus die hellste Flaeche aus, die beide
noch tragen (7:1 fuer den Nachrichtentext, 4,8:1 fuer die
Fusszeile). Wer hier eine Farbe eintippt, umgeht genau die Rechnung,
die die Lesbarkeit garantiert. Richtig ist:
node tools/chat-kacheln-rechnen.mjs --schreiben
node server/pruef-chatkachel.mjs
DIE SCHLUESSEL LINKS STEHEN IN DER DATENBANK. Wer einen umbenennt,
setzt die Wahl der betroffenen Person still auf „Standard" zurueck.
Vor diesem Umbau nachgesehen: gewaehlt waren `veilchen`, `ziegel`
und `moos` -- alle drei stehen weiter unten und haben ihren
Farbbereich behalten.
===================================================================== */
export const CHAT_KACHELN = [
{ wert: "grund", name: "Neutral", farbe: "#4f545c" },
/* BABYBLAU -- die einzige helle Kachel (22.09.2026).
------------------------------------------------------------------
Filipe: „jeder normale blaue farbe, sei es die kachel im chat oder
emojis, nur babyblau bitte." Und im selben Auftrag: „Textfarbe
soll mitwechseln, am besten schwarz auf hellen Kacheln -- und
weiss, wenn jemand eine schwarze Kachel waehlt."
Die zwei Saetze gehoeren zusammen, und in dieser Reihenfolge.
Babyblau ist HELL (Leuchtdichte 0,547); die helle Schrift der
Blase kaeme darauf auf 1,63:1 -- unlesbar. Erst weil die Schrift
jetzt mitwechselt (schriftFuer weiter unten), ist diese Kachel
ueberhaupt moeglich.
Sie steht deshalb NICHT in der Rechnung von
tools/chat-kacheln-rechnen.mjs: Das Werkzeug rechnet elf bunte
Toene auf EINE gemeinsame Leuchtdichte, damit niemand sich durch
seine Wahl schlechter lesbar machen kann. Diese hier hat eine
andere Leuchtdichte und dafuer ihre eigene Schrift -- gemessen:
Text 10,78:1 (noetig 7), Fusszeile 4,87:1 (noetig 4,5). Dasselbe
Versprechen, auf anderem Weg eingeloest.
Der Wert ist exakt `--akzent` des Hauses. Eine zweite Zahl daneben
waere zwei Babyblau, und beim naechsten Mal drei. */
{ wert: "babyblau", name: "Babyblau", farbe: "#8ec9ff" },
{ wert: "tinte", name: "Tinte", farbe: "#0150af" },
{ wert: "veilchen", name: "Veilchen", farbe: "#6a01e5" },
{ wert: "pflaume", name: "Pflaume", farbe: "#9301a2" },
{ wert: "kirsche", name: "Kirsche", farbe: "#a5015e" },
{ wert: "ziegel", name: "Ziegel", farbe: "#ad0103" },
{ wert: "bernstein", name: "Bernstein", farbe: "#7e4601" },
{ wert: "oliv", name: "Oliv", farbe: "#635201" },
{ wert: "moos", name: "Moos", farbe: "#405c01" },
{ wert: "tanne", name: "Tanne", farbe: "#00603d" },
{ wert: "lagune", name: "Lagune", farbe: "#035e5c" },
{ wert: "ozean", name: "Ozean", farbe: "#045b74" },
];
/* =====================================================================
WELCHE SCHRIFT AUF WELCHER KACHEL (22.09.2026)
=====================================================================
Filipe: „Textfarbe soll mitwechseln, am besten schwarz auf hellen
Kacheln -- und weiss, wenn jemand eine schwarze Kachel waehlt."
GERECHNET, NICHT JE KACHEL EINGETRAGEN. Eine dritte Spalte in
CHAT_KACHELN waere eine Liste, die jemand pflegen muss -- und beim
naechsten Ton vergisst. Hier steht stattdessen die Regel, und die
Farbe folgt aus der Flaeche.
ZWEI PAARE, NICHT BELIEBIGE FARBEN: Ein frei gerechneter Grauwert je
Kachel ergaebe zwoelf verschiedene Schriften, und der Chat saehe aus
wie zwoelf verschiedene Programme. Es gibt ein helles Paar (das
bisherige, aus chat.css) und ein dunkles; genommen wird das, das die
noetigen Kontraste schafft.
DIE SCHWELLEN SIND DIESELBEN WIE IM RECHENWERKZEUG: 7:1 (AAA) fuer
den Text -- der Chat ist die Seite, auf der am laengsten gelesen
wird -- und 4,5:1 fuer die Fusszeile. Sie stehen hier einmal und
werden von pruef-chatkachel.mjs aus DIESER Datei gelesen; zwei
Zahlen in zwei Dateien waeren der Widerspruch, den niemand bemerkt.
===================================================================== */
export const SCHRIFT_NOETIG = { text: 7, leise: 4.5 };
/** Das helle Paar -- dieselben Werte wie `--blase-text` / `--blase-leise`
* in chat.css. Sie stehen dort als Rueckfall fuer den Fall, dass gar
* keine Kachel gesetzt ist. */
export const SCHRIFT_HELL = { text: "#f3f7fc", leise: "#c4d2e2" };
/** Das dunkle Paar fuer helle Kacheln. Gemessen auf Babyblau:
* 10,78:1 und 4,87:1. */
export const SCHRIFT_DUNKEL = { text: "#0b1119", leise: "#3b4e63" };
const alsLinear = (c) => (c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4);
function leuchtdichte(hex) {
const z = String(hex).replace("#", "");
const [r, g, b] = [0, 2, 4]
.map((i) => parseInt(z.slice(i, i + 2), 16) / 255).map(alsLinear);
return 0.2126 * r + 0.7152 * g + 0.0722 * b;
}
function kontrastZwischen(a, b) {
const x = leuchtdichte(a), y = leuchtdichte(b);
return (Math.max(x, y) + 0.05) / (Math.min(x, y) + 0.05);
}
/** Welches Schriftpaar traegt auf dieser Flaeche?
*
* GIBT IMMER EINES ZURUECK. Ein dritter Ausgang ("keines passt")
* waere hier falsch: Der Chat muss etwas anzeigen. Dass beide Paare
* reichen, ist die Aufgabe von pruef-chatkachel.mjs -- sie misst
* jeden Ton der Liste gegen genau diese Funktion. Faellt einer durch,
* ist das ein Befund und keine Notlage zur Laufzeit. */
export function schriftFuer(farbe) {
const passt = (paar) =>
kontrastZwischen(paar.text, farbe) >= SCHRIFT_NOETIG.text
&& kontrastZwischen(paar.leise, farbe) >= SCHRIFT_NOETIG.leise;
if (passt(SCHRIFT_HELL)) return SCHRIFT_HELL;
if (passt(SCHRIFT_DUNKEL)) return SCHRIFT_DUNKEL;
/* Schafft keines beide Schwellen, entscheidet der TEXT -- er ist
das, was man liest. */
return kontrastZwischen(SCHRIFT_HELL.text, farbe)
>= kontrastZwischen(SCHRIFT_DUNKEL.text, farbe) ? SCHRIFT_HELL : SCHRIFT_DUNKEL;
}
/** Nur ein Ton aus der Liste kommt durch -- sonst nichts.
*
* DIE PRUEFUNG STEHT HIER UND NICHT NUR IM FORMULAR. Was aus der
* Datenbank kommt, koennte aus einer aelteren Fassung stammen oder
* von einem Aufruf an der Oberflaeche vorbei; ein unbekannter Wert
* wanderte sonst als CSS-Farbe in die Seite. `null` heisst
* „Standard", und das ist ein gueltiger Zustand. */
export function kachelPruefen(wert) {
if (!wert) return null;
/* SEIT DEM 23.09.2026 GIBT ES ZWEI SORTEN SCHLUESSEL.
Filipe wollte statt der Kachelreihe einen Kreis, auf dem man die
Farbe "ganz genau selber auswaehlen kann". Ein Winkel ist damit
eine gueltige Wahl: "ton-214" heisst 214 Grad.
WARUM NICHT EINFACH DIE FARBE SPEICHERN: Dann koennte sich jeder
ein "#ffffff" eintragen -- und die helle Schrift der Blase waere
darauf unlesbar. Der Winkel dagegen ist eine Nummer in einer
Tabelle, die aus der Kontrastrechnung stammt. Wer sich etwas
Unlesbares wuenscht, bekommt schlicht keinen Treffer.
Die alten Schluessel bleiben gueltig. Wer "veilchen" gewaehlt hat,
behaelt es -- eine Umstellung, die stillschweigend die Wahl von
fuenfzehn Leuten zuruecksetzt, waere kein Fortschritt. */
if (winkelAus(wert) !== null) return String(wert);
return CHAT_KACHELN.some((k) => k.wert === String(wert)) ? String(wert) : null;
}
/* WER NICHTS EINSTELLT, BEKOMMT TROTZDEM EINE FARBE (22.09.2026)
---------------------------------------------------------------------
Filipe: „die kachel von den texten von den leuten im chat soll auch
klarer und stärker sein ... so dass die leute richtig bekommen es zu
benutzen."
Vorher hiess „nichts eingestellt" GRAU -- und eingestellt hatten es
vier von fuenfzehn. Auf dem Bildschirm war der Chat damit einfarbig,
egal wie gut die zwoelf Toene gerechnet sind. Eine Einstellung, die
man erst finden muss, damit ueberhaupt etwas passiert, benutzt kaum
jemand; das Ergebnis sehen aber alle.
Jetzt bekommt jede Person von sich aus einen der elf bunten Toene.
Dieselbe Person hat immer denselben -- man erkennt sie an der Farbe,
noch bevor man den Namen liest. Wer einen anderen will, waehlt ihn
weiterhin; die eigene Wahl gewinnt immer.
WARUM AUS DER ID UND NICHT AUS DEM NAMEN: Ein Name aendert sich
(Heirat, Schreibweise, Kuerzel), eine ID nie. Eine Farbe, die beim
Umbenennen springt, waere schlimmer als gar keine.
Der neutrale Ton bleibt in der Liste -- er ist jetzt eine WAHL
(„ich will keine Farbe"), keine Voreinstellung. */
/* WARUM NICHT EINFACH `id % 11`.
---------------------------------------------------------------------
Die elf Toene stehen in der Reihenfolge ihres Farbwinkels -- Nachbarn
in der Liste sind auch Nachbarn im Farbkreis. Mit `id % 11` bekommen
zwei Leute, deren Nummern aufeinanderfolgen, deshalb zwei aehnliche
Farben. Gemessen am Bildschirm: Person 13 und 14 sassen im selben
Gespraech, eine magenta, eine rot -- auf dem Bildschirmfoto kaum zu
trennen, und genau das, was die Farbe verhindern soll.
Elf ist eine Primzahl. Damit ist JEDE Schrittweite von 1 bis 10
teilerfremd, laeuft also durch alle elf Toene, bevor sich einer
wiederholt -- keiner geht verloren. Die 4 ist gewaehlt, weil sie den
groessten Sprung ergibt: vier Schritte sind rund 131 Grad im
Farbkreis, fast das Maximum von 180. Aufeinanderfolgende Nummern
landen damit so weit auseinander wie moeglich. */
const SPRUNG = 4;
export function autoKachelFuer(personId) {
const bunte = CHAT_KACHELN.filter((k) => k.wert !== "grund");
if (!bunte.length) return null;
const n = Number(personId);
if (!Number.isFinite(n) || n < 0) return null;
return bunte[(n * SPRUNG) % bunte.length].wert;
}
/** Der Ton, den diese Person TRAEGT -- eigene Wahl, sonst die
* automatische. Fuer die Frage „was hat sie eingestellt?" gibt es
* `gewaehlteKachelFuer`; die beiden zu verwechseln hiesse, dass im
* Waehler ploetzlich ein Ton angehakt waere, den niemand gewaehlt hat. */
function kachelFuer(personId) {
return gewaehlteKachelFuer(personId) || autoKachelFuer(personId);
}
function gewaehlteKachelFuer(personId) {
try {
return kachelPruefen(db().prepare(
"SELECT chat_kachel FROM personen WHERE id = ?").get(personId)?.chat_kachel);
} catch { return null; }
}
function teilnehmerVon(raumId) {
return db().prepare(`
SELECT t.person_id AS id, p.name, p.rolle, p.bild, t.leitung, t.gelesen_bis
FROM chat_teilnehmer t
JOIN personen p ON p.id = t.person_id
WHERE t.raum_id = ? AND t.raus_am IS NULL
ORDER BY ` + ROLLEN_SORTIERUNG + ", p.name").all(raumId)
.map((z) => ({ ...z, bild: z.bild ? `/workspace/api/steckbrief/bild/${z.bild}` : null }));
}
/** Findet das Zweier-Gespräch der beiden -- oder legt es an.
*
* ES DARF NUR EINES GEBEN. Zwei Gespräche zwischen denselben zwei
* Leuten wären ein Verlauf an zwei Orten: Man schreibt in das eine,
* der andere liest im anderen und wartet. Deshalb wird zuerst
* gesucht, und zwar über die Teilnehmer -- ein "Paarschlüssel" als
* Spalte wäre eine zweite Wahrheit neben chat_teilnehmer. */
function direktRaum(personA, idB, { anlegen = true } = {}) {
const d = db();
const vorhanden = d.prepare(`
SELECT r.id FROM chat_raeume r
WHERE r.art = 'direkt'
AND EXISTS (SELECT 1 FROM chat_teilnehmer t WHERE t.raum_id = r.id AND t.person_id = ?)
AND EXISTS (SELECT 1 FROM chat_teilnehmer t WHERE t.raum_id = r.id AND t.person_id = ?)
AND (SELECT COUNT(*) FROM chat_teilnehmer t WHERE t.raum_id = r.id) = 2`)
.get(personA.id, idB);
if (vorhanden) return vorhanden.id;
if (!anlegen) return null;
const n = jetzt();
d.prepare("INSERT INTO chat_raeume (art, erstellt, erstellt_von, letzte_am) VALUES ('direkt',?,?,NULL)")
.run(n, personA.id);
const raumId = d.prepare("SELECT last_insert_rowid() AS id").get().id;
const rein = d.prepare(
"INSERT INTO chat_teilnehmer (raum_id, person_id, seit, gelesen_bis) VALUES (?,?,?,0)");
rein.run(raumId, personA.id, n);
rein.run(raumId, idB, n);
return raumId;
}
/* =====================================================================
WAS IST DAS WIRKLICH? — die Erkennung an den ersten Bytes
DIE GANZE SICHERHEIT DER ANHÄNGE HÄNGT AN DIESER FUNKTION.
Der Dateiname kommt vom Absender. Der Content-Type kommt vom
Absender. Beide kann man frei erfinden. Wer sich auf sie verlässt,
liefert irgendwann eine HTML- oder SVG-Datei mit der Endung .png
aus -- und die läuft dann im Browser als Seite DIESER Domain, mit
Zugriff auf die Sitzung des Empfängers. Das ist der Standardfehler
bei selbst gebauten Uploads, und er ist von aussen nicht zu sehen.
Deshalb: Der Typ wird aus dem Inhalt bestimmt. Was hier nicht
erkannt wird, kommt nicht herein -- und ausgeliefert wird später
genau der Typ, der HIER festgestellt wurde, nie der eingeschickte.
SVG STEHT ABSICHTLICH NICHT IN DER LISTE. Eine SVG-Datei ist ein
XML-Dokument und darf Skripte enthalten; sie ist als "Bild"
getarnter Programmtext. Fotos sind PNG, JPEG, WebP oder GIF.
Breite und Höhe kommen im selben Durchgang mit: Der Verlauf
reserviert damit den Platz, bevor das Bild da ist, und springt beim
Laden nicht. Lassen sie sich nicht ablesen, ist das kein Grund zur
Ablehnung -- dann steht eben 0, und der Platz wird geschätzt.
===================================================================== */
function dateiErkennen(b) {
if (!Buffer.isBuffer(b) || b.length < 16) return null;
const kopf = (von, bis) => b.toString("latin1", von, bis);
/* --- PNG: acht feste Bytes, danach muss IHDR kommen. -------------- */
if (b[0] === 0x89 && kopf(1, 4) === "PNG" && b[4] === 0x0d && b[5] === 0x0a
&& b[6] === 0x1a && b[7] === 0x0a) {
if (b.length >= 24 && kopf(12, 16) === "IHDR") {
return { art: "bild", typ: "image/png", endung: ".png",
breite: b.readUInt32BE(16), hoehe: b.readUInt32BE(20) };
}
return null; /* PNG-Kopf ohne IHDR ist keins */
}
/* --- GIF ---------------------------------------------------------- */
if (kopf(0, 6) === "GIF87a" || kopf(0, 6) === "GIF89a") {
return { art: "bild", typ: "image/gif", endung: ".gif",
breite: b.readUInt16LE(6), hoehe: b.readUInt16LE(8) };
}
/* --- WebP: RIFF-Behälter mit der Kennung WEBP ---------------------- */
if (kopf(0, 4) === "RIFF" && kopf(8, 12) === "WEBP") {
let breite = 0, hoehe = 0;
const sorte = kopf(12, 16);
try {
if (sorte === "VP8 " && b.length > 30 && b[23] === 0x9d && b[24] === 0x01 && b[25] === 0x2a) {
breite = b.readUInt16LE(26) & 0x3fff;
hoehe = b.readUInt16LE(28) & 0x3fff;
} else if (sorte === "VP8L" && b.length > 25 && b[20] === 0x2f) {
/* Vier Bytes, aus denen zweimal 14 Bit gelesen werden. */
const w = b.readUInt32LE(21);
breite = (w & 0x3fff) + 1;
hoehe = ((w >> 14) & 0x3fff) + 1;
} else if (sorte === "VP8X" && b.length > 30) {
breite = (b[24] | (b[25] << 8) | (b[26] << 16)) + 1;
hoehe = (b[27] | (b[28] << 8) | (b[29] << 16)) + 1;
}
} catch { breite = 0; hoehe = 0; }
return { art: "bild", typ: "image/webp", endung: ".webp", breite, hoehe };
}
/* --- JPEG: SOI, danach muss ein weiterer Marker folgen. ------------ */
if (b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff) {
let breite = 0, hoehe = 0;
let i = 2;
/* Durch die Abschnitte springen, bis ein Bildkopf (SOF) kommt.
0xc4/0xc8/0xcc sind KEINE Bildköpfe (Huffman-Tabellen u. ä.) --
wer die mitnimmt, liest dort Unsinn als Maße. */
while (i + 9 < b.length) {
if (b[i] !== 0xff) { i++; continue; }
const m = b[i + 1];
if (m === 0xff) { i++; continue; } /* Füllbyte */
if (m === 0xd8 || m === 0x01 || (m >= 0xd0 && m <= 0xd7)) { i += 2; continue; }
if (m === 0xda) break; /* ab hier Bilddaten */
const laenge = b.readUInt16BE(i + 2);
if (laenge < 2) break;
if (m >= 0xc0 && m <= 0xcf && m !== 0xc4 && m !== 0xc8 && m !== 0xcc) {
hoehe = b.readUInt16BE(i + 5);
breite = b.readUInt16BE(i + 7);
break;
}
i += 2 + laenge;
}
return { art: "bild", typ: "image/jpeg", endung: ".jpg", breite, hoehe };
}
/* --- PDF ---------------------------------------------------------- */
if (kopf(0, 5) === "%PDF-") {
return { art: "pdf", typ: "application/pdf", endung: ".pdf", breite: 0, hoehe: 0 };
}
/* =====================================================================
SPRACHNACHRICHTEN (23.09.2026)
Filipe: „dan will ich auch dass man im chat auch sprachnachrichten
und gifts reinschicken kann. also nur die modis rechte linke hand
und dogfather."
DREI BEHAELTER, WEIL DIE GERAETE DREI LIEFERN -- das ist keine
Grosszuegigkeit, sondern die Bedingung dafuer, dass es ueberhaupt
auf jedem Handy geht:
WebM/Opus Chrome, Edge, Android
MP4/AAC Safari, iPhone, iPad
Ogg/Opus Firefox
Wer nur einen davon nimmt, baut eine Funktion, die bei der Haelfte
des Teams stumm bleibt.
WARUM KEIN MP3: Kein Aufnahmegeraet im Browser erzeugt MP3. Es
zuzulassen hiesse, eine Tuer fuer Musikdateien aufzumachen, nach
der niemand gefragt hat. Bestellt waren Sprachnachrichten.
DER BEHAELTER ALLEIN GENUEGT NICHT. WebM und MP4 tragen genauso
gut Video -- und ein Video, das hier als "Ton" durchginge, landete
in einem Abspielgeraet ohne Bild: Es liefe, man hoerte etwas, und
niemand wuesste, dass die Haelfte fehlt. Deshalb wird im Kopf nach
der KENNUNG DER SPUR gesucht: Steht dort eine Videospur, wird
abgelehnt; steht keine Tonspur darin, ebenfalls.
GESUCHT WIRD NUR IM ANFANG (16 kB). Dort stehen bei allen drei
Formaten die Spurangaben. Die ganze Datei zu durchsuchen hiesse,
bei vier Megabyte nach Zeichenketten zu graben -- und dabei
irgendwann ein "avc1" mitten in den Tondaten zu finden.
===================================================================== */
const anfang = b.toString("latin1", 0, Math.min(b.length, 16384));
const hatVideo = /V_VP8|V_VP9|V_AV1|V_MPEG|avc1|hvc1|hev1|av01|mp4v|theora/.test(anfang);
/* --- WebM / Matroska: EBML-Kennung ------------------------------- */
if (b[0] === 0x1a && b[1] === 0x45 && b[2] === 0xdf && b[3] === 0xa3) {
if (hatVideo) return null;
if (!/A_OPUS|A_VORBIS|A_AAC|A_PCM/.test(anfang)) return null;
return { art: "ton", typ: "audio/webm", endung: ".webm", breite: 0, hoehe: 0 };
}
/* --- Ogg ---------------------------------------------------------- */
if (kopf(0, 4) === "OggS") {
if (hatVideo) return null;
if (!/OpusHead|vorbis|Speex|FLAC/.test(anfang)) return null;
return { art: "ton", typ: "audio/ogg", endung: ".ogg", breite: 0, hoehe: 0 };
}
/* --- MP4 / M4A: "ftyp" steht an Stelle 4, nicht 0 ----------------- */
if (kopf(4, 8) === "ftyp") {
if (hatVideo) return null;
if (!/M4A |mp4a|Opus/.test(anfang)) return null;
return { art: "ton", typ: "audio/mp4", endung: ".m4a", breite: 0, hoehe: 0 };
}
return null;
}
/** Wie heisst ein Anhang in einem Satz?
*
* „Foto" steht in der Gespraechsliste, im Zitat, an einer angehefteten
* Nachricht und in der Benachrichtigung -- an vier Stellen stand
* dieselbe Aufzaehlung, jede mit ihrem eigenen `? :`. Beim Hinzukommen
* der Sprachnachricht waeren es vier Aenderungen gewesen, und die
* vierte ist die, die man vergisst. Jetzt eine Stelle.
*
* LEER FUER UNBEKANNTES, nicht "Anhang": Der Aufrufer setzt das Wort
* hinter ein `||` -- ein Ersatzwort fuer etwas, das es nicht gibt,
* stuende sonst in einer Vorschau, in der nichts ist.
*/
export function anhangWort(art) {
return art === "bild" ? "Foto"
: art === "pdf" ? "PDF"
: art === "ton" ? "Sprachnachricht"
: "";
}
/** Der Anzeigename. Er steht nur in der Datenbank -- auf der Platte
* bekommt jede Datei einen erzeugten Zufallsnamen, damit ein Name mit
* "../" darin nirgendwo hinkommt. */
function anhangName(roh, endung) {
let name;
try { name = decodeURIComponent(roh || ""); } catch { name = String(roh || ""); }
name = basename(name).replace(/[\x00-\x1f<>:"/\\|?*]/g, "_").trim();
name = name.slice(0, ANHANG_NAME_MAX);
if (!name) name = "anhang" + endung;
return name;
}
/** Bis zu welcher Nachricht hat DIESE Person das Gespräch weggeräumt?
* 0 heisst: gar nicht. Steht an einer Stelle, damit keine Abfrage sie
* vergisst -- eine zweite Fassung wäre ein Gespräch, das in der Liste
* weg ist und in der Suche noch auftaucht. */
function geloeschtBis(raumId, personId) {
try {
return db().prepare(
"SELECT geloescht_bis FROM chat_teilnehmer WHERE raum_id = ? AND person_id = ?")
.get(raumId, personId)?.geloescht_bis ?? 0;
} catch { return 0; }
}
/** Wie heißt dieser Raum für DIESE Person?
*
* Ein Zweier-Gespräch heißt für jede Seite anders -- nach dem
* Gegenüber. Deshalb steht der Name nicht in der Tabelle: Er wäre für
* eine der beiden Seiten immer falsch. */
/* =====================================================================
KATEGORIE-KANAELE (10.09.2026, Kapitel 7.2)
===================================================================== */
/** Hoechstens drei Ankuendigungen je Raum.
*
* Nicht eine (dann kann man Regeln, Live-Plan und Frist nicht
* gleichzeitig oben haben) und nicht beliebig viele: Eine Pinnwand,
* die scrollt, ist keine Pinnwand mehr, sondern ein zweiter Verlauf.
* Wer die vierte anheften will, muss sich fuer eine entscheiden --
* und genau diese Entscheidung ist der Sinn der Funktion. */
const PIN_MAX = 3;
/** Der Name eines Kanals kommt aus der Kategorie, nicht aus einem Feld.
*
* Ein freies Namensfeld waere die naheliegende Freiheit -- und der
* sichere Weg zu "Clipping" neben "Clipping-Team", mit je der Haelfte
* der Nachrichten darin. Wer die Kategorie umbenennt, benennt damit
* jeden Kanal um; sie stehen nicht doppelt. */
function kanalName(kategorie) {
/* Der Treff steht nicht in MODI_KATEGORIEN -- er ist kein Thema des
Teams, sondern ein eigener Raum mit eigenen Regeln. Ohne diese
Zeile hiesse er schlicht "Kanal". */
if (kategorie === TREFF_KATEGORIE) return TREFF_NAME;
return MODI_KATEGORIEN.find((k) => k.wert === kategorie)?.name || "Kanal";
}
/** Wer darf hier etwas anheften?
*
* Die Teamfuehrung ueberall -- so steht es im Dokument. UND wer eine
* Gruppe angelegt hat, in seiner eigenen: Der Chat gehoert nicht nur
* Team Dogi, auch Manager und Scouts fuehren Gruppen. Waere das
* Anheften allein der Teamfuehrung vorbehalten, gaebe es die Funktion
* fuer die Haelfte des Hauses nicht -- und sie waere trotzdem
* sichtbar. */
function darfAnheften(person, raumId) {
if (fuehrtTeamDogi(person)) return true;
try {
return !!db().prepare(`SELECT 1 FROM chat_teilnehmer
WHERE raum_id = ? AND person_id = ? AND raus_am IS NULL AND leitung = 1`)
.get(raumId, person.id);
} catch { return false; }
}
/** Traegt die Teamfuehrung in jeden Kanal ein, in dem sie fehlt.
*
* WARUM SELBSTHEILEND UND NICHT AN DREI HAKEN: Die Zeile muesste sonst
* beim Anlegen eines Kanals, beim Anlegen einer Person und beim
* Rollenwechsel entstehen -- drei Stellen, von denen die dritte beim
* naechsten Umbau vergessen wird. Hier laeuft es genau dann, wenn es
* gebraucht wird: beim Blick in die Gespraechsliste, und nur fuer
* zwei Rollen.
*
* `gelesen_bis` STARTET AM AKTUELLEN STAND, nicht bei null. Wer heute
* dazukommt, hat die vierhundert Nachrichten von vorher nicht
* verpasst -- eine rote Vierhundert waere keine Auskunft, sondern
* Rauschen, und man schaltet sie ab statt sie zu lesen. */
/* =====================================================================
WER IN EINEN KATEGORIE-KANAL GEHOERT (22.09.2026)
=====================================================================
VanVans Befund, von Filipe weitergegeben:
* "Patrick und BananaStift (stifti) aus der Erwaehnen-Liste
entfernen -- sie stehen dort als SCOUT und gehoeren nicht in
diesen Chat."
* "Die Modis zum Erwaehnen hinzufuegen."
* "Die Modis sehen den Chat Moderation auch gar nicht."
AN DER LIVE-DATENBANK NACHGEMESSEN, bevor irgendetwas gebaut wurde:
Raum 3 kanal Chat-Moderation admin, hand, SCOUT, SCOUT, linke
Raum 7 kanal Der Treff admin, hand, 4x modi, linke, 3x gast
Raum 8 gruppe Dogi und Modis admin, hand, 4x modi, linke
Raum 9 gruppe Abmeldungen admin, hand, 4x modi, linke
Damit waren alle drei Punkte EIN Befund: Die Erwaehnen-Liste zeigt
genau die Teilnehmer des Raums (teilnehmerVon). Im
Moderations-Kanal standen zwei Scouts und kein einziger Modi --
also schlug die Liste Scouts vor, und die Modis sahen den Kanal gar
nicht. Nichts davon war ein Fehler der Erwaehnung.
DIE REGEL: Ein Kategorie-Kanal gehoert Team Dogi. Scouts, Manager
und Creator arbeiten im anderen Haus; sie haben in einem Kanal
ueber Chat-Moderation nichts verloren -- und dass sie dort standen,
war kein Rechtefehler, sondern eine Besetzung von Hand, die nie
jemand nachgeprueft hat.
SELBSTHEILEND, IN BEIDE RICHTUNGEN -- und das ist der Unterschied
zum alten Abgleich, der nur die Teamfuehrung nachtrug:
hinein jeder aktive Mensch aus Team Dogi, der in diesem Raum
NOCH NIE eine Zeile hatte
hinaus jeder aktive Teilnehmer, dessen Rolle nicht dazugehoert
(raus_am, kein DELETE -- der Verlauf bleibt lesbar)
"NOCH NIE EINE ZEILE" IST DER WICHTIGE TEIL. Wer ueber die
Mitglieder-Route bewusst herausgenommen wurde, hat eine Zeile mit
`raus_am` -- und wird deshalb NICHT wieder hineingezogen. Ein
Abgleich, der eine Entscheidung von Hand beim naechsten Seitenaufruf
ueberschreibt, macht die Mitglieder-Route wertlos; dieselbe
Ueberlegung steht schon bei treffAngleichen().
DER TREFF BLEIBT AUSSEN VOR. Er ist zwar technisch ein 'kanal',
aber kein Thema des Teams -- dort gehoert die Community dazu, und
TREFF_ROLLEN sagt das an seiner eigenen Stelle.
===================================================================== */
/** Wer in einen Kategorie-Kanal gehoert.
*
* ABGELEITET, NICHT ABGESCHRIEBEN: TEAM_DOGI_ROLLEN ist die eine
* Liste des Hauses (hand, linke, modi); DogFather kommt dazu, weil er
* zum Team gehoert -- er steht nicht darueber, er ist dabei. Kaeme
* morgen eine weitere Team-Rolle, waere sie hier von selbst dabei. */
export const KANAL_ROLLEN = ["admin", ...TEAM_DOGI_ROLLEN];
function kanaeleAngleichen(person) {
if (!fuehrtTeamDogi(person)) return 0;
try {
const d = db();
const n = jetzt();
const platz = KANAL_ROLLEN.map(() => "?").join(", ");
/* 1. WER FEHLT, KOMMT HINEIN. `gelesen_bis` auf den letzten Stand:
Wer heute dazukommt, hat nichts verpasst -- sonst staende beim
ersten Oeffnen eine rote Zahl ueber allem, was das Team je
geschrieben hat. Dieselbe Ueberlegung wie in der
Mitglieder-Route. */
const dazu = d.prepare(`
INSERT INTO chat_teilnehmer (raum_id, person_id, seit, gelesen_bis, leitung)
SELECT r.id, p.id, ?,
COALESCE((SELECT MAX(id) FROM chat_nachrichten WHERE raum_id = r.id), 0),
CASE WHEN p.rolle IN ('admin','hand') THEN 1 ELSE 0 END
FROM chat_raeume r
JOIN personen p ON p.aktiv = 1 AND p.rolle IN (${platz})
WHERE r.art = 'kanal' AND COALESCE(r.kategorie, '') <> ?
AND NOT EXISTS (SELECT 1 FROM chat_teilnehmer t
WHERE t.raum_id = r.id AND t.person_id = p.id)`)
.run(n, ...KANAL_ROLLEN, TREFF_KATEGORIE).changes;
/* 2. WER NICHT DAZUGEHOERT, GEHT HINAUS. Nicht geloescht: Was er
geschrieben hat, bleibt lesbar, und niemand verschwindet
rueckwirkend aus der Geschichte. */
const raus = d.prepare(`
UPDATE chat_teilnehmer SET raus_am = ?
WHERE raus_am IS NULL
AND raum_id IN (SELECT id FROM chat_raeume
WHERE art = 'kanal' AND COALESCE(kategorie, '') <> ?)
AND person_id IN (SELECT id FROM personen WHERE rolle NOT IN (${platz}))`)
.run(n, TREFF_KATEGORIE, ...KANAL_ROLLEN).changes;
if (dazu || raus) {
console.log(`[chat] Kanal-Abgleich: +${dazu} / -${raus}`);
}
return dazu + raus;
} catch (fehler) {
/* Ein Fehler hier darf die Gespraechsliste nicht kosten. Der
Zugriff selbst haengt ohnehin nicht daran -- istDrin() laesst die
Teamfuehrung auch ohne Zeile in einen Kanal. */
console.error("[chat] Kanal-Abgleich:", fehler?.message);
return 0;
}
}
/** Gehoert diese Person in einen Kategorie-Kanal?
*
* STEHT AN EINER STELLE, weil drei danach fragen: der Abgleich oben,
* das Anlegen eines Kanals und das Umbesetzen. Drei Fassungen waeren
* die, bei der die dritte beim naechsten Umbau vergessen wird -- und
* genau diese dritte Luecke hat VanVan gefunden. */
function gehoertInKanal(id) {
try {
const r = db().prepare("SELECT rolle FROM personen WHERE id = ? AND aktiv = 1").get(id);
return !!r && KANAL_ROLLEN.includes(r.rolle);
} catch { return false; }
}
function raumName(raum, teilnehmer, ichId) {
if (raum.art === "kanal") return raum.name || kanalName(raum.kategorie);
if (raum.art === "gruppe") return raum.name || "Gruppe";
const andere = teilnehmer.filter((t) => t.id !== ichId);
return andere.map((t) => t.name).join(", ") || "Gespräch";
}
/* =====================================================================
Die Schnittstellen
===================================================================== */
/** Mit wem kann ich ein Gespräch anfangen? */
chatRouter.get("/workspace/api/chat/partner", (req, res) => {
try {
const ids = schreibbareIds(req.person);
const wo = ids === null
? "id <> ?" : `id IN (${ids.map(() => "?").join(",")})`;
const werte = ids === null ? [req.person.id] : ids;
if (ids !== null && !ids.length) return res.json({ personen: [] });
/* DIE UEBERSCHRIFT KOMMT MIT (10.09.2026).
Die Auswahl im Browser zeichnete nach der Rollenfolge aus
bereiche.js -- und wer dort nicht steht, wurde nicht gezeichnet.
Still: keine Luecke, kein Fehler, nur ein Mensch, den es fuer
die Auswahl nicht gab. Mit einem Text vom Server kann der
Browser auch eine Rolle zeigen, deren Namen er gar nicht kennen
darf. */
res.json({
personen: db().prepare(
`SELECT id, name, rolle FROM personen WHERE aktiv = 1 AND ${wo}
ORDER BY ` + ROLLEN_SORTIERUNG + ", name").all(...werte)
.map((p) => ({ ...p, gruppe: ROLLEN_GRUPPE[p.rolle] || "Weitere" })),
});
} catch (fehler) {
console.error("[chat] Partner:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/** Meine Gespräche, das jüngste zuerst. */
/* =====================================================================
DIE EIGENE KACHEL EINSTELLEN (20.09.2026)
Filipe: „jeder account soll seine kachel personalisieren koennen."
ZWEI WEGE, WEIL ES ZWEI FRAGEN SIND: „welche gibt es" und „das will
ich". Die Liste kommt vom Server, damit im Browser keine zweite
Fassung der zwoelf Toene steht -- die waere beim dreizehnten die
vergessene.
NUR FUER SICH SELBST. Es gibt keinen Weg, die Kachel eines anderen
zu setzen, und das ist keine Luecke: Die Kachel ist das Einzige auf
dieser Seite, das einem selbst gehoert. Ein Recht der Leitung darauf
waere ein Recht, jemandem seine Farbe wegzunehmen.
===================================================================== */
chatRouter.get("/workspace/api/chat/kacheln", (req, res) => {
try {
res.json({
/* DIE SCHRIFT GEHT MIT. Der Browser soll sie nicht selbst
rechnen -- dann staende die Regel zweimal da, und beim
naechsten Ton waere eine der beiden Fassungen aelter. */
kacheln: CHAT_KACHELN.map((k) => ({ ...k, schrift: schriftFuer(k.farbe) })),
/* DER KREIS: 360 fertige Farben, Index = Winkel.
Der Browser rechnet sie NICHT selbst aus. Die Formel steht in
tools/chat-kacheln-rechnen.mjs und haengt an den Schriftfarben
aus dem CSS; sie ein zweites Mal in JavaScript zu fuehren
hiesse, dass die zweite Fassung ab dem naechsten
Schriftwechsel falsch ist -- und zwar unbemerkt, denn beide
liefern ja "irgendeine Farbe".
Rund 3 kB. Sie kommen mit derselben Anfrage, die es ohnehin
gibt; eine eigene waere eine zweite Wartezeit fuer nichts. */
kreis: KREIS,
/* Alle 360 liegen auf derselben Leuchtdichte wie die elf bunten
Kacheln -- also tragen sie auch dieselbe Schrift. Einmal
gerechnet und mitgeschickt, statt 360-mal dasselbe. */
kreis_schrift: schriftFuer(KREIS[0]),
/* Die eigene WAHL, nicht der getragene Ton -- sonst stuende im
Waehler ein Haken bei einer Farbe, die niemand gewaehlt hat. */
meine: gewaehlteKachelFuer(req.person.id),
/* Damit der Waehler beim neutralen Eintrag zeigen kann, was
stattdessen getragen wird, wenn man nichts waehlt. */
automatisch: autoKachelFuer(req.person.id),
});
} catch (f) {
console.error("[chat] Kacheln:", f?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
chatRouter.put("/workspace/api/chat/kachel", express.json({ limit: "2kb" }),
gleicheHerkunft, (req, res) => {
try {
const roh = req.body?.kachel;
/* LEER IST GUELTIG und heisst "Standard". Wer sich umentscheidet,
braucht einen Weg zurueck -- eine Einstellung ohne Rueckweg ist
eine Falle, keine Einstellung. */
const wert = (roh === null || roh === "" || roh === "grund")
? null : kachelPruefen(roh);
if (roh && roh !== "grund" && wert === null) {
return res.status(400).json({ fehler: "unbekannte_kachel" });
}
db().prepare("UPDATE personen SET chat_kachel = ? WHERE id = ?")
.run(wert, req.person.id);
res.json({ kachel: wert });
} catch (f) {
console.error("[chat] Kachel setzen:", f?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
chatRouter.get("/workspace/api/chat/raeume", (req, res) => {
try {
/* WEGGERÄUMTE GESPRÄCHE STEHEN NICHT IN DER LISTE.
Die Bedingung sitzt hier in der Abfrage und nicht in einem
Filter danach: Was nicht herauskommt, kann auch niemand
versehentlich wieder hineinreichen.
Zwei Fälle, und beide müssen stimmen:
* Es kam etwas Neues -> das Gespräch ist wieder da, aber nur
mit dem Neuen (id > geloescht_bis).
* Es kam nichts -> es bleibt weg. Auch dann, wenn es nie eine
Nachricht gab; dafür steht geloescht_am. */
/* ERST ANGLEICHEN, DANN LESEN. Ein Kanal, in dem die Teamfuehrung
keine Zeile hat, waere ihr zugaenglich (istDrin laesst sie
hinein) und stuende trotzdem nicht in ihrer Liste -- erreichbar
nur ueber einen Link, den ihr jemand schickt. Das ist genau die
Sorte Loch, die man nicht bemerkt, weil nichts kaputt aussieht. */
kanaeleAngleichen(req.person);
/* UND DER TREFF. `kanaeleAngleichen` traegt nur die Teamfuehrung
ein; im Treff stehen ausserdem die Community und die Modis.
Derselbe Gedanke, andere Personengruppe -- und aus demselben
Grund selbstheilend: Ein neuer Zugang aus der Community soll im
Chat stehen, ohne dass jemand daran denken muss. */
if (gehoertInTreff(req.person)) treffAngleichen();
const reihen = db().prepare(`
SELECT r.id, r.art, r.name, r.kategorie, r.letzte_am, r.erstellt_von,
t.gelesen_bis, t.leitung, t.geloescht_bis
FROM chat_raeume r
JOIN chat_teilnehmer t ON t.raum_id = r.id AND t.person_id = ?
WHERE t.raus_am IS NULL
AND (t.geloescht_am IS NULL
OR EXISTS (SELECT 1 FROM chat_nachrichten n
WHERE n.raum_id = r.id AND n.id > t.geloescht_bis))
ORDER BY CASE WHEN r.letzte_am IS NULL THEN 1 ELSE 0 END, r.letzte_am DESC, r.id DESC`)
.all(req.person.id);
const raeume = reihen.map((r) => {
const leute = teilnehmerVon(r.id);
/* Die letzte Nachricht als Vorschau -- ohne sie ist eine
Gesprächsliste nur eine Namensliste. Sie muss dieselbe Grenze
achten wie der Verlauf: Sonst stünde in der Vorschau ein Satz,
den man beim Öffnen nirgends findet. */
const letzte = db().prepare(`
SELECT n.text, n.erstellt, n.weg_am, n.anhang_art, p.name AS von
FROM chat_nachrichten n
LEFT JOIN personen p ON p.id = n.person_id
WHERE n.raum_id = ? AND n.id > ? ORDER BY n.id DESC LIMIT 1`)
.get(r.id, r.geloescht_bis);
const ungelesen = db().prepare(`
SELECT COUNT(*) AS n FROM chat_nachrichten
WHERE raum_id = ? AND id > ? AND id > ? AND person_id <> ?`)
.get(r.id, r.gelesen_bis, r.geloescht_bis, req.person.id).n;
/* STEHT IN DEN UNGELESENEN EIN "@" AN MICH? (20.09.2026)
Eine Zahl sagt "hier ist etwas". Sie sagt nicht, ob es an
DICH war. Wer morgens vier Raeume mit Zahlen sieht, macht
den lautesten zuerst auf -- und genau dort steht selten das,
was auf ihn wartet. Das Zeichen daneben dreht die Reihenfolge
um.
DIESELBEN ZWEI GRENZEN wie bei der Zahl darueber: was schon
gelesen ist, und was weggeraeumt wurde. Ohne die zweite
leuchtete ein Gespraech wieder auf, das jemand bewusst
beiseitegelegt hat.
UND `weg_am IS NULL`: Eine zurueckgenommene Nachricht spricht
niemanden mehr an. Der Eintrag bleibt stehen (er gehoert zur
Nachricht), zaehlt hier aber nicht mehr mit -- gerechnet wird
beim Lesen, nicht beim Zuruecknehmen, damit es keine zweite
Stelle gibt, die man vergessen kann. */
const erwaehnt = !!db().prepare(`
SELECT 1 FROM chat_erwaehnungen e
JOIN chat_nachrichten n ON n.id = e.nachricht_id
WHERE e.person_id = ? AND n.raum_id = ?
AND n.id > ? AND n.id > ? AND n.weg_am IS NULL
LIMIT 1`)
.get(req.person.id, r.id, r.gelesen_bis, r.geloescht_bis);
return {
id: r.id,
art: r.art,
kategorie: r.kategorie || null,
name: raumName(r, leute, req.person.id),
leitung: !!r.leitung,
/* DARF ICH DIESEN RAUM FUER ALLE AUFLOESEN? (11.09.2026)
Vom Server beantwortet, nicht im Browser nachgerechnet -- die
Oberflaeche hat `erstellt_von` sonst gar nicht. Die Regel
selbst steht in darfAufloesen(), damit sie nicht an zwei
Stellen steht; genau daran ist es beim ersten Anlauf
gescheitert. */
darf_aufloesen: darfAufloesen(r, req.person),
/* DAS BILD GEHOERT DAZU (20.09.2026).
Filipe: "da soll man im chat auch die profilfotos von den
leuten sehen wenn die schon eins drin haben."
Es fehlte genau hier: `teilnehmerVon` liest das Bild aus der
Datenbank, und diese Zeile warf es weg. Die Detailansicht
weiter unten nimmt es mit -- die LISTE nicht. Deshalb stand
im offenen Gespraech ein Gesicht und in der Liste daneben ein
Buchstabe, vom selben Menschen. */
teilnehmer: leute.map((t) => ({ id: t.id, name: t.name, rolle: t.rolle,
bild: t.bild })),
letzte: letzte ? {
/* Ein Anhang ohne Begleittext hätte hier eine leere Zeile
hinterlassen. „Foto", „PDF", „Sprachnachricht" ist die
Vorschau, die man in jeder Gesprächsliste erwartet -- das
Wort kommt aus anhangWort(), an einer Stelle für alle vier
Orte, an denen es gebraucht wird. */
text: letzte.weg_am ? null
: (letzte.text ? letzte.text.slice(0, 140)
: anhangWort(letzte.anhang_art)),
zurueckgenommen: !!letzte.weg_am,
von: letzte.von, erstellt: letzte.erstellt,
} : null,
ungelesen,
erwaehnt,
};
});
/* WELCHE KANAELE ES NOCH NICHT GIBT -- und nur fuer die, die sie
anlegen duerfen.
Die Liste steht bewusst NICHT in einer Datei im Browser. Sie
verraet fuer sich genommen nichts Schlimmes, aber sie ist der
Anfang einer Aufzaehlung dessen, was das Team tut; und die
Oberflaeche zeigt den Knopf ohnehin nur, wenn hier etwas
ankommt. Wer nichts anlegen darf, bekommt ein leeres Feld -- und
ein leeres Feld sagt nichts. */
const darfKanal = fuehrtTeamDogi(req.person);
const belegt = darfKanal
? new Set(db().prepare("SELECT kategorie FROM chat_raeume WHERE art = 'kanal'")
.all().map((z) => z.kategorie))
: new Set();
res.json({
raeume,
darf_kanal: darfKanal,
kanal_frei: darfKanal ? MODI_KATEGORIEN.filter((k) => !belegt.has(k.wert)) : [],
/* WAS FUER DEN TREFF GILT, STEHT IN DER ANTWORT -- die Seite
rechnet die Nachtruhe NICHT selbst nach. Eine zweite Rechnung
im Browser waere die, die bei der naechsten Zeitumstellung
anders herauskommt als die im Server; dann sagt die Seite
"offen", waehrend der Server ablehnt. */
treff: gehoertInTreff(req.person) ? nachtruheStand() : null,
/* AUSDRUECKLICH GESAGT, NICHT ERRATEN (19.09.2026).
Die Anrufknoepfe verschwinden fuer die Community nicht von
selbst, nur weil die Schnittstelle 404 antwortet -- sie stuenden
da und taeten nichts. Ein Knopf, der nichts tut, ist schlimmer
als kein Knopf: Man drueckt ihn wieder.
Die Antwort kommt aus DERSELBEN Funktion, die auch der
Anruf-Router benutzt. Zwei Rechnungen waeren die Stelle, an der
die Seite einen Knopf zeigt, den der Server ablehnt. */
darf_anrufen: darfTelefonieren(req.person),
});
} catch (fehler) {
console.error("[chat] Räume:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/** Ein Zweier-Gespräch öffnen (und beim ersten Mal anlegen). */
chatRouter.post("/workspace/api/chat/direkt", gleicheHerkunft, express.json({ limit: "8kb" }), (req, res) => {
try {
const mit = Number(req.body?.mit);
if (!Number.isInteger(mit) || mit < 1) return res.status(400).json({ fehler: "ungueltig" });
/* DIE REGEL SITZT HIER, nicht in der Oberfläche. Wer die Anfrage
von Hand baut, kommt damit keinen Schritt weiter. */
if (!darfSchreibenMit(req.person, mit)) {
return res.status(403).json({ fehler: "Mit dieser Person kannst du nicht schreiben." });
}
const ziel = db().prepare("SELECT id FROM personen WHERE id = ? AND aktiv = 1").get(mit);
if (!ziel) return res.status(404).json({ fehler: "nicht_gefunden" });
const raumId = direktRaum(req.person, mit);
res.json({ raum_id: raumId });
} catch (fehler) {
console.error("[chat] Direkt:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/** Eine Gruppe anlegen. Wer sie anlegt, führt sie. */
chatRouter.post("/workspace/api/chat/gruppe", gleicheHerkunft, express.json({ limit: "8kb" }), (req, res) => {
try {
const name = String(req.body?.name ?? "").trim();
if (name.length < 2) return res.status(400).json({ fehler: "Die Gruppe braucht einen Namen." });
if (name.length > NAME_MAX) return res.status(400).json({ fehler: "Der Name ist zu lang." });
const roh = Array.isArray(req.body?.mit) ? req.body.mit : [];
const mit = [...new Set(roh.map(Number).filter((n) => Number.isInteger(n) && n > 0))]
.filter((id) => id !== req.person.id);
/* JEDE Nummer einzeln gegen die Regel -- eine Gruppe ist kein
Schlupfloch, um jemanden zu erreichen, den man einzeln nicht
anschreiben dürfte. */
const verboten = mit.filter((id) => !darfSchreibenMit(req.person, id));
if (verboten.length) {
return res.status(403).json({ fehler: "Mit mindestens einer Person kannst du nicht schreiben." });
}
if (!mit.length) return res.status(400).json({ fehler: "Wähle mindestens eine Person aus." });
const d = db();
const n = jetzt();
d.prepare("INSERT INTO chat_raeume (art, name, erstellt, erstellt_von) VALUES ('gruppe',?,?,?)")
.run(name, n, req.person.id);
const raumId = d.prepare("SELECT last_insert_rowid() AS id").get().id;
d.prepare("INSERT INTO chat_teilnehmer (raum_id, person_id, seit, gelesen_bis, leitung) VALUES (?,?,?,0,1)")
.run(raumId, req.person.id, n);
const rein = d.prepare(
"INSERT INTO chat_teilnehmer (raum_id, person_id, seit, gelesen_bis) VALUES (?,?,?,0)");
for (const id of mit) {
if (d.prepare("SELECT 1 FROM personen WHERE id = ? AND aktiv = 1").get(id)) rein.run(raumId, id, n);
}
protokolliere("chat_gruppe_angelegt", {
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
detail: `#${raumId} ${name} (${mit.length + 1})`.slice(0, 120),
});
res.status(201).json({ raum_id: raumId });
} catch (fehler) {
console.error("[chat] Gruppe:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* =====================================================================
EINEN KANAL ANLEGEN (10.09.2026, Kapitel 7.2)
Kein Name im Rumpf, nur die Kategorie -- siehe kanalName(). Und keine
Pflicht, gleich jemanden hineinzusetzen: Ein Kanal, den DogFather
morgens anlegt und mittags fuellt, ist ein normaler Vorgang; ihn
dafuer zweimal aufmachen zu muessen waere eine Regel ohne Zweck.
===================================================================== */
chatRouter.post("/workspace/api/chat/kanal", gleicheHerkunft, express.json({ limit: "8kb" }), (req, res) => {
try {
/* 404 und nicht 403: Wer keine Kanaele fuehren darf, soll auch
nicht erfahren, dass es die Moeglichkeit gibt. */
if (!fuehrtTeamDogi(req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
const kategorie = String(req.body?.kategorie ?? "").trim();
if (!MODI_KATEGORIEN.some((k) => k.wert === kategorie)) {
return res.status(400).json({ fehler: "Unbekannte Kategorie." });
}
const d = db();
/* Die Regel steht hier UND als eindeutiger Index in der Datenbank.
Doppelt gemoppelt ist es nicht: Hier gibt es eine Meldung, die
jemand lesen kann, und dort eine Zusage, die auch dann gilt, wenn
einmal zwei Anfragen im selben Augenblick ankommen. */
const schon = d.prepare("SELECT id FROM chat_raeume WHERE art = 'kanal' AND kategorie = ?")
.get(kategorie);
if (schon) {
return res.status(409).json({ fehler: "Diesen Kanal gibt es schon.", raum_id: schon.id });
}
const roh = Array.isArray(req.body?.mit) ? req.body.mit : [];
const mit = [...new Set(roh.map(Number).filter((n) => Number.isInteger(n) && n > 0))]
.filter((id) => id !== req.person.id);
/* Jede Nummer einzeln gegen dieselbe Regel wie bei einer Gruppe.
Ein Kanal ist kein Schlupfloch, um jemanden zu erreichen, den man
einzeln nicht anschreiben duerfte. */
if (mit.some((id) => !darfSchreibenMit(req.person, id))) {
return res.status(403).json({ fehler: "Mit mindestens einer Person kannst du nicht schreiben." });
}
/* UND SIE MUESSEN ZU TEAM DOGI GEHOEREN (22.09.2026, VanVans
Befund). `darfSchreibenMit` beantwortet eine andere Frage --
"darf ich diesen Menschen ueberhaupt anschreiben" --, und die
sagt bei einem Scout zu Recht ja. Ein Kanal ueber
Chat-Moderation ist trotzdem kein Ort fuer ihn. Genau diese
Luecke hat die zwei Scouts in den Moderations-Kanal gebracht. */
if (mit.some((id) => !gehoertInKanal(id))) {
return res.status(403).json({
fehler: "In einen Kanal gehören nur Leute aus Team Dogi." });
}
const n = jetzt();
d.prepare(`INSERT INTO chat_raeume (art, name, kategorie, erstellt, erstellt_von)
VALUES ('kanal',?,?,?,?)`)
.run(kanalName(kategorie), kategorie, n, req.person.id);
const raumId = d.prepare("SELECT last_insert_rowid() AS id").get().id;
/* DIE GANZE TEAMFUEHRUNG KOMMT HINEIN, nicht nur der Anlegende.
kanaeleAngleichen() wuerde das beim naechsten Blick in die Liste
ohnehin nachholen -- aber "beim naechsten Blick" heisst: Die
rechte Hand sieht den Kanal erst, wenn sie die Seite neu laedt.
Hier ist er sofort da. */
const fuehrung = d.prepare(
"SELECT id FROM personen WHERE aktiv = 1 AND rolle IN ('admin','hand')").all().map((z) => z.id);
const reinLeitung = d.prepare(
"INSERT INTO chat_teilnehmer (raum_id, person_id, seit, gelesen_bis, leitung) VALUES (?,?,?,0,1)");
for (const id of new Set([req.person.id, ...fuehrung])) reinLeitung.run(raumId, id, n);
const rein = d.prepare(
"INSERT INTO chat_teilnehmer (raum_id, person_id, seit, gelesen_bis) VALUES (?,?,?,0)");
let drin = 0;
for (const id of mit) {
if (fuehrung.includes(id)) continue; /* steht schon als Leitung drin */
if (d.prepare("SELECT 1 FROM personen WHERE id = ? AND aktiv = 1").get(id)) {
rein.run(raumId, id, n); drin++;
}
}
protokolliere("chat_kanal_angelegt", {
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
detail: `#${raumId} ${kategorie} (${drin})`.slice(0, 120),
});
res.status(201).json({ raum_id: raumId, name: kanalName(kategorie) });
} catch (fehler) {
console.error("[chat] Kanal:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* =====================================================================
WER IST IM KANAL (10.09.2026)
Ohne diese Route waere ein Kanal beim Anlegen fuer immer festgelegt:
Ein neuer Modi koennte nie in "Clipping" -- der Kanal waere richtig
gebaut und trotzdem unbrauchbar.
ENTFERNT WIRD MIT `raus_am`, nicht mit DELETE. Wer draussen ist,
schreibt und liest nichts Neues mehr; der Verlauf bis dahin bleibt
aber lesbar, und niemand verschwindet rueckwirkend aus der
Geschichte. Dieselbe Entscheidung wie bei den Gruppen.
===================================================================== */
chatRouter.put("/workspace/api/chat/kanal/:id/mitglieder", gleicheHerkunft,
express.json({ limit: "8kb" }), (req, res) => {
try {
if (!fuehrtTeamDogi(req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
const raumId = Number(req.params.id);
if (!Number.isInteger(raumId)) return res.status(400).json({ fehler: "ungueltig" });
const d = db();
const raum = d.prepare("SELECT id, art FROM chat_raeume WHERE id = ?").get(raumId);
/* Ausdruecklich nur Kanaele. Diese Route auf Gruppen loszulassen
hiesse, dass die Teamfuehrung fremde Gruppen umbesetzen kann --
etwas voellig anderes, und niemand hat darum gebeten. */
if (!raum || raum.art !== "kanal") return res.status(404).json({ fehler: "nicht_gefunden" });
const roh = Array.isArray(req.body?.mit) ? req.body.mit : [];
const soll = new Set(roh.map(Number).filter((n) => Number.isInteger(n) && n > 0));
if ([...soll].some((id) => !darfSchreibenMit(req.person, id))) {
return res.status(403).json({ fehler: "Mit mindestens einer Person kannst du nicht schreiben." });
}
/* DIESELBE SCHRANKE WIE BEIM ANLEGEN. Ohne sie waere die Regel
eine Tuer mit zwei Eingaengen, von denen nur einer ein Schloss
hat -- und der ohne Schloss ist der, den man haeufiger
benutzt. */
if ([...soll].some((id) => !gehoertInKanal(id))) {
return res.status(403).json({
fehler: "In einen Kanal gehören nur Leute aus Team Dogi." });
}
/* Die Teamfuehrung bleibt unangetastet -- sie hat laut Kapitel 7.2
Zugriff auf alle Kanaele. Sie aus der Liste entfernen zu koennen
waere eine Tuer, die man hinter sich zuzieht: istDrin() liesse
sie zwar weiter hinein, in der Gespraechsliste stuende der Kanal
aber nicht mehr. */
const fuehrung = new Set(d.prepare(
"SELECT id FROM personen WHERE rolle IN ('admin','hand')").all().map((z) => z.id));
const ist = d.prepare(
"SELECT person_id FROM chat_teilnehmer WHERE raum_id = ? AND raus_am IS NULL")
.all(raumId).map((z) => z.person_id).filter((id) => !fuehrung.has(id));
const n = jetzt();
/* WER HEUTE DAZUKOMMT, HAT NICHTS VERPASST. Ohne diesen Stand
staende beim ersten Oeffnen eine rote Zahl ueber allem, was das
Team je in diesem Kanal geschrieben hat -- lesbar ist es
weiterhin, ungelesen war es nie. */
const hoechste = d.prepare(
"SELECT COALESCE(MAX(id), 0) AS m FROM chat_nachrichten WHERE raum_id = ?").get(raumId).m;
let dazu = 0, raus = 0;
for (const id of soll) {
if (fuehrung.has(id) || ist.includes(id)) continue;
if (!d.prepare("SELECT 1 FROM personen WHERE id = ? AND aktiv = 1").get(id)) continue;
/* Zurueckgeholt oder neu -- eine Zeile kann es schon geben (mit
raus_am). Ein blankes INSERT liefe dann auf den
Primaerschluessel auf. */
const wieder = d.prepare(
"SELECT 1 FROM chat_teilnehmer WHERE raum_id = ? AND person_id = ?").get(raumId, id);
if (wieder) {
d.prepare("UPDATE chat_teilnehmer SET raus_am = NULL, seit = ? WHERE raum_id = ? AND person_id = ?")
.run(n, raumId, id);
} else {
d.prepare(`INSERT INTO chat_teilnehmer (raum_id, person_id, seit, gelesen_bis)
VALUES (?,?,?,?)`).run(raumId, id, n, hoechste);
}
dazu++;
}
for (const id of ist) {
if (soll.has(id)) continue;
d.prepare("UPDATE chat_teilnehmer SET raus_am = ? WHERE raum_id = ? AND person_id = ?")
.run(n, raumId, id);
raus++;
}
if (dazu || raus) {
protokolliere("chat_kanal_besetzung", {
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
detail: `#${raumId} +${dazu} -${raus}`,
});
}
res.json({ ok: true, dazu, raus, teilnehmer: teilnehmerVon(raumId).map((t) => t.id) });
} catch (fehler) {
console.error("[chat] Kanal-Besetzung:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/** Der Verlauf eines Gesprächs. */
chatRouter.get("/workspace/api/chat/raeume/:id/nachrichten", (req, res) => {
try {
const raumId = Number(req.params.id);
if (!Number.isInteger(raumId)) return res.status(400).json({ fehler: "ungueltig" });
/* Was man nicht sehen darf, existiert nicht -- 404 statt 403,
sonst liesse sich durch Ausprobieren herausfinden, welche
Gespräche es gibt. */
if (!istDrin(raumId, req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
/* Nur die letzten 200. Ein Gespräch, das ein Jahr läuft, soll den
Browser nicht mit zehntausend Zeilen bewerfen; ältere holt man
über `vor`. */
const vor = Number(req.query.vor) || 0;
/* MIT DEM ZITAT IN EINER ABFRAGE (09.09.2026, Punkt 15).
Der zweite Verbund holt die Nachricht, auf die geantwortet
wurde. Sie einzeln nachzuladen waere je Antwort eine weitere
Abfrage -- bei 200 Zeilen im schlimmsten Fall 200 Stueck.
`LEFT` und nicht `INNER`: Die meisten Nachrichten sind keine
Antworten, und die duerfen nicht verschwinden. */
/* WAS ICH WEGGERÄUMT HABE, KOMMT NICHT ZURÜCK. Die Grenze steht im
WHERE und nicht in einem Filter danach -- sonst wäre sie eine
Zeile davon entfernt, beim nächsten Umbau vergessen zu werden. */
const weg = geloeschtBis(raumId, req.person.id);
const reihen = db().prepare(`
SELECT n.id, n.person_id, n.text, n.erstellt, n.weg_am, p.name AS von, p.rolle,
p.bild AS von_bild, p.chat_kachel AS von_kachel,
n.antwort_auf, n.angeheftet_am, n.rudel,
n.anhang_name, n.anhang_art, n.anhang_typ, n.anhang_groesse,
n.anhang_breite, n.anhang_hoehe, n.anhang_dauer,
a.text AS zitat_text, a.weg_am AS zitat_weg, ap.name AS zitat_von,
a.anhang_art AS zitat_anhang
FROM chat_nachrichten n
LEFT JOIN personen p ON p.id = n.person_id
LEFT JOIN chat_nachrichten a ON a.id = n.antwort_auf AND a.raum_id = n.raum_id
LEFT JOIN personen ap ON ap.id = a.person_id
WHERE n.raum_id = ? AND n.id > ? ${vor ? "AND n.id < ?" : ""}
ORDER BY n.id DESC LIMIT 200`).all(...(vor ? [raumId, weg, vor] : [raumId, weg]));
/* DER GELESEN-STAND, BEVOR ER GESETZT WIRD.
Die Oberflaeche zieht daraus die Linie "ab hier ist es neu". Sie
muss ihn deshalb beim OEFFNEN bekommen -- eine Zeile spaeter
(nach dem PUT auf /gelesen) waere er immer die letzte Nachricht,
und die Linie staende nie irgendwo. */
const gelesenBis = db().prepare(
"SELECT gelesen_bis FROM chat_teilnehmer WHERE raum_id = ? AND person_id = ?")
.get(raumId, req.person.id)?.gelesen_bis ?? 0;
const raum = db().prepare(
"SELECT id, art, name, kategorie, erstellt_von FROM chat_raeume WHERE id = ?").get(raumId);
const leute = teilnehmerVon(raumId);
/* DIE ANGEHEFTETEN, in einer eigenen Abfrage.
Sie MUESSEN getrennt geholt werden: Der Verlauf oben liefert nur
die letzten 200 Zeilen. Eine Ankuendigung von vorletzter Woche
faellt da heraus -- und waere damit ausgerechnet dann verschwunden,
wenn sie am laengsten oben stehen sollte.
DIESELBEN ZWEI GRENZEN WIE DER VERLAUF: `n.id > weg` (was ich
weggeraeumt habe, kommt nicht ueber die Hintertuer zurueck) und
`weg_am IS NULL` (eine zurueckgenommene Nachricht bleibt
zurueckgenommen, auch als Aushang). */
const weggeraeumt = weg;
const angeheftet = db().prepare(`
SELECT n.id, n.text, n.erstellt, n.angeheftet_am, n.anhang_art,
p.name AS von, q.name AS heftete
FROM chat_nachrichten n
LEFT JOIN personen p ON p.id = n.person_id
LEFT JOIN personen q ON q.id = n.angeheftet_von
WHERE n.raum_id = ? AND n.angeheftet_am IS NOT NULL
AND n.weg_am IS NULL AND n.id > ?
ORDER BY n.angeheftet_am DESC LIMIT ?`).all(raumId, weggeraeumt, PIN_MAX);
res.json({
raum: {
id: raum.id, art: raum.art, kategorie: raum.kategorie || null,
name: raumName(raum, leute, req.person.id),
teilnehmer: leute.map((t) => ({ id: t.id, name: t.name, rolle: t.rolle,
bild: t.bild, leitung: !!t.leitung })),
/* Dasselbe Feld wie in der Liste, aus derselben Regel. Die
Oberflaeche nimmt den offenen Raum von HIER -- ohne diese
Zeile blieb der Aufloesen-Knopf unsichtbar, obwohl das Recht
da war. */
darf_aufloesen: darfAufloesen(raum, req.person),
},
gelesen_bis: gelesenBis,
/* OB DER KNOPF UEBERHAUPT ERSCHEINT, entscheidet der Server.
Die Oberflaeche koennte `rolle === 'admin'` vergleichen -- aber
assets/js/chat.js bekommt jeder, der die Seite oeffnet. Ein
Ja/Nein verraet nichts ueber die Rollen dahinter. */
darf_anheften: darfAnheften(req.person, raumId),
/* WER JEDE NACHRICHT LOESCHEN DARF -- vom Server, nicht aus
der Rolle im Browser geraten. assets/js/chat.js bekommt
JEDER, der die Seite oeffnet; ein `rolle === 'hand'` darin
waere eine Auskunft ueber das Haus an jeden Leser. Und es
waere eine zweite Wahrheit neben der Schranke im Server. */
darf_alles_loeschen: darfJedeNachrichtLoeschen(req.person),
/* DARF ICH DAS RUDEL RUFEN? (23.09.2026)
Vom Server, aus derselben Funktion wie die Schranke beim
Schreiben (istTeamDogi). Die Oberflaeche koennte
`ich.rolle === 'modi' || ...` vergleichen -- das waere eine
zweite Wahrheit, und assets/js/chat.js bekommt jeder, der die
Seite oeffnet. Ein Ja/Nein verraet nichts ueber das Haus.
DAS WORT KOMMT MIT. Stuende "rudel" im Browser fest, hiesse es
nach einer Umbenennung an einer Stelle anders als an der
anderen -- und der Vorschlag beim Tippen setzte etwas ein, das
der Server nicht mehr erkennt. */
/* UND OB ER HIER ueberhaupt jemanden erreichen wuerde. In einem
Zweier-Gespraech mit einem Creator ist ausser mir niemand aus
dem Team -- der Vorschlag "rudel, alle im Team" waere dort ein
Eintrag, der nichts tut. Dieselbe Ueberlegung wie beim eigenen
Namen, den die Liste auch nicht anbietet.
DIE SCHRANKE BEIM SCHREIBEN HAENGT NICHT DARAN. Wer den Ruf
von Hand tippt, ruft eben niemanden -- genau wie ein "@Anna",
das Anna nicht beantwortet. Verboten ist es nicht, es ist nur
keine Hilfe, es vorzuschlagen. */
/* WEN DER VORSCHLAG ERREICHT, HAENGT AM RAUM -- und die
Schranke davor muss dieselbe Frage stellen.
Sonst entsteht ein stiller Widerspruch: Sitzt im Rudel-Raum
ein Modi mit neun Zuschauern, aber ohne zweites Teammitglied,
dann traefe "@rudel" jetzt neun Leute -- der Vorschlag beim
Tippen waere aber ausgeblendet, weil er nach einem zweiten
Teammitglied sucht. Die Funktion gaebe es, und niemand faende
sie. Also wird hier genau das gefragt, was der Ruf nachher
auch tut. */
darf_rudel: istTeamDogi(req.person)
&& (istTreffRaum(raumId)
? leute.some((t) => t.id !== req.person.id)
: leute.some((t) => t.id !== req.person.id && istTeamDogi(t))),
rudel_wort: RUDEL_WORT,
/* UND WEN ER MEINT, IN WORTEN.
Der Browser koennte die Kategorie des Raums vergleichen --
dann stuende die Regel an zwei Stellen und liefe irgendwann
auseinander. Er bekommt stattdessen die Antwort: "raum" oder
"team". Die Worte dazu bildet er selbst, damit deutscher Text
nicht im Server liegt. */
rudel_wen: istTreffRaum(raumId) ? "raum" : "team",
/* DARF ICH SPRACHNACHRICHTEN SCHICKEN? (23.09.2026)
Aus derselben Funktion wie die Schranke in der Anhang-Route.
Der Browser vergleicht keine Rollen -- assets/js/chat.js
bekommt jeder, der die Seite oeffnet.
ANDERS ALS BEIM RUDEL HAENGT ES NICHT AM RAUM: Eine
Sprachnachricht an einen Creator ist eine Sprachnachricht an
einen Creator; sie erreicht ihn. Der Ruf ans Rudel erreicht in
so einem Raum niemanden -- deshalb dort die zweite Bedingung
und hier nicht. */
darf_ton: istTeamDogi(req.person),
/* DIE GIF-KISTE, aus derselben Regel. Filipes „also nur" stand
im selben Satz wie die Sprachnachrichten. */
darf_gif: istTeamDogi(req.person),
angeheftet: angeheftet.map((a) => ({
id: a.id,
von: a.von || "Gelöscht",
heftete: a.heftete || null,
seit: a.angeheftet_am,
text: String(a.text || "").slice(0, 200)
|| anhangWort(a.anhang_art),
})),
/* Aufsteigend zurück -- gelesen wird von oben nach unten. */
/* Die Reaktionen in EINER Abfrage fuer alle Nachrichten -- nicht
je Zeile eine. Bei 200 Zeilen waeren das 200 Abfragen fuer eine
Ansicht, die man beim Scrollen staendig neu holt. */
nachrichten: (() => {
const gedreht = reihen.reverse();
const reakt = reaktionenZu(gedreht.map((n) => n.id), req.person.id);
return gedreht.map((n) => ({
reaktionen: reakt.get(n.id) || [],
id: n.id, von_id: n.person_id, von: n.von || "Gelöscht", rolle: n.rolle,
von_bild: n.von_bild ? `/workspace/api/steckbrief/bild/${n.von_bild}` : null,
/* DIE EIGENE KACHELFARBE (20.09.2026).
Filipe: "jeder account soll seine kachel personalisieren
koennen."
Sie kommt aus `personen`, nicht aus der Nachricht: Wer seine
Farbe aendert, aendert sie fuer ALLE seine Nachrichten,
auch die von gestern. Die Farbe an jede Zeile zu schreiben
waere eine zweite Wahrheit -- und nach der ersten Aenderung
haette dieselbe Person zwei Farben im selben Gespraech. */
/* Eigene Wahl, sonst die automatische -- dieselbe Regel wie
ueberall, damit eine Person in jeder Liste gleich aussieht. */
von_kachel: kachelPruefen(n.von_kachel) || autoKachelFuer(n.person_id),
text: n.weg_am ? null : n.text,
zurueckgenommen: !!n.weg_am,
erstellt: n.erstellt,
selbst: n.person_id === req.person.id,
angeheftet: !!n.angeheftet_am,
/* WURDE HIER DAS RUDEL GERUFEN? Steht an der Nachricht, weil
der Browser sonst die damalige Rolle des Absenders kennen
muesste -- siehe die Spalte in workspace.js. */
rudel: !!n.rudel,
/* Das Zitat wird GEKUERZT geschickt, nicht ganz: Es ist ein
Hinweis auf die Stelle, nicht ihre Wiederholung. Und eine
zurueckgenommene Nachricht bleibt auch im Zitat
zurueckgenommen -- sonst waere das Zuruecknehmen ueber ein
Zitat zu umgehen. */
antwort: n.antwort_auf ? {
id: n.antwort_auf,
von: n.zitat_von || "Gelöscht",
text: n.zitat_weg ? null
: (String(n.zitat_text || "").slice(0, 140)
|| anhangWort(n.zitat_anhang)),
zurueckgenommen: !!n.zitat_weg,
} : null,
/* Der Anhang wird als fertige ADRESSE geliefert, nicht als
Dateiname. Sonst setzt jede Stelle im Browser denselben Pfad
zusammen -- und eine davon setzt ihn irgendwann anders. */
anhang: (!n.weg_am && n.anhang_art) ? {
art: n.anhang_art, typ: n.anhang_typ,
name: n.anhang_name, groesse: n.anhang_groesse,
breite: n.anhang_breite || 0, hoehe: n.anhang_hoehe || 0,
dauer: n.anhang_dauer || 0,
weg: `/workspace/api/chat/anhang/${n.id}`,
} : null,
}));
})(),
});
} catch (fehler) {
console.error("[chat] Verlauf:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/** Etwas schreiben. */
chatRouter.post("/workspace/api/chat/raeume/:id/nachrichten", gleicheHerkunft,
express.json({ limit: "16kb" }), async (req, res) => {
try {
const raumId = Number(req.params.id);
if (!Number.isInteger(raumId)) return res.status(400).json({ fehler: "ungueltig" });
if (!istDrin(raumId, req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
/* ==== DIE NACHTRUHE ==============================================
Filipe: "quasi nach mitternacht bis morgens 6 uhr keiner
schreiben kann damit auch die privatsphaere beruecksichtig
wird ueber nacht."
SIE STEHT HIER UND NICHT NUR IM BROWSER. Ein ausgegrauter
Knopf ist eine Bitte; abgelehnt wird erst hier. Wer die
Schnittstelle direkt anspricht -- und das kann jeder, der die
Adresse kennt --, kaeme sonst durch.
SIE GILT FUER ALLE, AUCH FUER DIE LEITUNG. Eine Nachtruhe, von
der DogFather ausgenommen waere, ist keine: Wenn er um halb
vier schreibt, liest es jemand, und wer es liest, fuehlt sich
zustaendig. Genau den Druck soll sie wegnehmen.
NUR IM TREFF. Das Team hat keine Nachtruhe im Chat -- dort
arbeiten Leute nachts, das ist der Beruf. Hier geht es um
Zuschauer und um die, die sie betreuen.
MODERIEREN GEHT WEITER: Verbergen, loeschen, jemanden
herausnehmen sind keine Nachrichten und laufen ueber andere
Wege. Wer nachts etwas Schlimmes sieht, kann es wegnehmen --
er kann nur nicht darueber diskutieren. */
if (istTreffRaum(raumId) && istNachtruhe()) {
const stand = nachtruheStand();
return res.status(403).json({
fehler: stand.satz, nachtruhe: stand,
});
}
const text = String(req.body?.text ?? "").trim();
if (!text) return res.status(400).json({ fehler: "leer" });
if (text.length > TEXT_MAX) {
return res.status(400).json({ fehler: `Länger als ${TEXT_MAX} Zeichen geht nicht.` });
}
/* WORAUF GEANTWORTET WIRD, MUSS IN DEMSELBEN RAUM LIEGEN.
Ohne diese Pruefung koennte jemand die Kennung einer Nachricht
aus einem fremden Gespraech mitschicken -- und beim Empfaenger
stuende ein Zitat aus einem Raum, den er nie gesehen hat. Die
Abfrage bindet deshalb `raum_id` mit ein; passt es nicht, wird
das Zitat still weggelassen statt die Nachricht abzulehnen.
Der Text ist das Wichtige, das Zitat die Zugabe. */
let antwortAuf = Number(req.body?.antwort_auf) || null;
if (antwortAuf) {
const da = db().prepare(
"SELECT 1 FROM chat_nachrichten WHERE id = ? AND raum_id = ?").get(antwortAuf, raumId);
if (!da) antwortAuf = null;
}
const d = db();
const n = jetzt();
d.prepare("INSERT INTO chat_nachrichten (raum_id, person_id, text, erstellt, antwort_auf) VALUES (?,?,?,?,?)")
.run(raumId, req.person.id, text, n, antwortAuf);
const id = d.prepare("SELECT last_insert_rowid() AS id").get().id;
d.prepare("UPDATE chat_raeume SET letzte_am = ? WHERE id = ?").run(n, raumId);
/* Wer schreibt, hat das Eigene gelesen. */
d.prepare("UPDATE chat_teilnehmer SET gelesen_bis = ? WHERE raum_id = ? AND person_id = ?")
.run(id, raumId, req.person.id);
const zitat = antwortAuf ? d.prepare(`
SELECT a.text, a.weg_am, p.name AS von FROM chat_nachrichten a
LEFT JOIN personen p ON p.id = a.person_id WHERE a.id = ?`).get(antwortAuf) : null;
const nachricht = {
id, raum_id: raumId, von_id: req.person.id, von: req.person.name,
/* DAS BILD MUSS MIT (20.09.2026). Der Verlauf beim Laden bringt
`von_bild` mit -- diese Nachricht hier nicht, und sie ist die,
die per Ereignisstrom bei allen anderen ankommt. Folge: Wer
gerade zusieht, bekommt einen Buchstaben; wer die Seite neu
laedt, ein Gesicht. Derselbe Mensch, zwei Darstellungen, und
der Unterschied haengt nur daran, wann man geschaut hat. */
von_bild: bildWegFuer(req.person.id),
/* Auch hier -- sonst kaeme die frisch gesendete Nachricht ohne
Farbe bei den anderen an und faerbte sich erst beim naechsten
Laden. Derselbe Fehler wie beim Bild eine Zeile darueber. */
von_kachel: kachelFuer(req.person.id),
rolle: req.person.rolle, text, erstellt: n, zurueckgenommen: false,
antwort: zitat ? {
id: antwortAuf, von: zitat.von || "Gelöscht",
text: zitat.weg_am ? null : String(zitat.text || "").slice(0, 140),
zurueckgenommen: !!zitat.weg_am,
} : null,
anhang: null,
/* Wird gleich gesetzt, wenn das Rudel gerufen wurde. Steht
hier schon drin, damit das Feld in JEDER Nachricht vorkommt
-- eine Eigenschaft, die mal da ist und mal nicht, ist die,
die im Browser irgendwann `undefined` heisst. */
rudel: false,
};
/* ==== WER IST MIT "@" GEMEINT? (20.09.2026) =====================
Aufgeloest wird HIER, gegen die Teilnehmer DIESES Raums -- nicht
im Browser. Der Browser schickt nur Text. Wer daraus eine
Person wird, entscheidet der Server, und damit gilt:
* Ein von Hand getipptes "@Anna" wirkt genauso wie eines aus
der Auswahlliste. Wer schnell schreibt, soll nicht bestraft
werden.
* Niemand kann jemanden ansprechen, der gar nicht im Raum
sitzt -- auch nicht, indem er die Schnittstelle direkt
anspricht.
Die Regeln stehen in chat-erwaehnung.js, samt Begruendung je
Regel. Sie sind bewusst ohne Abhaengigkeiten, damit die
Pruefung sie lesen kann, ohne einen Server hochzufahren. */
/* ==== "@RUDEL" -- ALLE AUF EINMAL (23.09.2026) =================
Filipe: „dan will ich auch dass nur die modis, rechte hand,
linke hand und dogfather, alle auch auf einmal markieren
koennen im chat mit einem, @rudel ,dann sollen alle eine
benarichtigung bekommen."
WER DARF, WIRD HIER ENTSCHIEDEN -- nicht im Browser und nicht
in chat-erwaehnung.js. Der Browser schickt nur Text; die Regeln
haben keine Abhaengigkeiten und sollen keine bekommen. Bleibt
diese Stelle, und sie fragt die eine Funktion des Hauses:
istTeamDogi(). Schreibt ein Creator "@rudel", passiert nichts
-- kein Ruf, kein Eintrag, keine Hervorhebung. */
const darfRudel = istTeamDogi(req.person);
const alleLeute = teilnehmerVon(raumId);
const rudel = rudelGerufen(text, alleLeute, { rudel: darfRudel });
/* WEN DER RUF ERREICHT -- und das haengt vom RAUM ab.
Bis zum 23.09.2026 galt ueberall dasselbe: Der Ruf erreichte
nur die aus Team Dogi. Die Begruendung stand hier und war
nicht falsch -- im Treff sitzt die Community, und "@rudel"
haette dort jeden geweckt.
GENAU DAS WILL FILIPE JETZT, und zwar ausdruecklich nur dort:
"wenn wir da im chat @rudel machen will ich dass jeder in dem
chat markiert wird. nicht nur team ... und sehr wichtig ich
rede nur von dem chat wo die ganze community auch drin ist.
sonst nichts anfassen."
Also zwei Bedeutungen, nach Raum getrennt:
im Rudel-Raum -> ALLE, die drin sind. Der Raum IST das
Rudel; er heisst auch so.
ueberall sonst -> Team Dogi, wie bisher. Ein Gruppenchat
mit drei Creatorinnen bleibt unberuehrt.
WAS DIE ALTE SORGE ENTSCHAERFT, und warum das hier tragbar
ist: RUFEN darf weiterhin nur Team Dogi (siehe darfRudel eine
Zeile hoeher) -- kein Zuschauer kann alle wecken. Und die
Nachtruhe gilt in diesem Raum ohnehin, der Ruf kommt also
nicht um drei Uhr nachts. Bleibt die eine Stelle, an der man
hinsehen muss: Waechst der Raum auf Hunderte, unterbricht ein
Ruf sie alle. Das steht im Protokoll (chat_rudel mit Anzahl),
damit es eine Zahl bleibt und kein Gefuehl. */
const ausDemRudel = !rudel ? []
: istTreffRaum(raumId)
? alleLeute.map((t) => t.id)
: alleLeute.filter((t) => istTeamDogi(t)).map((t) => t.id);
const erwaehnt = [...new Set([
...erwaehnteIds(text, alleLeute, { rudel: darfRudel }),
...ausDemRudel,
])]
/* SICH SELBST ANSPRECHEN LOEST NICHTS AUS. Man schreibt den
eigenen Namen durchaus ("@Anna hat recht, ich auch") -- eine
Meldung an sich selbst waere Unsinn. Beim Rudel genauso: Wer
das Team ruft, ruft nicht sich. */
.filter((pid) => pid !== req.person.id);
if (erwaehnt.length) {
const einf = d.prepare(
"INSERT OR IGNORE INTO chat_erwaehnungen (nachricht_id, person_id) VALUES (?,?)");
for (const pid of erwaehnt) einf.run(id, pid);
}
if (rudel) {
/* DIE NACHRICHT MERKT SICH, DASS DAS RUDEL GERUFEN WURDE.
Daraus entsteht beim Lesen die Hervorhebung -- ohne dass der
Browser die Rolle des Absenders von damals nachschlagen
muesste. Begruendung steht bei der Spalte in workspace.js. */
d.prepare("UPDATE chat_nachrichten SET rudel = 1 WHERE id = ?").run(id);
nachricht.rudel = true;
/* INS PROTOKOLL. Ein Ruf ans ganze Team ist der eine Handgriff
im Chat, der alle gleichzeitig unterbricht. Wer ihn benutzt,
soll das nicht heimlich tun koennen -- nicht als Misstrauen,
sondern weil "@rudel wird zu oft benutzt" sonst ein Gefuehl
bleibt statt einer Zahl. */
protokolliere("chat_rudel", {
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
detail: `#${id} an ${erwaehnt.length} im Raum ${raumId}`.slice(0, 120),
});
}
/* Sofort an alle, die gerade zusehen -- und per Benachrichtigung
an die, die es nicht tun. Beides läuft über chatEreignis(),
damit die Entscheidung "wer bekommt was" an einer Stelle steht.
Auch die Erwaehnung: Sie ist keine ZWEITE Meldung, sondern eine
ANDERE -- wer angesprochen wurde, bekommt statt "Nachricht von
Anna" ein "Anna hat dich erwaehnt". Zwei Meldungen fuer eine
Nachricht waeren der schnellste Weg, dass jemand beide
abschaltet. */
const empfaenger = alleLeute.filter((t) => t.id !== req.person.id);
chatEreignis(raumId, nachricht, empfaenger.map((t) => t.id), "neu",
new Set(erwaehnt), rudel);
res.status(201).json({ nachricht });
} catch (fehler) {
console.error("[chat] Schreiben:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* =====================================================================
ANHÄNGE: FOTOS UND PDF (09.09.2026)
Filipe: "am besten wäre es auch wenn man da auch im chat pdfs
schicken könnte. pdfs und fotos."
Wer im Gespräch schreiben darf, darf auch etwas schicken -- auch
Creator. Das ist ausdrücklich ANDERS als in der Dateiablage, wo
Creator nicht hochladen dürfen: Dort landet etwas in einem Bereich,
den mehrere sehen; hier bekommt es genau der, mit dem man ohnehin
gerade spricht. Ein Creator, der seinem Scout einen Screenshot
schicken will, soll das können.
DER RUMPF WIRD ERST ANGENOMMEN, WENN DIE BERECHTIGUNG STEHT. Die
Mitgliedschaft wird VOR express.raw geprüft -- sonst wanderten
zwölf Megabyte durch die Leitung, nur um danach verworfen zu
werden, und jeder Angemeldete könnte damit an jeder Raumnummer
Speicher verbrauchen.
===================================================================== */
/** Vor express.raw: Bin ich in diesem Raum? */
function drinFuerAnhang(req, res, next) {
const raumId = Number(req.params.id);
if (!Number.isInteger(raumId)) return res.status(400).json({ fehler: "ungueltig" });
if (!istDrin(raumId, req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
next();
}
chatRouter.post("/workspace/api/chat/raeume/:id/anhang",
gleicheHerkunft,
drinFuerAnhang,
express.raw({ type: "*/*", limit: ANHANG_MAX }),
(req, res) => {
try {
const raumId = Number(req.params.id);
/* DIE NACHTRUHE GILT AUCH FUER ANHAENGE. Sie nur beim Text zu
pruefen hiesse, dass man nachts zwar nicht schreiben, aber ein
Foto mit Bildunterschrift schicken kann -- der Weg, den jeder
findet, der es einmal versucht. */
if (istTreffRaum(raumId) && istNachtruhe()) {
const stand = nachtruheStand();
return res.status(403).json({ fehler: stand.satz, nachtruhe: stand });
}
if (!Buffer.isBuffer(req.body) || !req.body.length) {
return res.status(400).json({ fehler: "Keine Datei empfangen." });
}
/* DER TYP KOMMT AUS DEM INHALT, nicht aus dem Namen und nicht aus
dem Content-Type. Siehe dateiErkennen(). */
const erkannt = dateiErkennen(req.body);
if (!erkannt) {
return res.status(415).json({
fehler: "Das geht nicht – erlaubt sind Fotos (PNG, JPEG, WebP, GIF), PDF und Sprachnachrichten.",
});
}
/* ==== SPRACHNACHRICHTEN SIND NICHT FUER ALLE (23.09.2026) =====
Filipe: „dan will ich auch dass man im chat auch
sprachnachrichten und gifts reinschicken kann. also nur die
modis rechte linke hand und dogfather."
Das „also nur" ist der Punkt. Fotos und PDF darf jeder
schicken, auch Creator -- das steht als Entscheidung im
Kommentar ueber dieser Route und bleibt. Ton nicht.
HIER UND NICHT NUR IM BROWSER. Ein ausgeblendeter Knopf ist
eine Bitte; abgelehnt wird erst an dieser Stelle. Dieselbe
Ueberlegung wie bei der Nachtruhe zwanzig Zeilen darueber. */
if (erkannt.art === "ton" && !istTeamDogi(req.person)) {
return res.status(403).json({
fehler: "Sprachnachrichten schicken nur Team Dogi und DogFather.",
});
}
if (erkannt.art === "ton" && req.body.length > TON_MAX) {
return res.status(413).json({
fehler: `Die Sprachnachricht ist zu lang – erlaubt sind ${Math.round(TON_MAX / 1048576)} MB.`,
});
}
/* WIE LANG SIE IST, SAGT DER ABSENDER -- und das ist eine
Behauptung, keine Messung. Sie steht nur in der Vorschau, bis
das Abspielgeraet die wahre Laenge kennt. Begrenzt wird sie
trotzdem: Ohne Obergrenze stuende in der Gespraechsliste
„Sprachnachricht (999:59)", und die Liste saehe kaputt aus. */
let dauer = null;
if (erkannt.art === "ton") {
const roh = Number.parseInt(req.get("x-dauer") || "", 10);
dauer = Number.isFinite(roh) && roh > 0 ? Math.min(roh, 60 * 60 * 1000) : null;
}
let begleittext = "";
try { begleittext = decodeURIComponent(req.get("x-text") || ""); } catch { begleittext = ""; }
begleittext = begleittext.trim().slice(0, TEXT_MAX);
const name = anhangName(req.get("x-dateiname"), erkannt.endung);
/* Die Endung auf der Platte kommt aus der ERKENNUNG, nicht aus dem
eingeschickten Namen. Damit kann dort nichts liegen, das anders
heisst, als es ist. */
mkdirSync(ANHANG_ORDNER, { recursive: true });
const aufPlatte = `${Date.now().toString(36)}-${randomBytes(8).toString("hex")}${erkannt.endung}`;
writeFileSync(join(ANHANG_ORDNER, aufPlatte), req.body, { flag: "wx" });
const d = db();
const n = jetzt();
d.prepare(`INSERT INTO chat_nachrichten
(raum_id, person_id, text, erstellt,
anhang_datei, anhang_name, anhang_art, anhang_typ,
anhang_groesse, anhang_breite, anhang_hoehe, anhang_dauer)
VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`)
.run(raumId, req.person.id, begleittext, n,
aufPlatte, name, erkannt.art, erkannt.typ,
req.body.length, erkannt.breite || null, erkannt.hoehe || null, dauer);
const id = d.prepare("SELECT last_insert_rowid() AS id").get().id;
d.prepare("UPDATE chat_raeume SET letzte_am = ? WHERE id = ?").run(n, raumId);
d.prepare("UPDATE chat_teilnehmer SET gelesen_bis = ? WHERE raum_id = ? AND person_id = ?")
.run(id, raumId, req.person.id);
const nachricht = {
id, raum_id: raumId, von_id: req.person.id, von: req.person.name,
rolle: req.person.rolle, text: begleittext, erstellt: n,
zurueckgenommen: false, antwort: null,
anhang: {
art: erkannt.art, typ: erkannt.typ, name,
groesse: req.body.length,
breite: erkannt.breite || 0, hoehe: erkannt.hoehe || 0,
dauer: dauer || 0,
weg: `/workspace/api/chat/anhang/${id}`,
},
rudel: false,
};
const empfaenger = teilnehmerVon(raumId).filter((t) => t.id !== req.person.id);
chatEreignis(raumId, nachricht, empfaenger.map((t) => t.id));
protokolliere("chat_anhang", {
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
detail: `#${id} ${erkannt.art} ${Math.round(req.body.length / 1024)} kB`.slice(0, 120),
});
res.status(201).json({ nachricht });
} catch (fehler) {
console.error("[chat] Anhang:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* =====================================================================
DIE GIF-KISTE (23.09.2026)
Filipe: „dan will ich auch dass man im chat auch sprachnachrichten
und gifts reinschicken kann. also nur die modis rechte linke hand
und dogfather."
ICH LESE „gifts" ALS GIFs -- die bewegten Bildchen -- und sage das
hier ausdruecklich, statt es stillschweigend anzunehmen. Im
Zusammenhang („im chat reinschicken", direkt neben Sprachnachrichten)
passt nichts anderes; sollte er Geschenke gemeint haben, steht das
hier als Stelle, an der man es sieht.
WARUM EINE EIGENE KISTE UND KEIN GIPHY: Die Begruendung steht bei
der Tabelle in workspace.js -- kurz: fremder Schluessel, fremde
Firma, jede Suche geht hinaus, und ab einer Menge kostet es. Die
Kiste laeuft hier, kostet nichts und wird mit der Zeit besser:
Was darin liegt, hat das Team ausgesucht.
DIE VIER GELTEN AUCH HIER. „also nur die modis rechte linke hand und
dogfather" stand im selben Satz wie die Sprachnachrichten; es gibt
keinen Grund, warum es fuer das eine gelten sollte und fuer das
andere nicht.
===================================================================== */
/** Vor jeder GIF-Route: Gehoere ich dazu? */
function nurRudel(req, res, next) {
if (!istTeamDogi(req.person)) {
return res.status(403).json({ fehler: "Die GIF-Kiste gehört Team Dogi." });
}
next();
}
chatRouter.get("/workspace/api/chat/gifs", nurRudel, (req, res) => {
try {
res.json({ gifs: gifListe(), hoechstens: GIF_MAX });
} catch (fehler) {
console.error("[chat] GIF-Liste:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/** Ein GIF in die Kiste legen. */
chatRouter.post("/workspace/api/chat/gifs", gleicheHerkunft, nurRudel,
express.raw({ type: "*/*", limit: GIF_MAX }), (req, res) => {
try {
if (!Buffer.isBuffer(req.body) || !req.body.length) {
return res.status(400).json({ fehler: "Keine Datei empfangen." });
}
/* AUS DEM INHALT, nicht aus dem Namen und nicht aus dem
Content-Type -- beide kommen vom Absender. */
const erkannt = dateiErkennen(req.body);
if (!erkannt || erkannt.typ !== "image/gif") {
return res.status(415).json({ fehler: "In die Kiste kommen nur GIFs." });
}
/* HABEN WIR DAS SCHON? Beantwortet am INHALT, nicht am Namen.
Ueber den Namen zu vergleichen waere die naheliegende
Abkuerzung -- und sie versagt genau dort, wo Dateien
"giphy.gif", "giphy(1).gif" und "download.gif" heissen, also
fast immer. Dasselbe GIF waere dreimal dieselbe Kachel. */
const pruef = createHash("sha256").update(req.body).digest("hex");
const d = db();
const schon = d.prepare("SELECT id FROM chat_gifs WHERE pruef = ?").get(pruef);
if (schon) {
/* KEIN FEHLER. Wer dasselbe GIF noch einmal hineinlegt, wollte
es in der Kiste haben -- und es ist drin. Eine Absage waere
formal richtig und im Erleben falsch. */
return res.status(200).json({ gif: gifListe().find((g) => g.id === schon.id) || null,
schon: true });
}
const name = anhangName(req.get("x-dateiname"), ".gif").replace(/\.gif$/i, "") || "GIF";
mkdirSync(GIF_ORDNER, { recursive: true });
const aufPlatte = `${Date.now().toString(36)}-${randomBytes(8).toString("hex")}.gif`;
writeFileSync(join(GIF_ORDNER, aufPlatte), req.body, { flag: "wx" });
const n = jetzt();
d.prepare(`INSERT INTO chat_gifs
(datei, name, pruef, typ, groesse, breite, hoehe, von_id, erstellt)
VALUES (?,?,?,?,?,?,?,?,?)`)
.run(aufPlatte, name.slice(0, 60), pruef, erkannt.typ, req.body.length,
erkannt.breite || null, erkannt.hoehe || null, req.person.id, n);
const id = d.prepare("SELECT last_insert_rowid() AS id").get().id;
protokolliere("chat_gif_dazu", {
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
detail: `#${id} ${name} ${Math.round(req.body.length / 1024)} kB`.slice(0, 120),
});
res.status(201).json({ gif: gifListe().find((g) => g.id === id) || null, schon: false });
} catch (fehler) {
console.error("[chat] GIF hineinlegen:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/** Ein GIF aus der Kiste ansehen. */
chatRouter.get("/workspace/api/chat/gifs/:id/bild", nurRudel, (req, res) => {
try {
const id = Number(req.params.id);
if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
const g = db().prepare("SELECT datei, name, typ FROM chat_gifs WHERE id = ?").get(id);
if (!g) return res.status(404).json({ fehler: "nicht_gefunden" });
const pfad = join(GIF_ORDNER, g.datei);
try { statSync(pfad); } catch { return res.status(410).json({ fehler: "Datei fehlt auf der Platte." }); }
/* Dieselben Kopfzeilen wie beim Anhang -- der Typ aus der
Erkennung, nosniff, und eine Richtlinie, die dem Dokument jede
Ausfuehrung nimmt. Ein GIF kostet das nichts. */
res.setHeader("Content-Type", g.typ || "image/gif");
res.setHeader("X-Content-Type-Options", "nosniff");
res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
res.setHeader("Cache-Control", "private, max-age=86400");
createReadStream(pfad).pipe(res);
} catch (fehler) {
console.error("[chat] GIF ausliefern:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/** Ein GIF wieder aus der Kiste nehmen.
*
* WER: der, der es hineingelegt hat -- und wer ohnehin jede Nachricht
* wegnehmen darf (DogFather und die rechte Hand). Die Kiste gehoert
* allen; ein GIF, das nicht mehr passt, muss jemand herausnehmen
* koennen, ohne den zu suchen, der es damals gebracht hat.
*
* DIE DATEI GEHT MIT. Anders als bei einer Nachricht gibt es hier
* keinen Verlauf, den man lesbar halten muesste -- was aus der Kiste
* ist, ist aus der Kiste. Bereits verschickte GIFs bleiben
* unberuehrt: Sie sind Kopien (siehe oben). */
chatRouter.delete("/workspace/api/chat/gifs/:id", gleicheHerkunft, nurRudel, (req, res) => {
try {
const id = Number(req.params.id);
if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
const d = db();
const g = d.prepare("SELECT id, datei, name, von_id FROM chat_gifs WHERE id = ?").get(id);
if (!g) return res.status(404).json({ fehler: "nicht_gefunden" });
if (g.von_id !== req.person.id && !darfJedeNachrichtLoeschen(req.person)) {
return res.status(403).json({ fehler: "Das hat jemand anderes hineingelegt." });
}
const weg = d.prepare("DELETE FROM chat_gifs WHERE id = ?").run(id).changes;
if (weg) {
try { unlinkSync(join(GIF_ORDNER, g.datei)); } catch { /* war schon weg */ }
}
protokolliere("chat_gif_weg", {
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
detail: `#${id} ${g.name}`.slice(0, 120),
});
res.json({ weg: weg > 0, gifs: gifListe() });
} catch (fehler) {
console.error("[chat] GIF herausnehmen:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/** Ein GIF aus der Kiste in ein Gespraech schicken.
*
* ES WIRD KOPIERT, NICHT VERWIESEN -- die Begruendung steht oben bei
* GIF_ORDNER: Eine geloeschte Nachricht nimmt ihre Datei mit, und ein
* gemeinsamer Verweis waere ein kaputtes Bild in drei Gespraechen.
*
* DANACH IST ES EIN GANZ NORMALER ANHANG. Keine zweite Sorte
* Nachricht: Es steht im Verlauf, es laesst sich zuruecknehmen, es
* faellt unter dieselbe Nachtruhe. Eine eigene Sorte haette eigene
* Rechte, eigene Suche, eigenes Loeschen -- drei Dinge, die es schon
* gibt. */
chatRouter.post("/workspace/api/chat/raeume/:id/gif", gleicheHerkunft, nurRudel,
express.json({ limit: "2kb" }), (req, res) => {
try {
const raumId = Number(req.params.id);
if (!Number.isInteger(raumId)) return res.status(400).json({ fehler: "ungueltig" });
if (!istDrin(raumId, req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
/* DIE NACHTRUHE GILT AUCH HIER. Sie nur beim Text und beim
Anhang zu pruefen hiesse, dass man nachts zwar nicht schreiben,
aber ein GIF schicken kann -- der Weg, den jeder findet, der
es einmal versucht. */
if (istTreffRaum(raumId) && istNachtruhe()) {
const stand = nachtruheStand();
return res.status(403).json({ fehler: stand.satz, nachtruhe: stand });
}
const gifId = Number(req.body?.gif_id);
const d = db();
const g = Number.isInteger(gifId)
? d.prepare("SELECT id, datei, name, typ, groesse, breite, hoehe FROM chat_gifs WHERE id = ?")
.get(gifId) : null;
if (!g) return res.status(404).json({ fehler: "Dieses GIF gibt es nicht mehr." });
const quelle = join(GIF_ORDNER, g.datei);
try { statSync(quelle); } catch {
return res.status(410).json({ fehler: "Die Datei fehlt auf der Platte." });
}
mkdirSync(ANHANG_ORDNER, { recursive: true });
const aufPlatte = `${Date.now().toString(36)}-${randomBytes(8).toString("hex")}.gif`;
copyFileSync(quelle, join(ANHANG_ORDNER, aufPlatte));
let begleittext = String(req.body?.text ?? "").trim().slice(0, TEXT_MAX);
const n = jetzt();
d.prepare(`INSERT INTO chat_nachrichten
(raum_id, person_id, text, erstellt,
anhang_datei, anhang_name, anhang_art, anhang_typ,
anhang_groesse, anhang_breite, anhang_hoehe)
VALUES (?,?,?,?,?,?,?,?,?,?,?)`)
.run(raumId, req.person.id, begleittext, n,
aufPlatte, `${g.name}.gif`, "bild", g.typ,
g.groesse, g.breite || null, g.hoehe || null);
const id = d.prepare("SELECT last_insert_rowid() AS id").get().id;
d.prepare("UPDATE chat_raeume SET letzte_am = ? WHERE id = ?").run(n, raumId);
d.prepare("UPDATE chat_teilnehmer SET gelesen_bis = ? WHERE raum_id = ? AND person_id = ?")
.run(id, raumId, req.person.id);
const nachricht = {
id, raum_id: raumId, von_id: req.person.id, von: req.person.name,
von_bild: bildWegFuer(req.person.id),
von_kachel: kachelFuer(req.person.id),
rolle: req.person.rolle, text: begleittext, erstellt: n,
zurueckgenommen: false, antwort: null, rudel: false,
anhang: {
art: "bild", typ: g.typ, name: `${g.name}.gif`,
groesse: g.groesse, breite: g.breite || 0, hoehe: g.hoehe || 0,
dauer: 0,
weg: `/workspace/api/chat/anhang/${id}`,
},
};
const empfaenger = teilnehmerVon(raumId).filter((t) => t.id !== req.person.id);
chatEreignis(raumId, nachricht, empfaenger.map((t) => t.id));
protokolliere("chat_gif", {
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
detail: `#${id} aus Kiste #${g.id}`.slice(0, 120),
});
res.status(201).json({ nachricht });
} catch (fehler) {
console.error("[chat] GIF schicken:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/** Einen Anhang ansehen oder laden.
*
* Die Kennung ist die der NACHRICHT, nicht die der Datei. Damit
* hängt der Zugriff an derselben Prüfung wie der Verlauf: Wer nicht
* im Raum ist, bekommt 404 -- und wer das Gespräch weggeräumt hat,
* auch. Ein eigener Dateischlüssel wäre eine zweite Tür mit einem
* zweiten Schloss. */
chatRouter.get("/workspace/api/chat/anhang/:id", (req, res) => {
try {
const id = Number(req.params.id);
if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
const n = db().prepare(`SELECT id, raum_id, weg_am,
anhang_datei, anhang_name, anhang_art, anhang_typ
FROM chat_nachrichten WHERE id = ?`).get(id);
if (!n || !n.anhang_datei || n.weg_am) return res.status(404).json({ fehler: "nicht_gefunden" });
if (!istDrin(n.raum_id, req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
if (n.id <= geloeschtBis(n.raum_id, req.person.id)) {
return res.status(404).json({ fehler: "nicht_gefunden" });
}
const pfad = join(ANHANG_ORDNER, n.anhang_datei);
try { statSync(pfad); } catch { return res.status(410).json({ fehler: "Datei fehlt auf der Platte." }); }
/* AUSGELIEFERT WIRD DER TYP AUS DER ERKENNUNG, nie ein
eingeschickter. Er steht seit dem Hochladen in der Datenbank und
kann seitdem von niemandem mehr beeinflusst werden.
`nosniff` verbietet dem Browser, sich einen anderen Typ
auszudenken. Die enge Richtlinie mit `sandbox` nimmt dem
Dokument jede Ausführung -- das ist die Sicherung für den Fall,
dass in einem PDF ein Skript steckt (PDF kann das). Bei einem
Bild kostet sie nichts. */
res.setHeader("Content-Type", n.anhang_typ || "application/octet-stream");
res.setHeader("X-Content-Type-Options", "nosniff");
res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
res.setHeader("Cache-Control", "private, max-age=86400");
/* Ansehen ist die Vorgabe -- ein Foto, das man erst herunterladen
muss, um es zu sehen, ist kein Foto im Chat. `?laden=1` macht
daraus einen Download. */
const alsDownload = req.query.laden === "1";
res.setHeader("Content-Disposition",
`${alsDownload ? "attachment" : "inline"}; filename*=UTF-8''${encodeURIComponent(n.anhang_name || "anhang")}`);
createReadStream(pfad).pipe(res);
} catch (fehler) {
console.error("[chat] Anhang ausliefern:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* =====================================================================
EIN GESPRÄCH WEGRÄUMEN — NUR BEI MIR (09.09.2026)
Filipe: "man muss die chats auch gelöscht bekommen!!!"
Auf Nachfrage: nur bei mir.
Was hier NICHT passiert: Es wird nichts aus der Datenbank entfernt.
Das Gegenüber behält seinen Verlauf vollständig -- niemand kann
einem anderen die Unterhaltung wegnehmen. Und es wird auch nicht
die Mitgliedschaft beendet: Schreibt der andere morgen wieder,
kommt das Gespräch mit dem NEUEN zurück, das Alte bleibt weg.
Genau so verhält sich jeder Messenger, den Filipe kennt.
`gelesen_bis` wandert mit. Ohne das käme das Gespräch sofort wieder
als "ungelesen" hoch -- weggeräumt und trotzdem eine rote Zahl in
der Kopfleiste wäre schlimmer als gar nicht löschen.
===================================================================== */
chatRouter.delete("/workspace/api/chat/raeume/:id", gleicheHerkunft, (req, res) => {
try {
const raumId = Number(req.params.id);
if (!Number.isInteger(raumId)) return res.status(400).json({ fehler: "ungueltig" });
if (!istDrin(raumId, req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
const d = db();
const bis = d.prepare("SELECT COALESCE(MAX(id), 0) AS m FROM chat_nachrichten WHERE raum_id = ?")
.get(raumId).m;
d.prepare(`UPDATE chat_teilnehmer
SET geloescht_bis = ?, geloescht_am = ?,
gelesen_bis = CASE WHEN gelesen_bis < ? THEN ? ELSE gelesen_bis END
WHERE raum_id = ? AND person_id = ?`)
.run(bis, jetzt(), bis, bis, raumId, req.person.id);
protokolliere("chat_weggeraeumt", {
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
detail: `Raum #${raumId} bis #${bis}`,
});
res.json({ ok: true, bis });
} catch (fehler) {
console.error("[chat] Wegräumen:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/** Darf diese Person diesen Raum fuer ALLE aufloesen?
*
* EINE REGEL, EINE STELLE (11.09.2026). Sie wurde zuerst in der
* Raumliste ausgerechnet -- und der Knopf blieb trotzdem unsichtbar,
* weil die Oberflaeche den offenen Raum aus dem Nachrichten-Weg
* bezieht, nicht aus der Liste. Zwei Wege, ein Raumobjekt, und nur
* einer kannte das Feld.
*
* Gefunden hat das nicht das Lesen, sondern eine Pruefung, die den
* KNOPF gemessen hat statt des Rechts dahinter.
*
* `erstellt_von` muss im uebergebenen Raum stehen -- wer die Spalte
* im SELECT vergisst, bekommt `undefined` und damit `false`. Das ist
* die sichere Richtung: kein Knopf statt eines falschen.
*/
function darfAufloesen(raum, person) {
return !!raum && raum.art !== "direkt"
&& !!raum.erstellt_von && raum.erstellt_von === person.id;
}
/* =====================================================================
REAKTIONEN — auf die Nachricht, ohne zu antworten (14.09.2026)
Filipe: "ich will dass man auf die nachrichten auch reagieren kann
mit einem emoji, die nachricht selbst ohne zu antworten."
EINE FESTE AUSWAHL, KEIN FREIES FELD. Sechs Zeichen, hier
aufgeschrieben. Drei Gruende, und der erste ist der wichtigste:
* Eine feste Liste laesst sich pruefen. Was hier nicht drinsteht,
kommt nicht in die Datenbank -- kein beliebiger Text, keine
Zeichenketten von 4 KB, keine unsichtbaren Steuerzeichen.
* Alle sehen dasselbe. Ein selbst getipptes Zeichen sieht auf
einem anderen Geraet anders aus oder gar nicht.
* Sechs Zeichen kann man ueberfliegen. Eine volle Emoji-Tafel ist
eine Suchaufgabe, und dann tippt man doch wieder "ok".
DIE LISTE STEHT AUF DEM SERVER und wird an die Oberflaeche geliefert
(/reaktionen/auswahl). Stuende sie im Browser, gaebe es sie zweimal
-- und die zweite Fassung waere die, in der ein Zeichen fehlt, das
der Server noch annimmt.
===================================================================== */
/* Die drei Listen stehen in workspace-reaktionen.js -- Katalog,
Vorschlag, erlaubte Zeichen. Hier stehen nur die Wege dorthin. */
/** Die Favoriten EINES Menschen, in seiner Reihenfolge. */
function favoritenVon(personId) {
return db().prepare(
"SELECT zeichen FROM chat_reaktion_favoriten WHERE person_id = ? ORDER BY platz, zeichen")
.all(personId).map((z) => z.zeichen)
/* Was nicht mehr im Katalog steht, faellt still weg -- aber nur
beim LESEN. Die Zeile bleibt stehen; kaeme das Zeichen zurueck,
ist der Favorit wieder da. Ein Loeschen waere eine Entscheidung
ueber fremde Daten wegen einer Katalogaenderung. */
.filter((z) => ERLAUBT.has(z));
}
/* WAS DIE OBERFLAECHE BRAUCHT, IN EINER ANTWORT: die Vorschlagszeile,
den ganzen Katalog mit Suchwoertern und die eigenen Favoriten.
Drei Abrufe daraus zu machen waere sparsamer aussehend und in
Wahrheit teurer: Die Tafel kann erst erscheinen, wenn alle drei da
sind. */
chatRouter.get("/workspace/api/chat/reaktionen/auswahl", (req, res) => {
try {
const favoriten = favoritenVon(req.person.id);
res.json({
/* Die Vorschlagszeile sind die FAVORITEN, sobald es welche gibt
-- sonst die Vorgabe. Beides an einer Stelle entschieden,
damit die Oberflaeche nicht selbst waehlen muss. */
zeichen: favoriten.length ? favoriten : VORSCHLAG,
eigene: favoriten.length > 0,
favoriten,
favoriten_max: FAVORITEN_MAX,
katalog: KATALOG,
});
} catch (fehler) {
console.error("[chat] Auswahl:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* EINEN FAVORITEN SETZEN ODER WEGNEHMEN -- wieder ein Umschalter,
wie das Reagieren selbst. Ein eigener Weg zum Entfernen waere ein
zweiter Weg, den man absichern muss. */
chatRouter.put("/workspace/api/chat/reaktionen/favorit", gleicheHerkunft,
express.json({ limit: "2kb" }), (req, res) => {
try {
const zeichen = String(req.body?.zeichen ?? "");
if (!ERLAUBT.has(zeichen)) return res.status(400).json({ fehler: "unbekanntes_zeichen" });
const d = db();
const da = d.prepare(
"SELECT 1 FROM chat_reaktion_favoriten WHERE person_id = ? AND zeichen = ?")
.get(req.person.id, zeichen);
if (da) {
d.prepare("DELETE FROM chat_reaktion_favoriten WHERE person_id = ? AND zeichen = ?")
.run(req.person.id, zeichen);
} else {
const wieViele = d.prepare(
"SELECT COUNT(*) AS n FROM chat_reaktion_favoriten WHERE person_id = ?")
.get(req.person.id).n;
if (wieViele >= FAVORITEN_MAX) {
/* NICHT STILL DEN AELTESTEN WEGWERFEN. Wer neun ablegen will,
soll erfahren, dass acht das Maximum sind -- und selbst
entscheiden, welcher geht. Ein Favorit, der ohne Ansage
verschwindet, sieht wie ein Fehler aus. */
return res.status(409).json({
fehler: `Mehr als ${FAVORITEN_MAX} Favoriten passen nicht in die Zeile. `
+ "Nimm erst einen weg.",
favoriten: favoritenVon(req.person.id),
});
}
/* Ans ENDE, nicht an den Anfang: Die vorhandenen sollen nicht
wandern -- man greift sonst daneben. */
const platz = (d.prepare(
"SELECT COALESCE(MAX(platz), 0) AS p FROM chat_reaktion_favoriten WHERE person_id = ?")
.get(req.person.id).p) + 1;
d.prepare(`INSERT INTO chat_reaktion_favoriten (person_id, zeichen, platz)
VALUES (?,?,?)`).run(req.person.id, zeichen, platz);
}
const favoriten = favoritenVon(req.person.id);
res.json({ favoriten, gesetzt: !da,
zeichen: favoriten.length ? favoriten : VORSCHLAG });
} catch (fehler) {
console.error("[chat] Favorit:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/** Alle Reaktionen zu einer Menge von Nachrichten/** Alle Reaktionen zu einer Menge von Nachrichten -- in EINER Abfrage.
*
* Je Nachricht einzeln zu fragen waere bei 200 Nachrichten 200
* Abfragen fuer eine Ansicht. Zurueck kommt eine Karte:
* nachricht_id -> [{ zeichen, anzahl, selbst, wer }].
*
* `wer` ist bewusst dabei: "drei Daumen" sagt weniger als "Ayla, Ben
* und Cem". Es sind Namen aus DEMSELBEN Raum -- wer die Nachricht
* sieht, sieht die Leute ohnehin.
*/
function reaktionenZu(ids, personId) {
const karte = new Map();
if (!ids.length) return karte;
const platz = ids.map(() => "?").join(",");
const reihen = db().prepare(`
SELECT r.nachricht_id, r.zeichen, r.person_id, p.name
FROM chat_reaktionen r
LEFT JOIN personen p ON p.id = r.person_id
WHERE r.nachricht_id IN (${platz})
ORDER BY r.wann`).all(...ids);
for (const z of reihen) {
if (!karte.has(z.nachricht_id)) karte.set(z.nachricht_id, new Map());
const proNachricht = karte.get(z.nachricht_id);
if (!proNachricht.has(z.zeichen)) {
proNachricht.set(z.zeichen, { zeichen: z.zeichen, anzahl: 0, selbst: false, wer: [] });
}
const eintrag = proNachricht.get(z.zeichen);
eintrag.anzahl++;
if (z.person_id === personId) eintrag.selbst = true;
eintrag.wer.push(z.name || "Gelöscht");
}
const fertig = new Map();
for (const [id, proNachricht] of karte) fertig.set(id, [...proNachricht.values()]);
return fertig;
}
/* REAGIEREN IST EIN UMSCHALTER, kein Hinzufuegen.
Zweimal dasselbe Zeichen heisst: wieder weg. Das erspart einen
zweiten Weg zum Zuruecknehmen -- und einen zweiten Weg, den man
vergisst abzusichern. */
/* ==== DIE NACHTRUHE GILT HIER ABSICHTLICH NICHT (19.09.2026) ========
Eine Reaktion ist keine Nachricht. Sie sagt nichts, was jemand
beantworten muesste, sie kann keinen Streit anfangen, und sie loest
keine Meldung aus (siehe die Begruendung weiter unten: „Ein Daumen
ist keine Nachricht").
Filipes Ansage war „keiner schreiben kann". Ein Daumen ist kein
Schreiben -- und genau darum geht es bei der Nachtruhe: Sie soll den
Druck wegnehmen, nachts antworten zu muessen, nicht den Raum
abschliessen.
DAS STEHT HIER, damit es nicht wie ein Versehen aussieht. Eine
Luecke, die niemand begruendet hat, wird beim naechsten Durchsehen
entweder geschlossen oder uebersehen -- beides falsch. */
chatRouter.put("/workspace/api/chat/nachrichten/:id/reaktion", gleicheHerkunft,
express.json({ limit: "2kb" }), (req, res) => {
try {
const id = Number(req.params.id);
if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
const zeichen = String(req.body?.zeichen ?? "");
if (!ERLAUBT.has(zeichen)) {
return res.status(400).json({ fehler: "unbekanntes_zeichen" });
}
const d = db();
const n = d.prepare(
"SELECT id, raum_id, weg_am FROM chat_nachrichten WHERE id = ?").get(id);
if (!n) return res.status(404).json({ fehler: "nicht_gefunden" });
/* Die Raumzugehoerigkeit ist die ganze Sicherheit dieses Wegs --
dieselbe Pruefung wie beim Lesen des Verlaufs. */
if (!istDrin(n.raum_id, req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
/* Auf eine zurueckgenommene Nachricht wird nicht reagiert. Dort
steht nichts mehr, worauf man reagieren koennte. */
if (n.weg_am) return res.status(409).json({ fehler: "zurueckgenommen" });
const da = d.prepare(`SELECT 1 FROM chat_reaktionen
WHERE nachricht_id = ? AND person_id = ? AND zeichen = ?`)
.get(id, req.person.id, zeichen);
if (da) {
d.prepare(`DELETE FROM chat_reaktionen
WHERE nachricht_id = ? AND person_id = ? AND zeichen = ?`)
.run(id, req.person.id, zeichen);
} else {
d.prepare(`INSERT INTO chat_reaktionen (nachricht_id, person_id, zeichen, wann)
VALUES (?,?,?,?)`).run(id, req.person.id, zeichen, jetzt());
}
const stand = reaktionenZu([id], req.person.id).get(id) || [];
/* ALLE IM RAUM SEHEN ES SOFORT -- ohne Benachrichtigung aufs
Handy. Ein Daumen ist keine Nachricht; wer dafuer eine Meldung
bekaeme, schaltet Meldungen ab. */
chatEreignis(n.raum_id, { id, raum_id: n.raum_id, reaktionen: stand }, [], "reaktion");
res.json({ id, reaktionen: stand, gesetzt: !da });
} catch (fehler) {
console.error("[chat] Reaktion:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* =====================================================================
EINE GRUPPE ODER EINEN KANAL AUFLOESEN — FUER ALLE (11.09.2026)
Filipe: "wenn ein gruppenchat oder kanal geoeffnet wird, die person
die ihn oeffnet soll auch das recht haben das zu loeschen und so
dass es dan fuer jeden geloescht ist. aber nur die person die es
gruendet."
DAS IST ETWAS ANDERES ALS DER WEG DARUEBER, und die beiden duerfen
nie verwechselt werden:
Wegraeumen -> nur bei mir. Die anderen behalten alles.
Aufloesen -> fuer alle. Der Raum ist weg, endgueltig.
Deshalb ein eigener Weg (/ganz) und nicht ein Zusatzfeld am
bestehenden: Ein vergessenes Feld waere hier der Unterschied
zwischen "bei mir ausgeblendet" und "bei allen geloescht".
NUR DER GRUENDER, und zwar woertlich. Nicht die Teamleitung, nicht
DogFather, nicht wer `leitung` in der Gruppe hat. `erstellt_von`
steht seit jeher in der Tabelle und ist die einzige Angabe, die
"wer hat das aufgemacht" beantwortet.
NICHT BEI ZWEIER-GESPRAECHEN. Dort gibt es keinen Gruender, nur
zwei Beteiligte -- und "niemand kann einem anderen die Unterhaltung
wegnehmen" ist die Regel von 09.09., die hier gilt.
DIE OFFENE STELLE, damit sie niemand suchen muss: Wird das Konto
des Gruenders geloescht, wird `erstellt_von` auf NULL gesetzt
(ON DELETE SET NULL) -- dann kann NIEMAND mehr aufloesen. Das ist
die ehrliche Folge von "nur der Gruender"; wer das aendern will,
muss eine zweite Person benennen, und das ist eine Entscheidung,
keine Reparatur.
REIHENFOLGE, und sie ist nicht beliebig:
1. Das Ereignis geht RAUS, solange es die Teilnehmer noch gibt --
chatEreignis liest sie aus der Tabelle. Danach waere die Liste
leer und niemand erfuehre, dass der Raum weg ist.
2. Die Zeilen fallen in EINER Transaktion.
3. Die Anhaenge auf der Platte erst NACH dem Commit. Andersherum
haetten wir bei einem Ruecklauf Nachrichten, die auf Dateien
zeigen, die es nicht mehr gibt.
===================================================================== */
chatRouter.delete("/workspace/api/chat/raeume/:id/ganz", gleicheHerkunft, (req, res) => {
try {
const raumId = Number(req.params.id);
if (!Number.isInteger(raumId)) return res.status(400).json({ fehler: "ungueltig" });
if (!istDrin(raumId, req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
const d = db();
const raum = d.prepare(
"SELECT id, art, name, kategorie, erstellt_von FROM chat_raeume WHERE id = ?").get(raumId);
if (!raum) return res.status(404).json({ fehler: "nicht_gefunden" });
if (raum.art === "direkt") return res.status(403).json({ fehler: "nur_gruppe_oder_kanal" });
/* Dieselbe Regel wie fuer den Knopf -- nicht "auch so eine". Waere
hier eine zweite Bedingung ausgeschrieben, koennte der Knopf
eines Tages erscheinen, wo der Weg ablehnt, oder umgekehrt. */
if (!darfAufloesen(raum, req.person)) {
return res.status(403).json({ fehler: "nur_gruender" });
}
const dateien = d.prepare(
`SELECT anhang_datei FROM chat_nachrichten
WHERE raum_id = ? AND anhang_datei IS NOT NULL`)
.all(raumId).map((z) => z.anhang_datei);
const wieViele = d.prepare(
"SELECT COUNT(*) AS n FROM chat_nachrichten WHERE raum_id = ?").get(raumId).n;
const leute = teilnehmerVon(raumId).map((t) => t.id);
/* Schritt 1: erst sagen, dann loeschen (siehe oben). */
chatEreignis(raumId, { raum_id: raumId, aufgeloest: true }, [], "raum-weg");
/* Schritt 2: alles in einem Zug. Ein halb aufgeloester Raum --
Nachrichten weg, Raum noch da -- waere in jeder Liste ein
leerer Eintrag, den niemand mehr loswird. */
d.exec("BEGIN");
try {
d.prepare("DELETE FROM chat_nachrichten WHERE raum_id = ?").run(raumId);
d.prepare("DELETE FROM chat_teilnehmer WHERE raum_id = ?").run(raumId);
d.prepare("DELETE FROM chat_raeume WHERE id = ?").run(raumId);
d.exec("COMMIT");
} catch (fehler) {
try { d.exec("ROLLBACK"); } catch { /* schon zurueck */ }
throw fehler;
}
/* Schritt 3: die Anhaenge. Was hier liegen bleibt, ist Muell --
aber kein Datenschaden, und es wird gemeldet statt verschwiegen. */
let dateienWeg = 0;
for (const name of dateien) {
try { unlinkSync(join(ANHANG_ORDNER, name)); dateienWeg++; }
catch (f) {
if (f?.code === "ENOENT") dateienWeg++;
else console.error("[chat] Anhang bleibt liegen:", f?.message);
}
}
protokolliere("chat_aufgeloest", {
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
detail: `${raum.art} #${raumId} "${raum.name || raum.kategorie || ""}": `
+ `${wieViele} Nachrichten, ${leute.length} Beteiligte, `
+ `${dateienWeg}/${dateien.length} Anhaenge`.slice(0, 200),
});
res.json({ ok: true, nachrichten: wieViele, beteiligte: leute.length,
anhaenge: dateien.length });
} catch (fehler) {
console.error("[chat] Aufloesen:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* =====================================================================
SUCHE (09.09.2026, Punkt 15)
Filipe: "ich will dass du diese seite viel krasser und detaillierter
machst ... alles reinsetzt was wir noch gebrauchen koennten."
Ein Chat ohne Suche ist ab dem zweiten Monat ein Archiv, in dem man
nichts findet. Das ist die Funktion, die am haeufigsten fehlt und am
meisten Zeit spart -- vor Reaktionen, vor Anhaengen, vor allem
anderen.
DIE EINGRENZUNG AUF DIE EIGENEN RAEUME IST DIE GANZE SICHERHEIT
DIESER FUNKTION. Sie steht deshalb im JOIN und nicht in einer
nachtraeglichen Pruefung: `chat_teilnehmer` wird mit der eigenen
Personenkennung verbunden, und was dort nicht drinsteht, kommt gar
nicht erst aus der Datenbank. Ein Filter, der erst hinterher
aussortiert, ist eine Zeile davon entfernt, vergessen zu werden.
OHNE VOLLTEXTINDEX, MIT ABSICHT. `LIKE '%...%'` kann keinen Index
benutzen und liest die Tabelle. Bei einem Team dieser Groesse sind
das einige tausend Zeilen -- gemessen unter einer Millisekunde. Ein
FTS5-Index waere eine zweite Tabelle, die synchron gehalten werden
muss, und genau daran gehen solche Sachen kaputt. Wenn der Verlauf
einmal sechsstellig wird, ist das der richtige Zeitpunkt dafuer,
nicht heute.
`escape` FUER DIE PLATZHALTER: In `LIKE` sind `%` und `_` Zeichen
mit Bedeutung. Wer nach "100 %" sucht, wuerde sonst alles finden.
===================================================================== */
chatRouter.get("/workspace/api/chat/suche", (req, res) => {
try {
const roh = String(req.query.q ?? "").trim();
if (roh.length < 2) return res.json({ frage: roh, treffer: [], zuKurz: true });
if (roh.length > 120) return res.status(400).json({ fehler: "zu_lang" });
/* AUCH DER BACKSLASH SELBST. Er ist hier das Fluchtzeichen
(`ESCAPE '\'`); wer ihn eingibt, wuerde sonst das naechste
Zeichen entwerten und im Zweifel ein ungueltiges Muster erzeugen.
Drei Zeichen haben in `LIKE` eine Bedeutung, nicht zwei. */
const muster = "%" + roh.replace(/[\\%_]/g, (z) => "\\" + z) + "%";
const reihen = db().prepare(`
SELECT n.id, n.raum_id, n.text, n.erstellt,
p.name AS von, p.rolle,
r.art, r.name AS raum_name
FROM chat_nachrichten n
JOIN chat_teilnehmer t ON t.raum_id = n.raum_id AND t.person_id = ?
JOIN chat_raeume r ON r.id = n.raum_id
LEFT JOIN personen p ON p.id = n.person_id
WHERE n.weg_am IS NULL
AND n.id > t.geloescht_bis
AND n.text LIKE ? ESCAPE '\\'
ORDER BY n.id DESC LIMIT 60`).all(req.person.id, muster);
res.json({
frage: roh,
treffer: reihen.map((n) => {
const leute = teilnehmerVon(n.raum_id);
return {
id: n.id, raum_id: n.raum_id,
raum: raumName({ id: n.raum_id, art: n.art, name: n.raum_name }, leute, req.person.id),
von: n.von || "Gelöscht", rolle: n.rolle,
erstellt: n.erstellt,
/* Der Ausschnitt wird um den Treffer herum geschnitten, nicht
vom Anfang: Bei einer langen Nachricht stuende sonst der
Anfang da und das gesuchte Wort waere nicht dabei. */
text: ausschnitt(n.text, roh),
};
}),
});
} catch (fehler) {
console.error("[chat] Suche:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/** Ein Stueck Text um die Fundstelle herum. */
function ausschnitt(text, frage) {
const t = String(text || "");
const i = t.toLowerCase().indexOf(frage.toLowerCase());
if (i < 0 || t.length <= 160) return t.slice(0, 160);
const von = Math.max(0, i - 50);
const bis = Math.min(t.length, i + frage.length + 90);
return (von > 0 ? "… " : "") + t.slice(von, bis) + (bis < t.length ? " …" : "");
}
/** Bis hierher gelesen. */
chatRouter.put("/workspace/api/chat/raeume/:id/gelesen", gleicheHerkunft,
express.json({ limit: "4kb" }), (req, res) => {
try {
const raumId = Number(req.params.id);
const bis = Number(req.body?.bis);
if (!Number.isInteger(raumId) || !Number.isInteger(bis)) {
return res.status(400).json({ fehler: "ungueltig" });
}
if (!istDrin(raumId, req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
/* ==== NICHT WEITER ALS BIS ZUR LETZTEN NACHRICHT (20.09.2026) ====
Hier stand nur `Number.isInteger(bis)`. Damit liess sich der
Stand auf JEDE Zahl setzen -- auch auf eine, die weit hinter
allem liegt, was es gibt.
Die Folge ist still und dauerhaft: Wer einmal "gelesen bis
999999" schickt, hat in diesem Gespraech nie wieder einen
Zaehler und nie wieder ein @-Zeichen. Alles Kuenftige ist
schon gelesen, bevor es geschrieben wurde. Niemand wuerde den
Zusammenhang je finden -- man merkt nur, dass "die
Benachrichtigungen nicht gehen".
Gefunden beim Bauen der Erwaehnungen: Die Pruefung setzte zum
Aufraeumen 99999 und wunderte sich danach, warum das frische
"@" nicht leuchtete. Der Fehler lag nicht in der Erwaehnung.
Der Browser schickt heute immer die Nummer der letzten
gesehenen Nachricht -- er ist also nicht der Grund. Aber eine
Grenze, die nur davon lebt, dass der Aufrufer sich benimmt,
ist keine.
ABGELEITET STATT GERATEN: Weiter als bis zur juengsten
Nachricht dieses Raums kann niemand gelesen haben. */
const neueste = db().prepare(
"SELECT COALESCE(MAX(id), 0) AS n FROM chat_nachrichten WHERE raum_id = ?")
.get(raumId).n;
const stand = Math.max(0, Math.min(bis, neueste));
/* NUR VORWÄRTS. Ein zu spät eintreffender Aufruf einer älteren
Ansicht darf den Stand nicht zurückdrehen -- sonst stünde eine
gelesene Nachricht wieder als ungelesen da. */
db().prepare(`UPDATE chat_teilnehmer SET gelesen_bis = ?
WHERE raum_id = ? AND person_id = ? AND gelesen_bis < ?`)
.run(stand, raumId, req.person.id, stand);
res.json({ ok: true });
} catch (fehler) {
console.error("[chat] Gelesen:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* =====================================================================
ANKUENDIGUNGEN ANHEFTEN (10.09.2026, Kapitel 7.2)
"Ankuendigungs-Funktion: Pin-Nachrichten von Owner/rechte Hand an
alle."
KEINE ZWEITE SORTE NACHRICHT. Naheliegend waere eine eigene Tabelle
"ankuendigungen" gewesen -- und damit ein zweiter Verlauf mit
eigenen Rechten, eigener Suche, eigenem Loeschen. Angeheftet wird
deshalb eine ganz normale Nachricht: Sie steht im Verlauf, sie ist
ueber die Suche zu finden, sie laesst sich zuruecknehmen, und sie
traegt zusaetzlich ein Datum und einen Namen.
WAS PASSIERT, WENN DER ABSENDER SIE ZURUECKNIMMT: Sie faellt von
selbst ab (siehe unten im Zuruecknehmen). Ein Aushang, dessen Text
"Nachricht zurueckgenommen" lautet, waere die schlechteste aller
Antworten -- er steht oben, faellt auf und sagt nichts.
===================================================================== */
chatRouter.put("/workspace/api/chat/nachrichten/:id/anheften", gleicheHerkunft,
express.json({ limit: "2kb" }), (req, res) => {
try {
const id = Number(req.params.id);
if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
const d = db();
const n = d.prepare(
"SELECT id, raum_id, weg_am, angeheftet_am FROM chat_nachrichten WHERE id = ?").get(id);
/* Erst die Mitgliedschaft (404 -- was man nicht sehen darf,
existiert nicht), dann das Recht (403 -- man sieht es, darf es
aber nicht). Zwei verschiedene Antworten fuer zwei verschiedene
Faelle; sie zu vermischen hiesse, ueber die eine die andere
verraten zu koennen. */
if (!n || !istDrin(n.raum_id, req.person)) {
return res.status(404).json({ fehler: "nicht_gefunden" });
}
if (!darfAnheften(req.person, n.raum_id)) {
return res.status(403).json({ fehler: "Anheften darf nur die Leitung." });
}
const an = req.body?.an !== false;
if (an && n.weg_am) {
return res.status(400).json({ fehler: "Eine zurückgenommene Nachricht geht nicht." });
}
if (an && !n.angeheftet_am) {
const schon = d.prepare(`SELECT COUNT(*) AS c FROM chat_nachrichten
WHERE raum_id = ? AND angeheftet_am IS NOT NULL AND weg_am IS NULL`).get(n.raum_id).c;
if (schon >= PIN_MAX) {
return res.status(409).json({
fehler: `Es hängen schon ${PIN_MAX} oben. Löse zuerst eine ab.`,
});
}
}
d.prepare("UPDATE chat_nachrichten SET angeheftet_am = ?, angeheftet_von = ? WHERE id = ?")
.run(an ? jetzt() : null, an ? req.person.id : null, id);
/* ALLE IM RAUM SEHEN ES SOFORT. Ein Aushang, den die anderen erst
beim naechsten Laden bemerken, ist bei einer kurzfristigen
Ansage genau einen Live-Abend zu spaet. Keine Push-Meldung
dazu: Das Anheften ist kein neuer Satz, sondern eine Betonung. */
chatEreignis(n.raum_id, { raum_id: n.raum_id, id, angeheftet: an }, [], "pin");
protokolliere(an ? "chat_angeheftet" : "chat_abgeheftet", {
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
detail: `#${id} in Raum #${n.raum_id}`,
});
res.json({ ok: true, angeheftet: an });
} catch (fehler) {
console.error("[chat] Anheften:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* =====================================================================
LÖSCHEN HEISST LÖSCHEN (22.09.2026)
=====================================================================
Filipe: „Gelöschte Nachrichten verschwinden vollständig – keine
Spur, kein ‚wurde gelöscht'-Hinweis, bei niemandem, auch nicht bei
DogFather." Und: „Löschen darf weiterhin jeder nur seine eigenen –
außer DogFather und rechte Hand: die dürfen jede Nachricht löschen,
für den Notfall."
---------------------------------------------------------------------
WAS SICH DAMIT UMDREHT
Hier stand bis heute das Gegenteil, und zwar begründet: „Ein Loch im
Verlauf wirft mehr Fragen auf als der Hinweis, dass hier etwas
zurückgenommen wurde." Die Zeile blieb, der Text wurde geleert, und
der Chat zeigte „Nachricht zurückgenommen".
Das Argument war nicht falsch -- es beantwortet nur eine andere
Frage als die, die Filipe stellt. Ein Hinweis „hier stand etwas"
ist für den, der gelöscht hat, oft schlimmer als der Satz selbst:
Er markiert die Stelle. Wer etwas aus Versehen schreibt, will es
weg haben und nicht unterstrichen.
DESHALB JETZT EIN ECHTES DELETE. Das geht sauber, weil die beiden
abhängigen Tabellen es mittragen:
chat_reaktionen ... REFERENCES chat_nachrichten(id) ON DELETE CASCADE
chat_erwaehnungen ... REFERENCES chat_nachrichten(id) ON DELETE CASCADE
und `PRAGMA foreign_keys = ON` beim Öffnen steht. Nachgesehen, nicht
angenommen.
DREI DINGE, DIE SONST EINE SPUR HINTERLIESSEN:
1. `antwort_auf` zeigt weiter auf die Nummer. Der Verlauf holt das
Zitat über einen LEFT JOIN -- es kommt nichts mehr zurück, und
die Anzeige lässt das Zitat dann weg. Ein Zitat auf etwas, das
es nicht gibt, wäre die Spur.
2. `letzte_am` am Raum. War die gelöschte die letzte Nachricht,
stünde die Gesprächsliste weiter auf ihrem Zeitpunkt -- ein
Raum, der ganz oben steht und nichts Neues hat. Wird neu
gerechnet.
3. Der Anhang auf der Platte. Das war schon vorher richtig gelöst
und bleibt so: erst die Zeile, dann die Datei.
WAS BLEIBT: die Protokollzeile. Sie nennt WER WESSEN Nachricht
gelöscht hat -- keinen Text, keinen Inhalt. Beim Notfall-Löschen
durch DogFather oder die rechte Hand ist das der Unterschied
zwischen einer Befugnis und einer unsichtbaren Macht. Das Protokoll
ist kein Chatverlauf; es steht an einer anderen Stelle und
beantwortet eine andere Frage.
===================================================================== */
/** Wer JEDE Nachricht löschen darf -- für den Notfall.
*
* NICHT `fuehrtTeamDogi`: Das schlösse die linke Hand ein, und Filipe
* hat ausdrücklich zwei genannt. Nicht `istLeitung`: Das schlösse
* Spicy Media ein -- die private Chats ausdrücklich nicht einmal
* sehen darf. Zwei Rollen, wörtlich die zwei aus dem Auftrag. */
const darfJedeNachrichtLoeschen = (person) =>
istDogFather(person) || person?.rolle === "hand";
chatRouter.delete("/workspace/api/chat/nachrichten/:id", gleicheHerkunft, (req, res) => {
try {
const id = Number(req.params.id);
if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
const d = db();
const n = d.prepare(
"SELECT id, raum_id, person_id, anhang_datei FROM chat_nachrichten WHERE id = ?").get(id);
if (!n || !istDrin(n.raum_id, req.person)) {
return res.status(404).json({ fehler: "nicht_gefunden" });
}
const fremd = n.person_id !== req.person.id;
if (fremd && !darfJedeNachrichtLoeschen(req.person)) {
return res.status(403).json({ fehler: "Nur eigene Nachrichten." });
}
const dateiWeg = n.anhang_datei;
/* ERST DIE ZEILE, DANN DIE DATEI. Scheitert das Entfernen (Datei
schon weg), ist der Verweis trotzdem fort -- andersherum bliebe
im schlechten Fall eine Zeile ohne Datei stehen. */
d.prepare("DELETE FROM chat_nachrichten WHERE id = ?").run(id);
if (dateiWeg) {
try { unlinkSync(join(ANHANG_ORDNER, dateiWeg)); }
catch (f) { if (f?.code !== "ENOENT") console.error("[chat] Anhang bleibt liegen:", f?.message); }
}
/* DER RAUM RECHNET SEINEN LETZTEN ZEITPUNKT NEU. Ohne das stuende
er in der Liste weiterhin ganz oben, mit einem Zeitpunkt, zu dem
es nichts mehr gibt. */
d.prepare(`UPDATE chat_raeume
SET letzte_am = (SELECT MAX(erstellt) FROM chat_nachrichten WHERE raum_id = ?)
WHERE id = ?`).run(n.raum_id, n.raum_id);
const empfaenger = teilnehmerVon(n.raum_id).map((t) => t.id);
/* `geloescht: true` STATT `zurueckgenommen`. Das Wort entscheidet,
was der Browser tut: Das alte hiess "zeig einen Hinweis", das
neue heisst "nimm es aus dem Bild". Beides gleichzeitig zu
schicken waere die Fassung, bei der eine alte Seite den Hinweis
weiter anzeigt. */
chatEreignis(n.raum_id, { id, raum_id: n.raum_id, geloescht: true }, [], "weg");
protokolliere("chat_geloescht", {
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
detail: fremd ? `#${id} (fremde Nachricht von #${n.person_id})` : `#${id}`,
});
res.json({ ok: true, geloescht: true, empfaenger: empfaenger.length });
} catch (fehler) {
console.error("[chat] Löschen:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* =====================================================================
Sofort zusehen (Server-Sent Events)
=====================================================================
WARUM SSE UND NICHT NACHFRAGEN IM TAKT: Ein Chat, der alle fünf
Sekunden nachfragt, ist fünf Sekunden langsam und stellt bei zehn
Angemeldeten 7200 Anfragen in der Stunde -- für Nachrichten, die es
meistens nicht gibt.
WARUM SSE UND NICHT WEBSOCKET: Hier fliesst alles in EINE Richtung,
vom Server zum Browser. Geschrieben wird über die normale
Schnittstelle. SSE ist dafür gebaut, kommt ohne fremde Bibliothek
aus und übersteht einen Verbindungsabriss von selbst -- der Browser
verbindet sich neu, ohne dass man dafür Code schreibt.
Der Browser holt sich nach einem Abriss die Lücke über den normalen
Verlauf nach; deshalb ist hier keine Nachrichtenwarteschlange nötig. */
/** Wer sieht gerade zu: Personennummer → Menge offener Verbindungen.
* Eine Person kann an zwei Geräten sitzen. */
const zuschauer = new Map();
/**
* @param erwaehnte Wer in DIESER Nachricht mit "@" angesprochen wurde.
* Diese Menge bekommt eine ANDERE Meldung, nicht eine zweite
* (20.09.2026). Sie steht hier und nicht an der Aufrufstelle,
* weil der Kommentar unten es verlangt: Die Entscheidung "wer
* bekommt was" gehoert an EINE Stelle.
*/
function chatEreignis(raumId, nachricht, benachrichtigen, art = "neu",
erwaehnte = new Set(), rudel = false) {
/* 1. An alle offenen Verbindungen der Beteiligten. */
const leute = teilnehmerVon(raumId).map((t) => t.id);
for (const personId of leute) {
for (const antwort of zuschauer.get(personId) || []) {
try {
antwort.write(`event: ${art}\ndata: ${JSON.stringify(nachricht)}\n\n`);
} catch { /* die Verbindung räumt sich selbst ab */ }
}
}
/* 2. Eine Benachrichtigung an die, die NICHT zusehen. Wer die Seite
offen hat, sieht die Nachricht ohnehin -- ihm auch noch eine
Meldung aufs Handy zu schicken, ist der schnellste Weg, dass er
Benachrichtigungen abschaltet. */
for (const personId of benachrichtigen) {
/* `.size` UND NICHT `.length` (berichtigt 19.09.2026).
`zuschauer` haelt Mengen (`new Set()`), und eine Menge hat kein
`length` -- der Ausdruck war IMMER `undefined`, also immer
falsch, also wurde nie uebersprungen. Folge: Wer die Seite offen
hatte, bekam zusaetzlich zur Nachricht auf dem Bildschirm noch
eine Meldung aufs Handy.
Genau davor warnt der Kommentar drei Zeilen darueber: „der
schnellste Weg, dass er Benachrichtigungen abschaltet". Die
Absicht stand da, die Zeile tat das Gegenteil -- und `siehtZu()`
weiter unten macht es mit `.size` schon richtig. Gefunden beim
Nachverfolgen eines ganz anderen Fehlers. */
if ((zuschauer.get(personId) || new Set()).size) continue;
/* DIE ART GEHT MIT (18.09.2026). Sie stand als Parameter oben und
endete im Ereignisstrom -- die Benachrichtigung bekam sie nie zu
sehen und behandelte deshalb JEDES Ereignis als Chatnachricht.
Bei einem Anruf kam dabei woertlich „Nachricht von [object
Object]" heraus. */
/* ANGESPROCHEN ODER NUR DABEI? Der Unterschied entscheidet ueber
Wortlaut UND Art -- und die Art kann jeder einzeln abschalten.
Wer den Chat stumm stellt, weil dort viel geredet wird, will
trotzdem wissen, wenn ihn jemand direkt anspricht. */
/* DREI STUFEN STATT ZWEI (23.09.2026): nur dabei -- angesprochen
-- das ganze Rudel gerufen. Der Unterschied steht im WORTLAUT,
nicht in einer zweiten Meldung: "Anna hat das Rudel gerufen"
sagt sofort, dass es alle betrifft und nicht nur mich.
AUF DEMSELBEN SCHALTER WIE DIE ERWAEHNUNG, mit Absicht (siehe
meldeNeueNachricht). Ein Ruf ans Team IST eine Erwaehnung -- nur
eben von allen. Ein eigener vierter Schalter waere der, den
jemand abschaltet und der dann genau im wichtigen Moment fehlt. */
void meldeNeueNachricht(personId, raumId, nachricht,
art === "neu" && erwaehnte.has(personId)
? (rudel ? "rudel" : "erwaehnung")
: art);
}
}
/** Die Push-Benachrichtigung. Absichtlich träge geladen: Der Chat soll
* auch dann laufen, wenn am Push-Teil etwas klemmt. */
/** Was in der Benachrichtigung steht.
*
* ALS EIGENE FUNKTION UND EXPORTIERT, damit eine Pruefung sie lesen
* kann, ohne einen Push-Dienst nachzubauen. Genau hier stand der
* Fehler, den Filipe am 18.09.2026 gemeldet hat -- und er war von
* aussen nicht messbar, weil der Text tief in einer Funktion entstand,
* die nur der Push-Weg aufruft.
*
* @param art "anruf" oder alles andere
* @returns {{titel: string, text: string, ziel: string}}
*/
export function pushTextFuer(art, nachricht, raumId) {
const ziel = `/workspace/chat.html?raum=${raumId}`;
/* ---- EIN ANRUF IST KEINE NACHRICHT ----------------------------
Filipe: „wenn ich vanvan anrufe kriegt sie nur eine benarichtigung
aber keinen anruf was soll das."
Gemessen kam bei ihr an:
Nachricht von [object Object]
(kein Text)
Zwei Fehler auf einmal. `nachricht.von` ist beim Klingeln ein
OBJEKT (`{id, name}`) und keine Zeichenkette -- aus der Vorlage
wurde deshalb „[object Object]". Und einen `text` gibt es bei
einem Anruf gar nicht, also blieb die Zeile leer.
Dass es so weit kam, lag daran, dass die ART des Ereignisses hier
nie ankam: Jedes Ereignis wurde als Chatnachricht behandelt, auch
das Klingeln. */
if (art === "anruf") {
const wer = nachricht.von?.name || "Jemand";
return {
titel: `${wer} ruft an`,
text: nachricht.video ? "Videoanruf – tippen zum Rangehen"
: "Tippen zum Rangehen",
ziel,
};
}
const wer = typeof nachricht.von === "string"
? nachricht.von : (nachricht.von?.name || "jemandem");
/* ---- ANGESPROCHEN IST ETWAS ANDERES ALS DABEI (20.09.2026) ----
"Nachricht von Anna" sagt nicht, dass sie DICH meint. In einem
Raum mit acht Leuten ist das der Unterschied zwischen "kann
warten" und "gleich nachsehen" -- und genau diesen Unterschied
soll das Markieren mit "@" machen. Steht er nicht in der Meldung,
ist das Markieren nur Farbe.
Der Anfang der Nachricht bleibt darunter stehen, wie sonst auch:
Wer auf dem Sperrbildschirm liest, soll nicht oeffnen muessen, um
zu erfahren, ob es wichtig war. */
if (art === "erwaehnung") {
return {
titel: `${wer} hat dich erwähnt`,
text: String(nachricht.text || "").slice(0, 120),
ziel,
};
}
/* ---- DAS GANZE RUDEL (23.09.2026) ----------------------------
Filipe: „dann sollen alle eine benarichtigung bekommen."
WARUM NICHT EINFACH „hat dich erwähnt": Weil es nicht stimmt.
Beim Rudel ist man nicht gemeint, sondern mitgemeint -- und wer
dreimal „hat dich erwähnt" liest und jedes Mal feststellt, dass
es alle betraf, glaubt beim vierten Mal auch dem echten nicht
mehr. Der Wortlaut sagt deshalb, was los ist.
ES IST TROTZDEM DIESELBE ART von Meldung (chat_erwaehnung, siehe
meldeNeueNachricht) -- ein Ruf ans Team ist eine Erwähnung, nur
eben von allen. */
if (art === "rudel") {
return {
titel: `${wer} hat das Rudel gerufen`,
text: String(nachricht.text || "").slice(0, 120),
ziel,
};
}
return {
titel: `Nachricht von ${wer}`,
/* Der Anfang der Nachricht steht in der Meldung -- eine
Benachrichtigung, die nur "Neue Nachricht" sagt, zwingt zum
Öffnen, um zu erfahren, ob es wichtig war. */
text: String(nachricht.text || "").slice(0, 120)
|| anhangWort(nachricht.anhang?.art),
ziel,
};
}
async function meldeNeueNachricht(personId, raumId, nachricht, art = "neu") {
try {
const { benachrichtige } = await import("./workspace-push.js");
/* ---- EIN ANRUF IST KEINE NACHRICHT (18.09.2026) --------------
Filipe: „wenn ich vanvan anrufe kriegt sie nur eine
benarichtigung aber keinen anruf was soll das."
Gemessen kam bei ihr an:
Nachricht von [object Object]
(kein Text)
Zwei Fehler auf einmal. `nachricht.von` ist beim Klingeln ein
OBJEKT (`{id, name}`) und keine Zeichenkette -- aus der Vorlage
wurde deshalb „[object Object]". Und einen `text` gibt es bei
einem Anruf gar nicht, also blieb die Zeile leer.
Dass es ueberhaupt so weit kam, lag daran, dass die ART des
Ereignisses hier nie ankam: Jedes Ereignis wurde als
Chatnachricht behandelt, auch das Klingeln.
Jetzt steht dort, was los ist -- und beim Tippen landet man im
richtigen Gespraech, wo es dank der Route `/anruf/offen` auch
wirklich klingelt. */
/* ALS EIGENE ART, wenn es ein Anruf ist. Sie umgeht die Ruhezeit
und laesst sich getrennt abschalten -- siehe workspace-push.js. */
/* DREI ARTEN, DREI SCHALTER. Jede laesst sich einzeln abschalten
(siehe ARTEN in workspace-push.js) -- und genau darum geht es:
Wer den lauten Chat stumm stellt, verliert damit weder Anrufe
noch die Faelle, in denen ihn jemand direkt anspricht. */
const pushArt = art === "anruf" ? "anruf"
/* Der Ruf ans Rudel laeuft ueber DENSELBEN Schalter wie die
Erwaehnung. Kein vierter Schalter: Wer "@rudel" stummschaltet,
schaltet den Fall stumm, in dem das ganze Team gebraucht wird
-- und genau dafuer gibt es ihn. Wem es zu viel wird, der sagt
es demjenigen, der ruft; im Protokoll steht, wer das war. */
: (art === "erwaehnung" || art === "rudel") ? "chat_erwaehnung"
: "chat_nachricht";
await benachrichtige(personId, pushArt, pushTextFuer(art, nachricht, raumId));
} catch (fehler) {
console.error("[chat] Benachrichtigung:", fehler?.message);
}
}
chatRouter.get("/workspace/api/chat/strom", (req, res) => {
res.set({
"Content-Type": "text/event-stream",
"Cache-Control": "no-cache, no-transform",
Connection: "keep-alive",
/* Ohne das puffert ein davorliegender Reverse Proxy (Caddy, nginx)
den Strom -- und dann kommt die Nachricht erst, wenn genug
zusammen ist. Genau das Gegenteil des Zwecks. */
"X-Accel-Buffering": "no",
});
res.flushHeaders?.();
res.write("retry: 3000\n\n");
const personId = req.person.id;
if (!zuschauer.has(personId)) zuschauer.set(personId, new Set());
zuschauer.get(personId).add(res);
/* Ein Lebenszeichen alle 25 Sekunden. Ohne das schliessen manche
Vermittlungsstellen die Verbindung nach einer Minute Stille -- der
Browser verbindet sich dann zwar neu, aber jedes Mal mit einer
Lücke von ein paar Sekunden. */
const puls = setInterval(() => {
try { res.write(": puls\n\n"); } catch { /* gleich weg */ }
}, 25_000);
puls.unref?.();
const aufraeumen = () => {
clearInterval(puls);
const menge = zuschauer.get(personId);
if (menge) {
menge.delete(res);
if (!menge.size) zuschauer.delete(personId);
}
};
req.on("close", aufraeumen);
req.on("error", aufraeumen);
});
/** Wie viele Nachrichten warten insgesamt auf mich?
* Für die Zahl in der Kopfleiste -- eine Abfrage statt einer je Raum. */
chatRouter.get("/workspace/api/chat/ungelesen", (req, res) => {
try {
const z = db().prepare(`
SELECT COUNT(*) AS n FROM chat_nachrichten m
JOIN chat_teilnehmer t ON t.raum_id = m.raum_id AND t.person_id = ?
WHERE t.raus_am IS NULL AND m.id > t.gelesen_bis AND m.id > t.geloescht_bis
AND m.person_id <> ?`)
.get(req.person.id, req.person.id);
res.json({ ungelesen: z?.n || 0 });
} catch (fehler) {
console.error("[chat] Ungelesen:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
}
});
/* ---------- Fehler aus express.raw ---------------------------------------
Ist die Datei zu gross, bricht express.raw ab, BEVOR der eigene Code
laeuft -- das try/catch dort greift also nicht, und der Fehler landet
im allgemeinen Behandler als HTTP 500. Fuer den Absender saehe das
aus wie ein kaputter Server statt wie "Datei zu gross"; er wuerde es
wieder und wieder versuchen. Derselbe Behandler steht aus demselben
Grund in workspace-dateien.js.
Er muss ZULETZT stehen: Express erkennt ihn an den vier Parametern
und ruft ihn nur fuer Fehler aus den Routen davor auf. */
// eslint-disable-next-line no-unused-vars
chatRouter.use((fehler, req, res, next) => {
if (!req.path.startsWith("/workspace/api/chat")) return next(fehler);
if (fehler?.type === "entity.too.large" || fehler?.status === 413) {
return res.status(413).json({
fehler: `Zu groß – erlaubt sind ${Math.round(ANHANG_MAX / 1024 / 1024)} MB je Datei.`,
});
}
console.error("[chat] Unerwartet:", fehler?.message);
res.status(503).json({ fehler: "nicht_verfuegbar" });
});
/* Für Prüfungen und andere Module: Sieht diese Person gerade zu? */
/* =====================================================================
EINE NACHRICHT AUS EINEM ANDEREN MODUL SCHICKEN (11.09.2026)
Gebraucht vom Entwicklungs-Bereich: Dort steht, was DogFather und die
rechte Hand ueber die Zeit beobachten -- und die Person selbst sieht
diesen Bereich nicht. Damit Anerkennung trotzdem ankommt, laesst sich
ein Eintrag als Nachricht schicken.
WARUM HIER UND NICHT DORT: Ein Zweier-Gespraech darf es nur EINMAL
geben (siehe direktRaum), die Leseraender muessen mitwandern, der
Live-Strom und die Benachrichtigung haengen daran. Wer das im
Nachbarmodul nachbaut, hat zwei Fassungen -- und die zweite ist die,
in der jemand eine Nachricht nicht bekommt.
DIE REGEL "wer darf mit wem" WIRD MITGEPRUEFT, obwohl der einzige
Aufrufer heute ohnehin darf. Eine Funktion, die aus einem fremden
Modul heraus jeden erreichen kann, ist genau die Abkuerzung, die man
spaeter woanders benutzt.
===================================================================== */
export function nachrichtSchicken(person, anId, text) {
const ziel = Number(anId);
const satz = String(text ?? "").trim().slice(0, TEXT_MAX);
if (!person || !Number.isInteger(ziel) || ziel < 1 || !satz) return null;
if (!darfSchreibenMit(person, ziel)) return null;
if (!db().prepare("SELECT 1 FROM personen WHERE id = ? AND aktiv = 1").get(ziel)) return null;
const raumId = direktRaum(person, ziel);
const d = db();
const n = jetzt();
d.prepare("INSERT INTO chat_nachrichten (raum_id, person_id, text, erstellt) VALUES (?,?,?,?)")
.run(raumId, person.id, satz, n);
const id = d.prepare("SELECT last_insert_rowid() AS id").get().id;
d.prepare("UPDATE chat_raeume SET letzte_am = ? WHERE id = ?").run(n, raumId);
d.prepare("UPDATE chat_teilnehmer SET gelesen_bis = ? WHERE raum_id = ? AND person_id = ?")
.run(id, raumId, person.id);
const nachricht = {
id, raum_id: raumId, von_id: person.id, von: person.name,
rolle: person.rolle, text: satz, erstellt: n,
zurueckgenommen: false, antwort: null, anhang: null,
};
chatEreignis(raumId, nachricht, [ziel], "neu");
return { id, raum_id: raumId };
}
/* =====================================================================
WAS DER ANRUF BRAUCHT (18.09.2026)
Drei Dinge, und alle drei gibt es hier schon: den Ereigniskanal, die
Zugangspruefung und die Teilnehmerliste. Sie werden ausdruecklich
hier freigegeben und nicht drueben nachgebaut -- eine zweite Fassung
von „wer darf in diesen Raum" waere die, die beim naechsten Umbau
nicht mitgeaendert wird, und genau daran haengt, wer mithoeren kann.
`istDrinFuerAnruf` und `teilnehmerFuerAnruf` heissen nicht wie die
inneren Funktionen, die sie weiterreichen: Die Namen sagen, WOFUER
sie freigegeben sind. Wer sie spaeter aendert, sieht am Namen, dass
noch jemand daran haengt.
===================================================================== */
/** Darf diese Person in diesem Raum telefonieren?
* Dieselbe Regel wie fuers Mitlesen -- es ist dieselbe Frage. */
export function istDrinFuerAnruf(raumId, person) {
return istDrin(raumId, person);
}
/** Wer ist in diesem Raum? Fuer die Frage „wie viele koennen mitmachen". */
export function teilnehmerFuerAnruf(raumId) {
return teilnehmerVon(raumId);
}
/** Der Ereigniskanal -- der Hinweg fuer Klingeln und Verbindungsdaten. */
export { chatEreignis };
export function siehtZu(personId) {
return (zuschauer.get(Number(personId)) || []).size > 0;
}
Reference in New Issue View Git Blame Copy Permalink