DogFatherGitandClaude Opus 5
e43fe97550
Filipe: „das mit dem anruf klappt nicht … es geeeeeht einfach nicht." NACHGEMESSEN WAR SERVERSEITIG ALLES IN ORDNUNG: Der Anruf kam an (Protokoll), der Raum stimmte (Dogfather + VanVan), sie war angemeldet (Sitzung bis morgen frueh), sie hat ein Geraet fuer Benachrichtigungen, und der neue Code lief. Trotzdem ging es nicht -- und zwar aus zwei Gruenden, die beide nichts mit Technik zu tun haben, sondern mit Zeit und Sichtbarkeit. 1. 45 SEKUNDEN SIND KEIN KLINGELN. Bei einem Telefon hebt man ab. Hier muss in dieselben Sekunden: Benachrichtigung zustellen, bemerken, Handy entsperren, antippen, App laden, Anmeldung pruefen. Das reicht, wenn man das Geraet in der Hand haelt -- und sonst nie. Jetzt zwei Minuten: lang genug, um aus der Tasche zu kommen, kurz genug, dass niemand vor einem Anruf sitzt, den es nicht mehr gibt. 2. UND DANACH WAR ES, ALS WAERE NIE ETWAS GEWESEN. Ein verpasster Anruf verschwand lautlos: keine Zeile, kein Hinweis, nicht einmal, DASS jemand angerufen hat. Genau das fuehlt sich an wie „geht nicht", auch wenn alles funktioniert hat. Jedes Telefon der Welt zeigt einen verpassten Anruf; jetzt steht er als Zeile im Gespraech, beim Anrufer, mit Uhrzeit. Geprueft: pruef-anruf 95 -> 100. Der neue Abschnitt misst den echten Ablauf (anrufen, niemand geht ran, Zeile erscheint) und dass sie NUR EINMAL erscheint -- `aufraeumen()` laeuft bei jeder Anfrage mit. Dafuer ist die Klingeldauer ueber die Umgebung einstellbar: Eine Pruefung, die zwei Minuten wartet, wird abgeschaltet, und dann waere der verpasste Anruf wieder ungeprueft. Im Betrieb steht die Variable nirgends. Und noch ein eigener Messfehler: Die Pruefung las zuerst /api/chat/raum/:id -- die Route heisst /api/chat/raeume/:id/nachrichten. Sie meldete „0 Nachrichten, vorher wie nachher" und sah damit aus wie ein Befund ueber den Code. Co-Authored-By: Claude Opus 5 <[email protected]>
552 lines
24 KiB
JavaScript
552 lines
24 KiB
JavaScript
/* =====================================================================
|
||
TELEFONIEREN IM CHAT (18.09.2026)
|
||
|
||
Filipe: „kann man machen dass die modis, rechte hand und ich auch
|
||
telefonieren können im chat?" -- und nach dem Plan: „ich will dass du
|
||
das nimmst was man selbst in die app reinsetzten kann, nicht meinen
|
||
pc belastet und trotzdem vielleicht in gruppe, mit video oder
|
||
einzelnd, alles was möglich ist."
|
||
|
||
---------------------------------------------------------------------
|
||
WAS HIER PASSIERT -- UND WAS AUSDRÜCKLICH NICHT
|
||
|
||
Der Ton geht NICHT über diesen Server. Er geht direkt von einem
|
||
Browser zum anderen (WebRTC). Dieser Server tut nur das, was die
|
||
beiden allein nicht können: Er reicht die Verbindungsdaten weiter,
|
||
damit sie sich finden. Das sind ein paar Kilobyte je Anruf --
|
||
danach ist er aus dem Spiel.
|
||
|
||
DAS IST DIE ANTWORT AUF „NICHT MEINEN PC BELASTEN":
|
||
Bei zwei Teilnehmern kodiert jedes Gerät genau einen Strom und
|
||
dekodiert einen. Das ist die Last eines gewöhnlichen Videoanrufs.
|
||
Erst bei GRUPPEN wächst sie -- dazu unten mehr.
|
||
|
||
---------------------------------------------------------------------
|
||
WARUM ES KEINEN NEUEN DIENST BRAUCHT
|
||
|
||
Der Chat hat bereits alles, was die Signalisierung verlangt:
|
||
|
||
`chatEreignis()` schickt an alle offenen Verbindungen eines Raums
|
||
(SSE) -- der Hinweg für Angebot, Antwort und
|
||
Verbindungswege.
|
||
Push weckt die, die gerade nicht zusehen -- das
|
||
Klingeln.
|
||
`chat_raeume` kennt Räume mit beliebig vielen Teilnehmern --
|
||
Einzelgespräch ist der Sonderfall „genau zwei".
|
||
|
||
Ein Anruf ist damit kein neues Konzept, sondern ein Ereignis mehr in
|
||
einem Kanal, den es gibt. Ein eigener WebSocket-Dienst daneben wäre
|
||
eine zweite Verbindung, die dieselbe Frage beantwortet -- und die
|
||
zweite ist die, die beim nächsten Umbau vergessen wird.
|
||
|
||
---------------------------------------------------------------------
|
||
DIE GRENZEN, EHRLICH AUFGESCHRIEBEN
|
||
|
||
1. ZU ZWEIT ist die Last minimal und es funktioniert überall.
|
||
|
||
2. IN DER GRUPPE verbindet sich jeder mit jedem. Bei drei Leuten
|
||
sind das zwei Ströme hin und zwei zurück, bei vier je drei. Ab
|
||
etwa vier Teilnehmern wird das auf schwächeren Geräten spürbar.
|
||
Die Grenze steht deshalb als Zahl im Code (GRUPPE_MAX) und nicht
|
||
im Gedächtnis -- wer sie erhöht, soll sehen, was daran hängt.
|
||
|
||
Der saubere Weg darüber hinaus wäre ein Medienserver (SFU), der
|
||
die Ströme verteilt: Dann sendet jedes Gerät nur EINMAL. Der
|
||
läuft auf unserem Server, nicht auf Filipes Rechner -- aber er
|
||
ist ein eigener Dienst mit eigener Wartung. Das ist der nächste
|
||
Schritt, nicht dieser.
|
||
|
||
3. AUF DEM IPHONE hört der Ton auf, sobald der Bildschirm ausgeht
|
||
oder Safari in den Hintergrund rutscht. Das ist eine Regel von
|
||
Apple für alle Web-Anwendungen und lässt sich nicht umgehen. Es
|
||
klingelt zuverlässig -- wer rangeht, muss die Seite offen lassen.
|
||
|
||
4. OHNE EIGENEN TURN-SERVER kommen etwa 15 bis 25 Prozent der
|
||
Verbindungen nicht zustande (strenge Firmennetze, manche
|
||
Mobilfunknetze). Die Adressen stehen in den Einstellungen und
|
||
lassen sich nachtragen, ohne eine Zeile Code zu ändern.
|
||
===================================================================== */
|
||
import express from "express";
|
||
import {
|
||
db, sitzungLesen, protokolliere, echteIp, einstellung, einstellungSetzen,
|
||
istDogFather,
|
||
} from "./workspace.js";
|
||
import { chatEreignis, istDrinFuerAnruf, teilnehmerFuerAnruf } from "./workspace-chat.js";
|
||
import { mitZugangsdaten } from "./workspace-turn.js";
|
||
|
||
export const anrufRouter = express.Router();
|
||
|
||
/** Wie viele gleichzeitig -- und warum diese Zahl.
|
||
*
|
||
* Jeder verbindet sich mit jedem: Bei N Teilnehmern sendet jedes
|
||
* Gerät N-1 Ströme und empfängt N-1. Bei vier sind das je drei, und
|
||
* drei Videoströme zu kodieren merkt ein älteres Handy deutlich.
|
||
*
|
||
* VIER IST DIE GRENZE, AN DER ES NOCH ANGENEHM IST. Wer sie erhöht,
|
||
* erhöht die Last quadratisch -- deshalb steht sie hier und nicht
|
||
* verstreut in drei Abfragen. */
|
||
export const GRUPPE_MAX = 4;
|
||
|
||
/** Wie lange ein Anruf im Raum „klingelt", bevor er von selbst verfällt.
|
||
*
|
||
* Ohne diese Grenze bliebe ein Anruf, bei dem der Anrufer die Seite
|
||
* schließt, für immer offen stehen -- und der Angerufene sähe eine
|
||
* Einladung zu einem Gespräch, an dem niemand mehr teilnimmt.
|
||
*
|
||
* ---------------------------------------------------------------------
|
||
* WARUM ZWEI MINUTEN UND NICHT 45 SEKUNDEN (18.09.2026)
|
||
*
|
||
* Filipe: „das mit dem anruf klappt nicht … es geeeeeht einfach
|
||
* nicht." Nachgemessen war serverseitig alles in Ordnung: Der Anruf
|
||
* kam an, der Raum stimmte, die Angerufene war angemeldet und hatte
|
||
* ein Gerät für Benachrichtigungen.
|
||
*
|
||
* Nur passte die Zeit nicht zum Weg. Bei einem Telefon hebt man ab --
|
||
* hier muss in dieselben Sekunden: Benachrichtigung zustellen, sie
|
||
* bemerken, Handy entsperren, antippen, App laden, Anmeldung prüfen.
|
||
* 45 Sekunden reichen dafür, wenn man das Gerät in der Hand hält, und
|
||
* sonst nie.
|
||
*
|
||
* Das ist der Unterschied zwischen „funktioniert" und „funktioniert
|
||
* im Alltag". Zwei Minuten sind lang genug, um aus der Tasche zu
|
||
* kommen, und kurz genug, dass niemand vor einem Anruf sitzt, den es
|
||
* längst nicht mehr gibt. */
|
||
const KLINGELT_SEKUNDEN = Number(process.env.ANRUF_KLINGELT_SEKUNDEN) || 120;
|
||
|
||
/* WARUM UEBER DIE UMGEBUNG UMSTELLBAR: Damit eine Pruefung den Ablauf
|
||
messen kann, ohne zwei Minuten zu warten. Eine Pruefung, die so
|
||
lange braucht, wird abgeschaltet -- und dann ist der verpasste
|
||
Anruf wieder ungeprueft. Im Betrieb steht die Variable nirgends;
|
||
dort gelten die 120 Sekunden. */
|
||
|
||
/* Wer gerade in welchem Raum telefoniert.
|
||
IM SPEICHER, NICHT IN DER DATENBANK: Ein laufender Anruf ist ein
|
||
Zustand dieses Prozesses, kein Datum. Startet der Server neu, ist
|
||
jeder Anruf ohnehin zu Ende -- ein Eintrag in der Datenbank würde
|
||
danach eine Verbindung behaupten, die es nicht mehr gibt. */
|
||
const laufend = new Map(); // raumId -> { seit, wer: Map(personId -> {name, seit}) }
|
||
|
||
/** Räumt ab, was abgelaufen ist. Läuft bei jeder Anfrage mit, statt
|
||
* als Zeitgeber: Ein Zeitgeber, der alle zehn Sekunden über eine
|
||
* leere Liste läuft, ist Arbeit ohne Anlass. */
|
||
function aufraeumen() {
|
||
const jetzt = Date.now();
|
||
for (const [raumId, a] of laufend) {
|
||
if (!a.wer.size) { laufend.delete(raumId); continue; }
|
||
/* Ein Anruf, bei dem seit KLINGELT_SEKUNDEN nur EINER drin ist,
|
||
ist keiner mehr -- der Angerufene ist nicht rangegangen. */
|
||
if (a.wer.size === 1 && jetzt - a.seit > KLINGELT_SEKUNDEN * 1000) {
|
||
laufend.delete(raumId);
|
||
|
||
/* ---- UND ER HINTERLAESST EINE SPUR (18.09.2026) -------------
|
||
|
||
Bisher verschwand ein verpasster Anruf lautlos. Wer zu spaet
|
||
kam, oeffnete den Chat und sah -- nichts. Keine Zeile, kein
|
||
Hinweis, nicht einmal, DASS jemand angerufen hat. Genau das
|
||
fuehlt sich an wie „es geht einfach nicht", auch wenn technisch
|
||
alles funktioniert hat.
|
||
|
||
Jedes Telefon der Welt zeigt einen verpassten Anruf. Hier
|
||
steht er als Zeile im Gespraech, mit Namen und Uhrzeit -- und
|
||
damit hat der andere etwas, worauf er antworten kann.
|
||
|
||
IN EINEM EIGENEN try: Ein Fehler beim Schreiben der Zeile darf
|
||
das Aufraeumen nicht anhalten -- sonst bliebe ein abgelaufener
|
||
Anruf stehen, und das waere schlimmer als eine fehlende
|
||
Notiz. */
|
||
try { verpasstVermerken(raumId, a); } catch (f) {
|
||
console.error("[anruf] verpasst:", f?.message);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/** Schreibt „Verpasster Anruf" in das Gespraech.
|
||
*
|
||
* Als ganz normale Nachricht des Anrufers: So steht sie an der
|
||
* richtigen Stelle im Verlauf, wird mitgezaehlt wie jede andere und
|
||
* braucht keine Sonderbehandlung in der Oberflaeche. */
|
||
function verpasstVermerken(raumId, a) {
|
||
const anrufer = [...a.wer.entries()][0];
|
||
if (!anrufer) return;
|
||
const [id, wer] = anrufer;
|
||
const d = db();
|
||
const n = new Date().toISOString();
|
||
const text = a.video ? "📞 Verpasster Videoanruf" : "📞 Verpasster Anruf";
|
||
d.prepare("INSERT INTO chat_nachrichten (raum_id, person_id, text, erstellt) VALUES (?,?,?,?)")
|
||
.run(raumId, id, text, n);
|
||
const neueId = d.prepare("SELECT last_insert_rowid() AS id").get().id;
|
||
d.prepare("UPDATE chat_raeume SET letzte_am = ? WHERE id = ?").run(n, raumId);
|
||
|
||
/* Die anderen im Raum bekommen sie wie jede Nachricht -- inklusive
|
||
Benachrichtigung, falls sie gerade nicht zusehen. Wer den Anruf
|
||
verpasst hat, sieht wenigstens, DASS er ihn verpasst hat. */
|
||
const andere = teilnehmerFuerAnruf(raumId)
|
||
.map((t) => t.id).filter((x) => x !== id);
|
||
chatEreignis(raumId, {
|
||
id: neueId, raum_id: raumId, von_id: id, von: wer.name,
|
||
text, erstellt: n, zurueckgenommen: false, antwort: null, anhang: null,
|
||
}, andere, "neu");
|
||
}
|
||
|
||
function angemeldet(req, res, next) {
|
||
const person = sitzungLesen(req);
|
||
if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
|
||
req.person = person;
|
||
next();
|
||
}
|
||
|
||
/* GLEICHE HERKUNFT. Ein Anruf ist ein schreibender Vorgang -- er
|
||
klingelt bei jemandem. Dieselbe Pruefung wie ueberall sonst. */
|
||
function gleicheHerkunft(req, res, next) {
|
||
const herkunft = req.get("origin");
|
||
if (!herkunft) return next();
|
||
try {
|
||
if (new URL(herkunft).host === req.get("host")) return next();
|
||
} catch { /* unlesbar -> abweisen */ }
|
||
return res.status(403).json({ fehler: "fremde_herkunft" });
|
||
}
|
||
|
||
anrufRouter.use("/workspace/api/anruf", angemeldet);
|
||
|
||
const nummer = (x) => { const n = Number(x); return Number.isInteger(n) && n > 0 ? n : 0; };
|
||
|
||
/* =====================================================================
|
||
DIE VERBINDUNGSADRESSEN
|
||
|
||
STUN sagt einem Browser, wie er von aussen aussieht. TURN leitet den
|
||
Ton weiter, wenn eine direkte Verbindung nicht zustande kommt.
|
||
|
||
SIE STEHEN IN DEN EINSTELLUNGEN, NICHT IM CODE. Wer einen eigenen
|
||
TURN-Server einrichtet, traegt ihn dort ein -- ohne dass jemand eine
|
||
Zeile aendert und ohne Neustart. Genau daran ist im Haus schon
|
||
einmal etwas gescheitert: Eine Adresse im Quelltext ist eine, die
|
||
beim naechsten Umzug niemand findet.
|
||
|
||
DER STANDARD IST BEWUSST LEER, was STUN angeht: Ein oeffentlicher
|
||
STUN-Dienst (etwa der von Google) bekommt bei jedem Anruf die
|
||
IP-Adresse beider Teilnehmer zu sehen. Das ist fuer ein Team, das
|
||
ueber Moderation und Vorfaelle spricht, keine Kleinigkeit -- und es
|
||
waere eine Entscheidung, die ich nicht still treffen darf. Ohne
|
||
Eintrag funktioniert der Anruf im selben Netz; sobald coturn auf dem
|
||
eigenen Server steht, funktioniert er ueberall.
|
||
===================================================================== */
|
||
anrufRouter.get("/workspace/api/anruf/adressen", (req, res) => {
|
||
try {
|
||
let liste = [];
|
||
try { liste = JSON.parse(einstellung("anruf_adressen") || "[]"); } catch { liste = []; }
|
||
|
||
/* ZUGANGSDATEN WERDEN GERECHNET, NICHT GESPEICHERT.
|
||
Warum das so ist, steht ausfuehrlich in workspace-turn.js. Kurz:
|
||
Ein festes TURN-Passwort laege dauerhaft im Browser jedes
|
||
Teilnehmers und liesse sich nie wieder entziehen. Die hier
|
||
erzeugten verfallen von selbst.
|
||
|
||
Als Kennung die PERSONENNUMMER, nicht der Name -- sie landet im
|
||
Protokoll von coturn, und das ist kein Ort fuer Klarnamen. */
|
||
const { adressen, turn_gesamt, turn_bereit, grund } =
|
||
mitZugangsdaten(liste, `w${req.person.id}`);
|
||
|
||
if (grund) {
|
||
/* DER DRITTE AUSGANG. „Kann nicht nachsehen" ist etwas anderes
|
||
als „ist nicht eingerichtet" -- und wer das verschweigt, sucht
|
||
den Fehler spaeter beim Anrufer. */
|
||
console.warn(`[anruf] TURN-Geheimnis nicht verwendbar: ${grund}`);
|
||
}
|
||
|
||
res.json({
|
||
adressen,
|
||
gruppe_max: GRUPPE_MAX,
|
||
/* WAS DIE OBERFLAECHE WISSEN MUSS, um ehrlich zu sein: Ohne
|
||
Adressen klappt der Anruf nur im selben Netz. Das gehoert
|
||
DAVOR gesagt, nicht als Fehlermeldung danach. */
|
||
nur_gleiches_netz: !Array.isArray(liste) || liste.length === 0,
|
||
/* Zahlen statt Ja/Nein: Wer zaehlen kann, kann pruefen. Ein
|
||
eingetragener TURN-Server, der mangels Geheimnis niemanden
|
||
durchlaesst, sieht sonst genauso aus wie ein funktionierender. */
|
||
turn_gesamt,
|
||
turn_bereit,
|
||
...(grund ? { turn_grund: grund } : {}),
|
||
});
|
||
} catch (f) {
|
||
console.error("[anruf] Adressen:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/** Die Adressen eintragen -- nur DogFather.
|
||
*
|
||
* Es sind Zugangsdaten zu einem Dienst (TURN braucht Benutzer und
|
||
* Passwort). Die gehoeren nicht in eine Oberflaeche, die jeder sieht. */
|
||
anrufRouter.put("/workspace/api/anruf/adressen", gleicheHerkunft,
|
||
express.json({ limit: "8kb" }), (req, res) => {
|
||
try {
|
||
if (!istDogFather(req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
const liste = Array.isArray(req.body?.adressen) ? req.body.adressen : null;
|
||
if (!liste) return res.status(400).json({ fehler: "Erwartet wird eine Liste." });
|
||
/* Nur die Felder, die WebRTC kennt -- alles andere waere ein
|
||
offenes Tor, um beliebiges JSON in die Einstellungen zu legen. */
|
||
const sauber = liste.slice(0, 8).map((e) => ({
|
||
urls: String(e?.urls || "").slice(0, 200),
|
||
...(e?.username ? { username: String(e.username).slice(0, 100) } : {}),
|
||
...(e?.credential ? { credential: String(e.credential).slice(0, 200) } : {}),
|
||
})).filter((e) => /^(stun|turn|turns):/.test(e.urls));
|
||
einstellungSetzen("anruf_adressen", JSON.stringify(sauber));
|
||
protokolliere("anruf_adressen", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `${sauber.length} Adresse(n)`,
|
||
});
|
||
res.json({ ok: true, anzahl: sauber.length });
|
||
} catch (f) {
|
||
console.error("[anruf] Adressen setzen:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* =====================================================================
|
||
ANRUFEN
|
||
===================================================================== */
|
||
anrufRouter.post("/workspace/api/anruf/:raum/start", gleicheHerkunft,
|
||
express.json({ limit: "4kb" }), (req, res) => {
|
||
try {
|
||
aufraeumen();
|
||
const raumId = nummer(req.params.raum);
|
||
if (!raumId || !istDrinFuerAnruf(raumId, req.person)) {
|
||
return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
}
|
||
const mitVideo = req.body?.video === true;
|
||
|
||
const leute = teilnehmerFuerAnruf(raumId);
|
||
if (leute.length > GRUPPE_MAX) {
|
||
return res.status(409).json({
|
||
fehler: `In diesem Gespräch sind ${leute.length} Leute. `
|
||
+ `Telefonieren geht bis ${GRUPPE_MAX} – darüber wird es für die `
|
||
+ `Geräte zu viel.`,
|
||
});
|
||
}
|
||
|
||
const schon = laufend.get(raumId);
|
||
if (schon && !schon.wer.has(req.person.id)) {
|
||
/* Es laeuft schon einer -- dann tritt man bei, statt einen
|
||
zweiten zu starten. Zwei Anrufe im selben Raum waeren zwei
|
||
Gespraeche, von denen jeder das andere nicht hoert. */
|
||
schon.wer.set(req.person.id, { name: req.person.name, seit: Date.now() });
|
||
chatEreignis(raumId, {
|
||
raum_id: raumId, art: "dabei",
|
||
person: { id: req.person.id, name: req.person.name },
|
||
wer: [...schon.wer.entries()].map(([id, w]) => ({ id, name: w.name })),
|
||
}, [], "anruf");
|
||
return res.json({ ok: true, beigetreten: true, video: schon.video });
|
||
}
|
||
|
||
laufend.set(raumId, {
|
||
seit: Date.now(), video: mitVideo,
|
||
wer: new Map([[req.person.id, { name: req.person.name, seit: Date.now() }]]),
|
||
});
|
||
|
||
/* DAS KLINGELN. `chatEreignis` schickt an alle offenen
|
||
Verbindungen des Raums UND weckt per Push, wer nicht zusieht --
|
||
genau die zwei Wege, die ein Anruf braucht. Der dritte
|
||
Parameter sind die, die geweckt werden sollen: alle ausser dem
|
||
Anrufer. */
|
||
const wecken = leute.map((t) => t.id).filter((id) => id !== req.person.id);
|
||
chatEreignis(raumId, {
|
||
raum_id: raumId, art: "klingelt", video: mitVideo,
|
||
von: { id: req.person.id, name: req.person.name },
|
||
laeuft_bis: Date.now() + KLINGELT_SEKUNDEN * 1000,
|
||
}, wecken, "anruf");
|
||
|
||
protokolliere("anruf_start", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `Raum ${raumId}${mitVideo ? " mit Video" : ""}`,
|
||
});
|
||
res.json({ ok: true, video: mitVideo, wer: [{ id: req.person.id, name: req.person.name }] });
|
||
} catch (f) {
|
||
console.error("[anruf] Start:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/** Annehmen. */
|
||
anrufRouter.post("/workspace/api/anruf/:raum/dabei", gleicheHerkunft, (req, res) => {
|
||
try {
|
||
aufraeumen();
|
||
const raumId = nummer(req.params.raum);
|
||
if (!raumId || !istDrinFuerAnruf(raumId, req.person)) {
|
||
return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
}
|
||
const a = laufend.get(raumId);
|
||
if (!a) return res.status(409).json({ fehler: "Der Anruf ist schon vorbei." });
|
||
if (a.wer.size >= GRUPPE_MAX) {
|
||
return res.status(409).json({ fehler: `Es telefonieren schon ${GRUPPE_MAX}.` });
|
||
}
|
||
a.wer.set(req.person.id, { name: req.person.name, seit: Date.now() });
|
||
chatEreignis(raumId, {
|
||
raum_id: raumId, art: "dabei",
|
||
person: { id: req.person.id, name: req.person.name },
|
||
wer: [...a.wer.entries()].map(([id, w]) => ({ id, name: w.name })),
|
||
}, [], "anruf");
|
||
res.json({ ok: true, video: a.video,
|
||
wer: [...a.wer.entries()].map(([id, w]) => ({ id, name: w.name })) });
|
||
} catch (f) {
|
||
console.error("[anruf] Dabei:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/** Auflegen -- oder ablehnen. Derselbe Weg.
|
||
*
|
||
* Wer ablehnt, war nie dabei; wer auflegt, geht raus. Beides endet in
|
||
* „diese Person nimmt nicht (mehr) teil", und zwei getrennte Wege
|
||
* waeren zwei Gelegenheiten, den Zustand verschieden zu fuehren. */
|
||
anrufRouter.post("/workspace/api/anruf/:raum/ende", gleicheHerkunft, (req, res) => {
|
||
try {
|
||
const raumId = nummer(req.params.raum);
|
||
if (!raumId || !istDrinFuerAnruf(raumId, req.person)) {
|
||
return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
}
|
||
const a = laufend.get(raumId);
|
||
if (a) {
|
||
const war = a.wer.get(req.person.id);
|
||
a.wer.delete(req.person.id);
|
||
const dauer = war ? Math.round((Date.now() - war.seit) / 1000) : 0;
|
||
if (!a.wer.size) laufend.delete(raumId);
|
||
chatEreignis(raumId, {
|
||
raum_id: raumId, art: a.wer.size ? "weg" : "ende",
|
||
person: { id: req.person.id, name: req.person.name },
|
||
wer: [...a.wer.entries()].map(([id, w]) => ({ id, name: w.name })),
|
||
dauer,
|
||
}, [], "anruf");
|
||
if (war && dauer > 2) {
|
||
protokolliere("anruf_ende", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `Raum ${raumId}, ${dauer} s`,
|
||
});
|
||
}
|
||
}
|
||
res.json({ ok: true });
|
||
} catch (f) {
|
||
console.error("[anruf] Ende:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* =====================================================================
|
||
DIE SIGNALISIERUNG
|
||
|
||
Angebot, Antwort und Verbindungswege wandern hier durch -- und NUR
|
||
sie. Der Server liest sie nicht, er reicht sie weiter.
|
||
|
||
AN EINE BESTIMMTE PERSON, nicht an den ganzen Raum: Bei drei
|
||
Teilnehmern baut jeder mit jedem eine eigene Verbindung auf, und ein
|
||
Angebot, das an alle geht, würde von zweien beantwortet.
|
||
===================================================================== */
|
||
anrufRouter.post("/workspace/api/anruf/:raum/signal", gleicheHerkunft,
|
||
express.json({ limit: "64kb" }), (req, res) => {
|
||
try {
|
||
const raumId = nummer(req.params.raum);
|
||
if (!raumId || !istDrinFuerAnruf(raumId, req.person)) {
|
||
return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
}
|
||
const an = nummer(req.body?.an);
|
||
const inhalt = req.body?.inhalt;
|
||
if (!an || !inhalt || typeof inhalt !== "object") {
|
||
return res.status(400).json({ fehler: "unvollstaendig" });
|
||
}
|
||
/* DER EMPFAENGER MUSS IM RAUM SEIN. Ohne diese Zeile waere das
|
||
hier ein Weg, jedem Angemeldeten beliebiges JSON zu schicken --
|
||
an jeder Chatberechtigung vorbei. */
|
||
if (!teilnehmerFuerAnruf(raumId).some((t) => t.id === an)) {
|
||
return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
}
|
||
chatEreignis(raumId, {
|
||
raum_id: raumId, art: "signal",
|
||
von: req.person.id, an, inhalt,
|
||
}, [], "anruf");
|
||
res.json({ ok: true });
|
||
} catch (f) {
|
||
console.error("[anruf] Signal:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/** Läuft hier gerade ein Anruf? Für den, der die Seite frisch öffnet. */
|
||
/* =====================================================================
|
||
KLINGELT GERADE ETWAS FUER MICH? (18.09.2026)
|
||
|
||
Filipe: „wenn ich vanvan anrufe kriegt sie nur eine benarichtigung
|
||
aber keinen anruf was soll das."
|
||
|
||
DAS WAR DER FEHLER, UND ER WAR GRUNDSAETZLICH. Das Klingeln lief
|
||
ausschliesslich ueber `chatEreignis` -- also ueber den offenen
|
||
Ereignisstrom. Wer die Seite gerade ansieht, hoert es. Wer sie
|
||
NICHT offen hat, bekommt die Push-Benachrichtigung, tippt darauf,
|
||
die Seite laedt -- und dann passiert nichts mehr. Das Ereignis war
|
||
in dem Moment vorbei, in dem es geschickt wurde.
|
||
|
||
Damit funktionierte der Anruf ausgerechnet fuer die nicht, fuer die
|
||
die Benachrichtigung gebaut wurde. Und es sah aus wie ein Fehler
|
||
beim Angerufenen („sie kriegt nur eine Benachrichtigung"), obwohl
|
||
nichts kaputt war -- es fehlte schlicht der Weg zurueck.
|
||
|
||
Diese Route ist dieser Weg: Beim Laden fragt die Seite einmal nach,
|
||
ob in einem ihrer Raeume gerade jemand wartet. Ein laufender Anruf
|
||
steht im Speicher (`laufend`), die Frage kostet also nichts.
|
||
|
||
NUR WAS NOCH KLINGELT: Anrufe, die laenger als KLINGELT_SEKUNDEN
|
||
her sind, gelten als verpasst -- sonst klingelte es beim Oeffnen
|
||
noch, obwohl der andere laengst aufgelegt hat. Und nur Raeume, in
|
||
denen die Person auch wirklich drin ist; `istDrinFuerAnruf` ist
|
||
dieselbe Pruefung wie ueberall sonst.
|
||
===================================================================== */
|
||
anrufRouter.get("/workspace/api/anruf/offen", (req, res) => {
|
||
try {
|
||
aufraeumen();
|
||
const jetzt = Date.now();
|
||
const offen = [];
|
||
for (const [raumId, a] of laufend) {
|
||
/* Schon dabei? Dann klingelt es nicht mehr, dann telefoniert
|
||
man. */
|
||
if (a.wer.has(req.person.id)) continue;
|
||
if (jetzt - a.seit > KLINGELT_SEKUNDEN * 1000) continue;
|
||
/* DIE PERSON, NICHT IHRE NUMMER -- istDrin() wirft sonst einen
|
||
TypeError, und zwar ausdruecklich: Die Sicherung steht dort
|
||
genau fuer diesen Fall. Hier stand zuerst `.id`. */
|
||
if (!istDrinFuerAnruf(raumId, req.person)) continue;
|
||
const ersterAndere = [...a.wer.entries()][0];
|
||
offen.push({
|
||
raum_id: raumId,
|
||
video: !!a.video,
|
||
von: ersterAndere
|
||
? { id: ersterAndere[0], name: ersterAndere[1].name }
|
||
: null,
|
||
laeuft_bis: a.seit + KLINGELT_SEKUNDEN * 1000,
|
||
});
|
||
}
|
||
res.json({ anrufe: offen });
|
||
} catch (f) {
|
||
console.error("[anruf] Offene:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
anrufRouter.get("/workspace/api/anruf/:raum", (req, res) => {
|
||
try {
|
||
aufraeumen();
|
||
const raumId = nummer(req.params.raum);
|
||
if (!raumId || !istDrinFuerAnruf(raumId, req.person)) {
|
||
return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
}
|
||
const a = laufend.get(raumId);
|
||
res.json({
|
||
laeuft: !!a,
|
||
video: a?.video || false,
|
||
wer: a ? [...a.wer.entries()].map(([id, w]) => ({ id, name: w.name })) : [],
|
||
ich_dabei: !!a?.wer.has(req.person.id),
|
||
});
|
||
} catch (f) {
|
||
console.error("[anruf] Lage:", f?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|