Alle Spieler werden benachrichtigt.
+ ${sicher(p.job)}${p.fraktion ? " · " + sicher(p.fraktion) : ""} · ${sicher(p.region)} · ${d.spielzeit || 0} Min · Gruppe ${sicher(d.gruppe)}
+ Keine Projekte.
';
+ const act = async (a, id) => { try { await A("staat", a, { id }); toast("Erledigt", "good"); neu(); } catch (f) { toast(f.message, "warn"); } };
+ main.querySelectorAll("[data-end]").forEach((b) => b.addEventListener("click", () => act("beenden", +b.dataset.end)));
+ main.querySelectorAll("[data-act]").forEach((b) => b.addEventListener("click", () => act("aktivieren", +b.dataset.act)));
+ main.querySelectorAll("[data-arch]").forEach((b) => b.addEventListener("click", () => act("archivieren", +b.dataset.arch)));
+ });
+
+ /* ===== RESSOURCEN ============================================ */
+ App.registriere("ressourcen", async (main) => {
+ const d = await A("ressourcen", "laden");
+ main.innerHTML = kopf("Ressourcen", `${d.ressourcen.filter((r) => r.status === "started").length}/${d.ressourcen.length} aktiv`,
+ darf("ressourcen.neustart") ? '}
+ */
+ function aufruf(modul, aktion, daten) {
+ return new Promise((aufloesen, ablehnen) => {
+ if (!IST_FIVEM) {
+ // Browser-Vorschau: es gibt keinen Server zum Fragen
+ ablehnen(new Error("Vorschaumodus — keine Verbindung zum Server."));
+ return;
+ }
+
+ const ruf = ++rufZaehler;
+ offeneRufe[ruf] = { aufloesen, ablehnen };
+
+ anClient("aufruf", { modul, aktion, daten: daten || {}, ruf });
+
+ // Nicht ewig warten, falls eine Antwort ausbleibt
+ setTimeout(() => {
+ if (offeneRufe[ruf]) {
+ delete offeneRufe[ruf];
+ ablehnen(new Error("Zeitüberschreitung — der Server hat nicht geantwortet."));
+ }
+ }, 15000);
+ });
+ }
+
+ /* ---- Kurzmeldungen ------------------------------------------------ */
+
+ /**
+ * Zeigt eine kurze Meldung.
+ * @param {string} text Inhalt
+ * @param {string} art "gut" | "fehler" | ""
+ */
+ function meldung(text, art) {
+ const el = document.createElement("div");
+ el.className = "meldung " + (art || "");
+ el.textContent = text;
+ $("meldungen").appendChild(el);
+ setTimeout(() => el.remove(), 3200);
+ }
+
+ /* ---- Fenster (Dialoge) -------------------------------------------- */
+
+ /**
+ * Öffnet ein Dialogfenster.
+ * @param {object} o { titel, inhalt, knoepfe: [{text, art?, klick}], nachOeffnen? }
+ */
+ function fenster(o) {
+ const ebene = $("fenster-ebene");
+ const hg = document.createElement("div");
+ hg.className = "fenster-hg";
+
+ const knoepfe = (o.knoepfe || []).map((k, i) =>
+ `${sicher(k.text)} `
+ ).join("");
+
+ hg.innerHTML =
+ `
+
+
${sicher(o.titel || "")}
+ ✕
+
+
${o.inhalt || ""}
+ ${knoepfe ? `
${knoepfe}
` : ""}
+
+
ℹ
+
Diese Entscheidung triffst du. Das System hat den Vorgang nur
+ vorbereitet — dokumentiert wird er erst mit deiner Bestätigung.
+
+ ${sicher(m.icon)}
+ ${sicher(m.name)}
+ `).join("");
+
+ nav.querySelectorAll("[data-modul]").forEach((el) => {
+ el.addEventListener("click", () => oeffneModul(el.dataset.modul));
+ });
+ }
+
+ /**
+ * Öffnet ein Modul.
+ * @param {string} modulId Modul
+ * @param {object|null} ziel Sprungziel, z. B. { patient: 12 }.
+ * Die Ansicht liest ihn über App.zustand.modulZiel und räumt ihn auf.
+ */
+ async function oeffneModul(modulId, ziel) {
+ const ansicht = ansichten[modulId];
+ if (!ansicht) {
+ meldung("Dieses Modul ist nicht geladen.", "fehler");
+ return;
+ }
+
+ zustand.aktivesModul = modulId;
+ zustand.modulZiel = ziel || null;
+ zeichneNavigation();
+
+ const behaelter = $("inhalt");
+ behaelter.innerHTML = ``;
+
+ try {
+ await ansicht.rendern(behaelter);
+ } catch (fehler) {
+ behaelter.innerHTML =
+ `Fehler
+
${sicher(fehler.message)}
+ `).join("");
+
+ $("status-liste").querySelectorAll("[data-status]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const gewaehlt = el.dataset.status;
+ zustand.mitarbeiter.status = gewaehlt;
+ anClient("status", { status: gewaehlt });
+ $("status-liste").hidden = true;
+ zeichneStatus();
+ });
+ });
+ }
+
+ function zeichneFunktion() {
+ const aktuell = zustand.funktionen.find(
+ (f) => f.id === (zustand.mitarbeiter || {}).funktion);
+
+ $("funktion-text").textContent = aktuell ? aktuell.name : "Stationsdienst";
+
+ $("funktion-liste").innerHTML = zustand.funktionen.map((f) =>
+ `${sicher(f.name)} `).join("");
+
+ $("funktion-liste").querySelectorAll("[data-funktion]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const gewaehlt = el.dataset.funktion;
+ zustand.mitarbeiter.funktion = gewaehlt;
+ anClient("funktion", { funktion: gewaehlt });
+ $("funktion-liste").hidden = true;
+ zeichneFunktion();
+ });
+ });
+ }
+
+ /* ---- Mitteilungen --------------------------------------------------- */
+
+ function zeichneHinweise() {
+ const ungelesen = zustand.hinweise.filter((h) => !h.gelesen).length;
+ const zaehler = $("hinweise-zaehler");
+ zaehler.hidden = ungelesen === 0;
+ zaehler.textContent = ungelesen > 99 ? "99+" : ungelesen;
+
+ const symbole = {
+ einsatz: "🚑", patient: "🧍", labor: "🧪", medikament: "💊",
+ blut: "🩸", op: "🔪", doku: "📄", system: "ℹ",
+ };
+
+ $("hinweise-inhalt").innerHTML = zustand.hinweise.length
+ ? zustand.hinweise.map((h) =>
+ `
+
+ ${symbole[h.kategorie] || "•"} ${sicher(h.titel)}
+ ${zeit(h.erstellt_am)}
+
+ ${h.text ? `
${sicher(h.text)}
` : ""}
+
Keine Mitteilungen.
`;
+
+ $("hinweise-inhalt").querySelectorAll("[data-hinweis]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const id = +el.dataset.hinweis;
+ if (!id) return;
+ const treffer = zustand.hinweise.find((h) => h.id === id);
+ if (treffer) treffer.gelesen = 1;
+ aufruf("dashboard", "hinweisGelesen", { id }).catch(() => {});
+ zeichneHinweise();
+ if (treffer) springeZuHinweis(treffer);
+ });
+ });
+ }
+
+ /**
+ * Öffnet das Modul, zu dem ein Hinweis gehört.
+ * Nur Ziele, die eine Ansicht auch auswertet, werden mitgegeben —
+ * alles andere öffnet schlicht das passende Modul.
+ */
+ function springeZuHinweis(hinweis) {
+ if (!hinweis.zielTyp) return;
+
+ // zielTyp → [Modul, Schlüssel des Sprungziels oder null]
+ const wege = {
+ patient: ["mdt", "patient"],
+ akte: ["mdt", "akte"],
+ aufnahme: ["patienten", null],
+ behandlung: ["behandlung", "behandlung"],
+ bericht: ["bericht", "bericht"],
+ operation: ["operation", null],
+ labor: ["labor", null],
+ blut: ["blutbank", "blut"],
+ medikament: ["medikament", null],
+ zimmer: ["station", "zimmer"],
+ fahrzeug: ["fahrzeug", "fahrzeug"],
+ einsatz: ["einsatz", null],
+ intensiv: ["intensiv", "intensiv"],
+ nachricht: ["kommunikation", "nachricht"],
+ aushang: ["kommunikation", "aushang"],
+ };
+
+ const weg = wege[hinweis.zielTyp];
+ if (!weg) return;
+
+ // Nur öffnen, wenn das Modul für diesen Mitarbeiter sichtbar ist
+ if (!zustand.module.some((m) => m.id === weg[0])) return;
+
+ const ziel = weg[1] && hinweis.zielId ? { [weg[1]]: +hinweis.zielId } : null;
+ oeffneModul(weg[0], ziel);
+ $("hinweise-schublade").hidden = true;
+ }
+
+ /** Nimmt einen neu eingetroffenen Hinweis auf */
+ function neuerHinweis(hinweis) {
+ zustand.hinweise.unshift(Object.assign({ erstellt_am: new Date().toISOString() }, hinweis));
+ if (zustand.hinweise.length > 50) zustand.hinweise.pop();
+ zeichneHinweise();
+ meldung(hinweis.titel, hinweis.prioritaet === "kritisch" ? "fehler" : "");
+
+ // Offene Ansicht auffrischen, falls sie das betrifft
+ const ansicht = ansichten[zustand.aktivesModul];
+ if (ansicht && ansicht.aktualisieren) ansicht.aktualisieren();
+ }
+
+ /* ---- Aufbau beim Öffnen ---------------------------------------------- */
+
+ function zeigeTablet(daten) {
+ zustand.imDienst = true;
+ zustand.mitarbeiter = daten.mitarbeiter || {};
+ zustand.module = daten.module || [];
+ zustand.status = daten.status || [];
+ zustand.funktionen = daten.funktionen || [];
+ zustand.stationen = daten.stationen || [];
+
+ $("anmeldung").hidden = true;
+ $("tablet").hidden = false;
+
+ $("tb-kuerzel").textContent = daten.kuerzel || "LSMC";
+ $("tb-klinik").textContent = daten.klinik || "Klinikinformationssystem";
+ $("tb-name").textContent = zustand.mitarbeiter.name || "—";
+ $("tb-rolle").textContent = zustand.mitarbeiter.rolleName || "—";
+ $("tb-nummer").textContent = zustand.mitarbeiter.personalnummer || "—";
+
+ zeichneNavigation();
+ zeichneStatus();
+ zeichneFunktion();
+ zeichneHinweise();
+
+ if (zustand.module.length) oeffneModul(zustand.module[0].id);
+ }
+
+ function zeigeAnmeldung(daten) {
+ zustand.imDienst = false;
+ $("tablet").hidden = true;
+ $("anmeldung").hidden = false;
+
+ $("an-klinik").textContent = daten.klinik || "Los Santos Medical Center";
+ $("an-name").textContent = daten.name || "—";
+ $("an-nummer").textContent = daten.personalnummer || "—";
+ $("an-rolle").textContent = daten.rolleName || "—";
+ $("an-station").textContent = daten.station || "—";
+
+ // Dienstfunktion auswählen — die Vorauswahl ist nur ein Vorschlag
+ const funktionen = daten.funktionen || [{ id: "station", name: "Stationsdienst" }];
+ let gewaehlt = funktionen[0].id;
+
+ $("an-funktionen").innerHTML = funktionen.map((f, i) =>
+ `${sicher(f.name)} `).join("");
+
+ $("an-funktionen").querySelectorAll("[data-funktion]").forEach((el) => {
+ el.addEventListener("click", () => {
+ gewaehlt = el.dataset.funktion;
+ $("an-funktionen").querySelectorAll("[data-funktion]")
+ .forEach((k) => k.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ });
+ });
+
+ $("an-antreten").onclick = () => anClient("dienstAntreten", { funktion: gewaehlt });
+ }
+
+ /* ---- Verdrahtung der Hülle -------------------------------------------- */
+
+ function verdrahteShell() {
+ $("an-abbrechen").addEventListener("click", () => anClient("schliessen", {}));
+ $("tablet-schliessen").addEventListener("click", () => anClient("schliessen", {}));
+
+ $("dienst-beenden").addEventListener("click", () => {
+ bestaetigen({
+ titel: "Dienst beenden",
+ inhalt: `Du meldest dich vom Dienst ab. Laufende Behandlungen und
+ Dokumentationen bleiben offen — sie werden nicht abgeschlossen.
`,
+ bestaetigenText: "Dienst beenden",
+ bestaetigt: (_, zu) => { zu(); anClient("dienstBeenden", {}); },
+ });
+ });
+
+ // Statuswähler
+ $("status-knopf").addEventListener("click", () => {
+ const liste = $("status-liste");
+ liste.hidden = !liste.hidden;
+ $("funktion-liste").hidden = true;
+ });
+
+ // Funktionswähler
+ $("funktion-knopf").addEventListener("click", () => {
+ const liste = $("funktion-liste");
+ liste.hidden = !liste.hidden;
+ $("status-liste").hidden = true;
+ });
+
+ // Mitteilungen
+ $("hinweise-knopf").addEventListener("click", () => {
+ const schublade = $("hinweise-schublade");
+ schublade.hidden = !schublade.hidden;
+ if (!schublade.hidden) zeichneHinweise();
+ });
+ $("hinweise-zu").addEventListener("click", () => { $("hinweise-schublade").hidden = true; });
+
+ // Design umschalten
+ $("thema-wechsel").addEventListener("click", () => {
+ document.body.classList.toggle("thema-dunkel");
+ document.body.classList.toggle("thema-hell");
+ });
+
+ // Globale Suche
+ $("global-suche").addEventListener("keydown", (e) => {
+ if (e.key === "Enter") {
+ const begriff = e.target.value.trim();
+ if (begriff.length >= 2) globalSuchen(begriff);
+ }
+ });
+
+ // Klick ins Leere schließt die Auswahllisten
+ document.addEventListener("click", (e) => {
+ if (!e.target.closest("#status-waehler")) $("status-liste").hidden = true;
+ if (!e.target.closest("#funktion-waehler")) $("funktion-liste").hidden = true;
+ });
+
+ document.addEventListener("keydown", (e) => {
+ if (e.key !== "Escape") return;
+ if (document.querySelector(".fenster-hg")) {
+ document.querySelector(".fenster-hg").remove();
+ return;
+ }
+ if (!$("hinweise-schublade").hidden) { $("hinweise-schublade").hidden = true; return; }
+ anClient("schliessen", {});
+ });
+
+ // Nachrichten vom Client
+ window.addEventListener("message", (e) => {
+ const daten = e.data || {};
+
+ switch (daten.aktion) {
+ case "oeffnen":
+ zeigeTablet(daten);
+ document.body.style.display = "";
+ break;
+
+ case "anmeldung":
+ zeigeAnmeldung(daten);
+ document.body.style.display = "";
+ break;
+
+ case "schliessen":
+ document.body.style.display = "none";
+ $("hinweise-schublade").hidden = true;
+ $("fenster-ebene").innerHTML = "";
+ break;
+
+ case "antwort": {
+ const offen = offeneRufe[daten.ruf];
+ if (!offen) break;
+ delete offeneRufe[daten.ruf];
+ if (daten.fehler) offen.ablehnen(new Error(daten.fehler));
+ else offen.aufloesen(daten.ergebnis || {});
+ break;
+ }
+
+ case "hinweis":
+ neuerHinweis(daten.hinweis || {});
+ break;
+
+ case "dienstliste": {
+ zustand.dienstliste = daten.mitarbeiter || [];
+ const ansicht = ansichten[zustand.aktivesModul];
+ if (ansicht && ansicht.aktualisieren) ansicht.aktualisieren();
+ break;
+ }
+
+ case "einsatzAenderung": {
+ const ansicht = ansichten[zustand.aktivesModul];
+ if (ansicht && ansicht.aktualisieren) ansicht.aktualisieren();
+ break;
+ }
+
+ case "einsatzZuweisung":
+ meldung(`Zuweisung: ${daten.daten.nummer} — ${daten.daten.titel}`);
+ break;
+
+ case "fehler":
+ meldung(daten.text, "fehler");
+ break;
+ }
+ });
+ }
+
+ /* ---- Globale Suche ----------------------------------------------------- */
+
+ /** Registriert einen Anbieter für die globale Suche */
+ function registriereSuche(funktion) { suchAnbieter.push(funktion); }
+
+ async function globalSuchen(begriff) {
+ const treffer = [];
+
+ for (const anbieter of suchAnbieter) {
+ try {
+ const ergebnis = await anbieter(begriff);
+ if (Array.isArray(ergebnis)) treffer.push(...ergebnis);
+ } catch (e) { /* einzelne Anbieter dürfen scheitern */ }
+ }
+
+ fenster({
+ titel: `Suche: „${begriff}"`,
+ inhalt: treffer.length
+ ? `${treffer.map((t) =>
+ `
+
${sicher(t.bereich)}
+
+
${sicher(t.titel)}
+
${sicher(t.unter || "")}
+
+
`).join("")}
Keine Treffer.
`,
+ });
+ }
+
+ /* ---- Öffentliche Schnittstelle ------------------------------------------ */
+ return {
+ /** Registriert eine Modulansicht */
+ registriereAnsicht(modulId, ansicht) { ansichten[modulId] = ansicht; },
+ /** Registriert einen Anbieter für die globale Suche */
+ registriereSuche,
+ zustand, aufruf, meldung, fenster, bestaetigen,
+ sicher, zeit, dauer, minuten, euro, $,
+ anClient, oeffneModul,
+ start() {
+ verdrahteShell();
+ if (IST_FIVEM) document.body.style.display = "none";
+ else {
+ // Eigenständige Browser-Ansicht: Anmeldebildschirm zeigen
+ zeigeAnmeldung({
+ klinik: "Los Santos Medical Center", name: "Vorschau",
+ personalnummer: "LSMC-0000", rolleName: "Assistenzarzt", station: "notaufnahme",
+ funktionen: [
+ { id: "station", name: "Stationsdienst" },
+ { id: "rtw", name: "Rettungswagen" },
+ ],
+ });
+ }
+ },
+ };
+})();
+
+App.start();
diff --git a/resources/[aether]/aether-medical/html/js/bausteine.js b/resources/[aether]/aether-medical/html/js/bausteine.js
new file mode 100644
index 0000000..5ab258a
--- /dev/null
+++ b/resources/[aether]/aether-medical/html/js/bausteine.js
@@ -0,0 +1,156 @@
+/* =====================================================================
+ aether-medical — Bausteine für die Bögen
+
+ Setzt vorformulierten Text in ein Formular ein. Mehr tut diese Datei
+ nicht, und mehr soll sie nicht tun:
+
+ * Sie schreibt nichts zum Server. Der Text landet im Textfeld,
+ gespeichert wird danach von Hand.
+ * Sie überschreibt nichts. Steht schon etwas im Feld, wird der
+ Baustein darunter gehängt.
+ * Sie wählt nichts aus. Welcher Baustein passt, entscheidet der,
+ der ihn einsetzt.
+===================================================================== */
+"use strict";
+
+const Bausteine = (() => {
+ const { sicher, aufruf, meldung, bestaetigen } = App;
+
+ /**
+ * Hängt Text an ein Textfeld an, ohne Vorhandenes zu verlieren.
+ * @param {HTMLTextAreaElement} feld Zielfeld
+ * @param {string} text Einzusetzender Text
+ */
+ function anhaengen(feld, text) {
+ const vorhanden = feld.value.trim();
+ feld.value = vorhanden ? vorhanden + "\n\n" + text : text;
+ }
+
+ /**
+ * Öffnet die Bausteinauswahl für einen Bogen.
+ * @param {object} o {
+ * modul Modulkennung, unter der die Aktion liegt
+ * behaelter Element, in dem die Textfelder stehen
+ * nachEinsetzen Rückruf nach dem Einsetzen (freiwillig)
+ * }
+ */
+ async function einsetzen(o) {
+ let d;
+ try {
+ d = await aufruf(o.modul, "bausteine", {});
+ } catch (fehler) { return meldung(fehler.message, "fehler"); }
+
+ if (!d.bausteine.length) {
+ return meldung("Für diesen Bogen ist kein Baustein hinterlegt.", "fehler");
+ }
+
+ let gewaehlt = null; // aktuell gewählter Baustein
+ const abgewaehlt = {}; // Felder, die der Nutzer ausgenommen hat
+
+ bestaetigen({
+ titel: "Baustein einsetzen",
+ inhalt: `
+
+
🧩
+
Der Baustein füllt nur das Formular. Gespeichert wird nichts —
+ das machst du danach selbst. Text, der schon im Feld steht, bleibt
+ erhalten; der Baustein kommt darunter.
+
Baustein für den ${sicher(d.bereichName)}
+
+ ${d.bausteine.map((b) => `
+
+
${sicher(b.kennung)}
+
+
${sicher(b.name)}
+
${d.felder
+ .filter((f) => b.inhalt[f.id])
+ .map((f) => sicher(f.name)).join(" · ") || "leer"}
+
+
`).join("")}
+
+
Wähle einen Baustein, um seinen Text zu sehen.
+
+ Wird eingesetzt
+ Häkchen entfernen, was nicht mit soll
+
+ ${d.felder.filter((f) => gewaehlt.inhalt[f.id]).map((f) => `
+
+
+
+
${sicher(gewaehlt.inhalt[f.id])
+ .replace(/\n/g, "
+
+
+
Behandlungen
+
Das System speichert ausschließlich die Dokumentation. Es behandelt
+ nicht, es diagnostiziert nicht und es schlägt nichts vor.
+
+ ${d.rechte.dokumentieren
+ ? `
＋ Behandlung dokumentieren ` : ""}
+
+
+
Laufend
+
${d.zaehler.laufend}
+
noch nicht abgeschlossen
+
+
+
Davon von dir
+
${d.zaehler.meine}
+
deine offene Dokumentation
+
+
+
Heute abgeschlossen
+
${d.zaehler.heute}
+
in der ganzen Klinik
+
+
+
+ Laufend${d.zaehler.laufend}
+
+ Meine
+
+ Abgeschlossen
+
+
+
+
+
+
+
+ Dokumentationen
+ ${d.liste.length} Einträge
+
+
+ ${d.liste.length ? d.liste.map(zeile).join("")
+ : `
Keine Dokumentation gefunden.
`}
+
+
+
${sicher(b.kennung)}
+
+
${sicher(b.patientName)}
+ geb. ${sicher(b.geburt)}
+
${sicher(b.diagnose || b.massnahmen
+ || "Noch nichts eingetragen")}
+
+
+ ${b.hinweis ? `
⚠ ` : ""}
+ ${b.allergien ? `
A ` : ""}
+ ${b.gaben > 0 ? `
💊 ${b.gaben} ` : ""}
+ ${b.einsatzNummer ? `
${sicher(b.einsatzNummer)} ` : ""}
+ ${b.eigene ? `
von dir ` : ""}
+
+
${sicher(b.status)}
+
${laufend
+ ? "offen seit " + minuten(b.offenSeit) : zeit(b.abgeschlossen_am)}
+
+
+
${sicher(b.kennung)} · ${sicher(b.patientName)}
+
geb. ${sicher(b.geburt)}
+ ${b.einsatzNummer ? " · Einsatz " + sicher(b.einsatzNummer) : ""}
+ ${b.aufnahmeGrund ? " · Aufnahme: " + sicher(b.aufnahmeGrund) : ""}
+
+
← Übersicht
+
+
⚠
+
Warnhinweis — ${sicher(s.hinweis)}
+
+
💊
+
Allergien — ${sicher(s.allergien)}
+ Vor jeder Gabe selbst prüfen. Das System
+ gleicht Medikamente nicht gegen Allergien ab.
+
+
+
Status ${sicher(b.status)}
+
Angelegt ${zeit(b.erstelltAm)}
+
Von ${sicher(b.erstelltVon)}
+
Blutgruppe
+ ${sicher(s.blutgruppe || "nicht bestimmt")}
+
Vorerkrankungen
+ ${sicher(s.vorerkrankungen || "keine erfasst")}
+
Dauermedikation
+ ${sicher(s.dauermedikation || "keine erfasst")}
+ ${b.abgeschlossenAm ? `
+
Abgeschlossen ${zeit(b.abgeschlossenAm)}
+
Durch ${sicher(b.abgeschlossenVon)}
` : ""}
+
+
+ Patientenakte
+ ${laufend && d.rechte.dokumentieren
+ ? `🧩 Baustein
+ Dokumentation speichern ` : ""}
+ ${laufend && d.rechte.abschliessen
+ ? `Abschließen ` : ""}
+ ${!laufend && d.rechte.abschliessen
+ ? `Wieder öffnen ` : ""}
+
+
+ ${feld("symptome", "Symptome / Anamnese", b.symptome, laufend && d.rechte.dokumentieren,
+ "Was schildert der Patient?")}
+ ${feld("untersuchung", "Untersuchung", b.untersuchung, laufend && d.rechte.dokumentieren,
+ "Was hast du erhoben? Vitalwerte, Befunde am Patienten…")}
+ ${feld("diagnose", "Diagnose", b.diagnose,
+ laufend && d.rechte.dokumentieren && !diagnoseSperre,
+ diagnoseSperre ? "Für die Diagnose fehlt dir die Berechtigung."
+ : "Deine Einschätzung. Das System stellt keine Diagnose.")}
+ ${feld("massnahmen", "Maßnahmen / Behandlung", b.massnahmen,
+ laufend && d.rechte.dokumentieren,
+ "Verbände, Lagerung, Eingriffe, Reanimation…")}
+ ${feld("empfehlung", "Empfehlung", b.empfehlung, laufend && d.rechte.dokumentieren,
+ "Was empfiehlst du dem Patienten?")}
+ ${feld("nachsorge", "Nachsorge", b.nachsorge, laufend && d.rechte.dokumentieren,
+ "Kontrolltermin, Wundversorgung, Medikamentenplan…")}
+
+
+
+
+ Verabreichte Medikamente
+ ${laufend && d.rechte.medikament
+ ? `＋ Gabe dokumentieren ` : ""}
+
+
+ ${d.gaben.length ? d.gaben.map((g) => `
+
+
+ ${g.btm ? "BTM" : "💊"}
+
+
${sicher(g.name)}
+ ${g.menge} ${sicher(g.einheit)}
+
+ ${g.dosierung ? sicher(g.dosierung) + " · " : ""}
+ ${sicher(g.autor)} · ${zeit(g.gegeben_am)}
+ ${g.hinweis ? " · " + sicher(g.hinweis) : ""}
+
+
+ ${laufend && (g.eigene || d.rechte.bestand)
+ ? `
✕ ` : ""}
+
`).join("")
+ : `
Keine Gabe dokumentiert.
`}
+
+
+
+
Laborergebnisse des Patienten
+
+ ${d.labor.length ? d.labor.map((l) => `
+
+
${sicher(l.kennung)}
+
+
${sicher(l.art)}
+
${sicher(l.befund || l.ergebnis
+ || "Noch kein Ergebnis")}
+
+
+ ${sicher(l.status)}
+
`).join("")
+ : `
Keine Laboraufträge.
`}
+
+
+
+
+
Operationen des Patienten
+
+ ${d.operationen.length ? d.operationen.map((o) => `
+
+
${sicher(o.kennung)}
+
+
${sicher(o.art)}
+
${o.beginn ? zeit(o.beginn) : "noch nicht begonnen"}
+
+
${sicher(o.status)}
+
`).join("")
+ : `
Keine Operationen.
`}
+
+
+
+
${sicher(titel)}
+
${wert
+ ? sicher(wert).replace(/\n/g, "
+ ${hinweis ? `
${sicher(hinweis)}
` : ""}
+
+
${sicher(titel)}
+
+ ${hinweis ? `
${sicher(hinweis)}
` : ""}
+
${sicher(b.kennung)} — ${sicher(b.patientName)}
+ Die Dokumentation wird damit schreibgeschützt. Sie lässt sich später
+ mit Begründung wieder öffnen.
+ ${!b.diagnose ? `
+
+
📄
+
Es ist keine Diagnose eingetragen. Abschließen ist trotzdem
+ möglich — das System trägt keine für dich ein.
+
Nicht gespeicherte Änderungen im Bogen gehen dabei
+ verloren. Erst speichern, dann abschließen.
+ Vermerk (freiwillig)
+
`,
+ bestaetigenText: "Abschließen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("behandlung", "abschliessen", {
+ id: b.id, vermerk: el.querySelector("[name=vermerk]").value.trim(),
+ });
+ zu();
+ meldung("Behandlung abgeschlossen.", "gut");
+ oeffne(behaelter, b.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+
+ const wiederOeffnen = behaelter.querySelector("[data-oeffnen]");
+ if (wiederOeffnen) wiederOeffnen.addEventListener("click", () => {
+ bestaetigen({
+ titel: "Dokumentation wieder öffnen",
+ inhalt: `Die Behandlung wird wieder bearbeitbar. Der Vorgang steht
+ dauerhaft im Protokoll.
+ Begründung (Pflicht)
+
`,
+ bestaetigenText: "Wieder öffnen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (grund.length < 3) return meldung("Bitte eine Begründung angeben.", "fehler");
+ try {
+ await aufruf("behandlung", "wiedereroeffnen", { id: b.id, grund });
+ zu();
+ meldung("Dokumentation wieder geöffnet.", "gut");
+ oeffne(behaelter, b.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+
+ const gabe = behaelter.querySelector("[data-gabe]");
+ if (gabe) gabe.addEventListener("click", () => gabeFenster(behaelter, d));
+
+ behaelter.querySelectorAll("[data-zuruecknehmen]").forEach((el) => {
+ el.addEventListener("click", () => {
+ bestaetigen({
+ titel: "Eintrag zurücknehmen",
+ gefahr: true,
+ inhalt: `Der Eintrag wird aus der Dokumentation entfernt. Wurde damals
+ Bestand gebucht, wird er als Korrektur zurückgebucht.
+ Begründung (Pflicht)
+
`,
+ bestaetigenText: "Zurücknehmen",
+ bestaetigt: async (dialog, zu) => {
+ const grund = dialog.querySelector("[name=grund]").value.trim();
+ if (grund.length < 3) return meldung("Bitte eine Begründung angeben.", "fehler");
+ try {
+ await aufruf("behandlung", "medikamentZuruecknehmen", {
+ gabe: +el.dataset.zuruecknehmen, grund,
+ });
+ zu();
+ meldung("Eintrag zurückgenommen.", "gut");
+ oeffne(behaelter, b.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+ });
+ }
+
+ /* ---- Medikamentengabe ---------------------------------------------------- */
+
+ async function gabeFenster(behaelter, d) {
+ const b = d.behandlung;
+
+ let katalog;
+ try {
+ katalog = await aufruf("behandlung", "medikamente", {});
+ } catch (f) { return meldung(f.message, "fehler"); }
+
+ let gewaehlt = null;
+ // Wird gesetzt, wenn der Bestand nicht reicht und trotzdem dokumentiert wird
+ let ohneBestand = false;
+
+ // Medikamente nach Kategorie gruppieren
+ const gruppen = {};
+ katalog.medikamente.forEach((m) => {
+ (gruppen[m.kategorie] = gruppen[m.kategorie] || []).push(m);
+ });
+ const kategorieName = {};
+ katalog.kategorien.forEach((k) => { kategorieName[k.id] = k.name; });
+
+ const dialog = bestaetigen({
+ titel: "Medikamentengabe dokumentieren",
+ inhalt: `
+ ${sicher(b.patientName)} · ${sicher(b.kennung)}
+ ${d.stamm.allergien ? `
+
+
⚠
+
Bekannte Allergien: ${sicher(d.stamm.allergien)}Das System prüft nicht gegen diese Liste.
+ Der Abgleich ist deine Aufgabe.
+
Medikament
+
+
+ ${Object.keys(gruppen).map((kategorie) => `
+
+
${sicher(kategorieName[kategorie] || kategorie)}
+ ${gruppen[kategorie].map((m) => `
+
+ ${sicher(m.name)}
+ ${m.btm ? `BTM ` : ""}
+ ${m.abgelaufen ? `abgelaufen ` : ""}
+ ${sicher(m.wirkstoff || "")}
+ ${m.dosierung_standard ? " · " + sicher(m.dosierung_standard) : ""}
+
+ ${m.bestand} ${sicher(m.einheit)}
+ `).join("")}
+
`).join("")}
+
+
Die Standarddosierung ist ein Vorschlag aus dem
+ Katalog. Was du gibst, entscheidest du.
+
Hinweis (freiwillig)
+
+
`,
+ bestaetigenText: "Gabe dokumentieren",
+ bestaetigt: async (el, zu) => {
+ if (!gewaehlt) return meldung("Bitte ein Medikament wählen.", "fehler");
+ try {
+ await aufruf("behandlung", "medikamentGeben", {
+ id: b.id,
+ medikament: gewaehlt,
+ menge: +el.querySelector("[name=menge]").value,
+ dosierung: el.querySelector("[name=dosierung]").value.trim(),
+ hinweis: el.querySelector("[name=hinweis]").value.trim(),
+ ohneBestand,
+ });
+ zu();
+ meldung("Gabe dokumentiert.", "gut");
+ oeffne(behaelter, b.id);
+ } catch (f) {
+ meldung(f.message, "fehler");
+ // Bestand reicht nicht: Dokumentation trotzdem anbieten
+ if (f.message.indexOf("Bestand") !== -1) zeigeBestandsWeg(el);
+ }
+ },
+ nachOeffnen: (hg) => {
+ const suchfeld = hg.querySelector("[name=suche]");
+ const dosierung = hg.querySelector("[name=dosierung]");
+
+ hg.querySelectorAll("[data-med]").forEach((el) => {
+ el.addEventListener("click", () => {
+ gewaehlt = +el.dataset.med;
+ ohneBestand = false;
+ hg.querySelector("[data-warnung]").style.display = "none";
+ hg.querySelectorAll("[data-med]").forEach((k) => k.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ // Standarddosierung als Vorschlag übernehmen, überschreibbar
+ if (!dosierung.value) dosierung.value = el.dataset.dosierung;
+ });
+ });
+
+ suchfeld.addEventListener("input", () => {
+ const begriff = suchfeld.value.trim().toLowerCase();
+ hg.querySelectorAll("[data-med]").forEach((el) => {
+ el.style.display = !begriff || el.dataset.name.indexOf(begriff) !== -1 ? "" : "none";
+ });
+ // Leere Gruppen ausblenden
+ hg.querySelectorAll("[data-gruppe]").forEach((gruppe) => {
+ const sichtbar = [...gruppe.querySelectorAll("[data-med]")]
+ .some((el) => el.style.display !== "none");
+ gruppe.style.display = sichtbar ? "" : "none";
+ });
+ });
+ },
+ });
+
+ /** Bietet an, die Gabe ohne Bestandsbuchung zu dokumentieren */
+ function zeigeBestandsWeg(el) {
+ const warnung = el.querySelector("[data-warnung]");
+ warnung.style.display = "";
+ warnung.innerHTML = `
+
+
📦
+
Der Lagerbestand reicht nicht. Eine Dokumentation darf daran
+ nicht scheitern — etwa wenn das Mittel aus dem RTW stammt.
+ Ohne Bestandsbuchung dokumentieren
+
Patient suchen
+
+
+
Mindestens zwei Zeichen eingeben.
+
+
+ Zu einem Einsatz zuordnen (freiwillig)
+
+
Symptome / Anamnese
+
+
Erste Untersuchung
+
+
Diagnose, Maßnahmen und Nachsorge trägst du
+ anschließend im Bogen nach.
+
Mindestens zwei Zeichen eingeben.
`;
+ return;
+ }
+ try {
+ const antwort = await aufruf("behandlung", "patientSuche", { begriff });
+ const treffer = antwort.treffer || [];
+ einsaetze = antwort.einsaetze || [];
+
+ liste.innerHTML = treffer.length ? treffer.map((t) => `
+
+
+
${sicher(t.firstname)} ${sicher(t.lastname)}
+
geb. ${sicher(t.dob)}
+ ${t.blutgruppe ? " · " + sicher(t.blutgruppe) : ""}
+
+ ${t.hinweis ? `
⚠ ` : ""}
+ ${t.allergien ? `
A ` : ""}
+ ${t.aufnahme ? `
aufgenommen ` : ""}
+
Keine Person gefunden.
`;
+
+ liste.querySelectorAll("[data-person]").forEach((el) => {
+ el.addEventListener("click", () => {
+ gewaehlt = treffer.find((t) => t.id === +el.dataset.person);
+ liste.querySelectorAll("[data-person]")
+ .forEach((zeile) => zeile.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ formular.style.display = "";
+
+ // Laufende Einsätze anbieten, an denen man beteiligt ist
+ if (einsaetze.length) {
+ einsatzfeld.style.display = "";
+ hg.querySelector("[name=einsatz]").innerHTML =
+ `— keinem Einsatz zuordnen — ` +
+ einsaetze.map((e) =>
+ `${sicher(e.nummer)} · ${sicher(e.titel)} `
+ ).join("");
+ }
+ });
+ });
+ } catch (f) { meldung(f.message, "fehler"); }
+ }, 260);
+ });
+ },
+ });
+ }
+
+ /* ---- Laden ---------------------------------------------------------------- */
+
+ async function oeffne(behaelter, behandlungId) {
+ try {
+ const d = await aufruf("behandlung", "oeffnen", { id: behandlungId });
+ z.offen = behandlungId;
+ z.offeneDaten = d;
+ einzelAnsicht(behaelter, d);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("behandlung", "uebersicht", {
+ ordner: z.ordner, begriff: z.suche,
+ });
+
+ // Sprungziel aus einem Hinweis, z. B. „Dokumentation fehlt"
+ const ziel = App.zustand.modulZiel;
+ if (ziel && ziel.behandlung) {
+ App.zustand.modulZiel = null;
+ return oeffne(behaelter, ziel.behandlung);
+ }
+
+ if (z.offen) await oeffne(behaelter, z.offen);
+ else uebersicht(behaelter);
+ } catch (f) {
+ behaelter.innerHTML = `Behandlungen
+
Konnte nicht geladen werden: ${sicher(f.message)}
+ ${eintraege.map((e) => `
+
+ ${sicher(e.text)}${e.zahl > 0 ? `${e.zahl} ` : ""}
+ `).join("")}
+
`;
+ }
+
+ function kennzahlen(d) {
+ const zk = d.zaehler;
+
+ return `
+
+
Eigene Entwürfe
+
${zk.meine}
+
nur du siehst sie
+
+
+
Warten auf Freigabe
+
${zk.freigabe}
+
liegen zur Unterschrift
+
+
+
Davon von dir
+
${zk.meineOffen}
+
eingereicht, noch nicht gezeichnet
+
+
+
Heute freigegeben
+
${zk.freigegeben}
+
endgültig, unveränderlich
+
+
+
+
Berichte
+
Das System schreibt keinen Satz. Der Weg vom Entwurf zur Freigabe wird
+ Schritt für Schritt gegangen — freigegeben wird durch Unterschrift,
+ nie durch Zeitablauf.
+
+ ${d.rechte.erstellen
+ ? `
＋ Bericht anlegen ` : ""}
+
+ Fremde Entwürfe sind nicht einsehbar —
+ erst mit dem Einreichen wird ein Bericht sichtbar.
+
+
+
+
+ ${
+ z.ordner === "meine" ? "Deine offenen Entwürfe"
+ : z.ordner === "freigabe" ? "Eingereicht, wartet auf Unterschrift"
+ : z.ordner === "freigegeben" ? "Freigegebene Berichte" : "Alle Berichte"}
+ ${d.liste.length} Einträge
+
+
+ ${d.liste.length ? d.liste.map(zeile).join("")
+ : `
Keine Berichte in diesem Ordner.
`}
+
+
+
${sicher(b.nummer)}
+
+
+
${sicher(b.titel)}
+
+ ${b.patientName ? sicher(b.patientName) : "ohne Patientenbezug"}
+ · ${sicher(b.autor)}
+ ${b.behandlungKennung ? " · " + sicher(b.behandlungKennung) : ""}
+ ${b.einsatzNummer ? " · " + sicher(b.einsatzNummer) : ""}
+
+
+
+ ${b.vonMir ? `
von dir ` : ""}
+ ${b.hatDiagnose ? "" : `
ohne Diagnose `}
+ ${b.unterschriften > 0
+ ? `
${b.unterschriften} Unterschrift(en) ` : ""}
+
+
+ ${sicher(statusName(b.status))}
+
${zeit(b.erstellt_am)}
+
+
${sicher(feld.name)}
+
${wert
+ ? sicher(wert).replace(/\n/g, "
+
+ ${sicher(feld.name)}
+
+
`;
+ }
+
+ function einzelAnsicht(behaelter, d) {
+ const b = d.bericht;
+ const schreibbar = d.rechte.aendern;
+
+ behaelter.innerHTML = `
+
+
+
${sicher(b.titel)}
+
${sicher(b.nummer)} · ${sicher(statusName(b.status))}
+ ${b.patientName ? " · " + sicher(b.patientName)
+ + (b.patientGeburt ? ", geb. " + sicher(b.patientGeburt) : "") : ""}
+
+
← Übersicht
+
+
🔒
+
Freigegeben. Der Wortlaut steht fest und wird nicht mehr geändert.
+ Eine weitere Unterschrift ist möglich, eine Änderung nicht.
+
+
✍
+
Liegt zur Freigabe. Bis zur Unterschrift ist der Text gesperrt.
+ ${b.vonMir ? "Zum Weiterschreiben musst du ihn zurückziehen." : ""}
+
+
ℹ
+
Verfasser und Freigabe sind dieselbe Person. Das ist zulässig und
+ steht so im Dokument.
+
+
+
Nummer ${sicher(b.nummer)}
+
Verfasser ${sicher(b.autor)}
+
Angelegt ${zeit(b.erstelltAm)}
+
Patient
+ ${sicher(b.patientName || "kein Bezug")}
+
Behandlung
+ ${sicher(b.behandlungKennung || "keine")}
+
Einsatz
+ ${sicher(b.einsatzNummer || "keiner")}
+
+
+
+ ${b.patient
+ ? `Patientenakte ` : ""}
+ ${schreibbar ? `
+ 🧩 Baustein
+ Entwurf speichern
+ ${b.behandlung
+ ? `Aus Behandlung übernehmen ` : ""}
+ Anlage
+ Einreichen ` : ""}
+ ${b.status === "eingereicht" && b.vonMir && d.rechte.erstellen
+ ? `Zurückziehen ` : ""}
+ ${b.status === "eingereicht" && d.rechte.freigeben ? `
+ Freigeben
+ Zurückweisen ` : ""}
+ ${b.status !== "entwurf" && d.rechte.freigeben
+ ? `Gegenzeichnen ` : ""}
+
+
+ Titel
+
` : ""}
+
+
+ ${d.felder.map((feld) => bogenFeld(feld, b[feld.id], schreibbar)).join("")}
+
+
+
+
+
+ Unterschriften
+ ${d.unterschriften.length} · nicht zurücknehmbar
+
+
+ ${d.unterschriften.length ? d.unterschriften.map((u) => `
+
+
+ ${sicher(unterschriftArt[u.art] || u.art)}
+
+
${sicher(u.name)}
+
${sicher(u.rolle || "")}
+ ${u.personalnummer ? " · " + sicher(u.personalnummer) : ""}
+
+
${zeit(u.am)}
+
`).join("")
+ : `
Noch nicht unterschrieben.
`}
+
+
+
+ Anlagen
+ ${d.anlagen.length}
+
+
+ ${d.anlagen.length ? d.anlagen.map((a, i) => `
+
+
+
${sicher(a.titel)}
+
${sicher(a.von)} · ${zeit(a.am)}
+
+ ${schreibbar
+ ? `
Entfernen `
+ : ""}
+
`).join("")
+ : `
Keine Anlagen.
`}
+
+
+
+
+
+ Weg des Berichts
+ aus dem Protokoll, unveränderlich
+
+
+ ${d.spur.length ? d.spur.map((s) => `
+
+
+
${sicher(s.aktion)}
+
${sicher(s.autor)}
+ ${s.grund ? " · " + sicher(s.grund) : ""}
+
+
${zeit(s.am)}
+
`).join("")
+ : `
Noch kein Eintrag.
`}
+
+
+
Titel
+
+
+ Patient (freiwillig)
+
+
+
Nicht jeder Bericht gehört zu einem Patienten.
+
+
Behandlung verknüpfen (freiwillig)
+
+
Einsatz verknüpfen (freiwillig)
+
+
Eine Verknüpfung erlaubt es später, den Wortlaut
+ der Behandlung ausdrücklich zu übernehmen. Von selbst wird nichts kopiert.
`,
+ bestaetigenText: "Anlegen",
+ bestaetigt: async (el, zu) => {
+ const titel = el.querySelector("[name=titel]").value.trim();
+ if (!titel) return meldung("Bitte einen Titel angeben.", "fehler");
+
+ try {
+ const antwort = await aufruf("bericht", "anlegen", {
+ titel, patient, behandlung, einsatz,
+ });
+ zu();
+ meldung(`Bericht ${antwort.nummer} angelegt.`, "gut");
+ z.ordner = "meine";
+ oeffne(behaelter, antwort.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ nachOeffnen: (hg) => {
+ const suchfeld = hg.querySelector("[name=suche]");
+ const liste = hg.querySelector("[data-treffer]");
+ const vorgaenge = hg.querySelector("[data-vorgaenge]");
+ let warten = null;
+
+ /** Lädt Behandlungen und Einsätze zum gewählten Patienten */
+ async function ladeVorgaenge() {
+ let antwort;
+ try {
+ antwort = await aufruf("bericht", "quellen", { patient });
+ } catch (f) { return meldung(f.message, "fehler"); }
+
+ vorgaenge.style.display = "";
+
+ const behListe = hg.querySelector("[data-behandlungen]");
+ behListe.innerHTML = antwort.behandlungen.length
+ ? antwort.behandlungen.map((b) => `
+
+
${sicher(b.kennung)}
+
+
${sicher(b.diagnose || "ohne Diagnose")}
+
${zeit(b.erstellt_am)}
+
+
+ ${sicher(b.status)}
+
Keine Behandlung erfasst.
`;
+
+ const einListe = hg.querySelector("[data-einsaetze]");
+ einListe.innerHTML = antwort.einsaetze.length
+ ? antwort.einsaetze.map((e) => `
+
+
${sicher(e.nummer)}
+
+
${sicher(e.titel)}
+
${zeit(e.erstellt_am)}
+
+
Kein Einsatz verknüpft.
`;
+
+ // Ein zweiter Klick nimmt die Verknüpfung wieder zurück
+ behListe.querySelectorAll("[data-behandlung]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const schon = behandlung === +el.dataset.behandlung;
+ behListe.querySelectorAll("[data-behandlung]")
+ .forEach((k) => k.classList.remove("gewaehlt"));
+ behandlung = schon ? null : +el.dataset.behandlung;
+ if (!schon) el.classList.add("gewaehlt");
+ });
+ });
+
+ einListe.querySelectorAll("[data-einsatz]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const schon = einsatz === +el.dataset.einsatz;
+ einListe.querySelectorAll("[data-einsatz]")
+ .forEach((k) => k.classList.remove("gewaehlt"));
+ einsatz = schon ? null : +el.dataset.einsatz;
+ if (!schon) el.classList.add("gewaehlt");
+ });
+ });
+ }
+
+ suchfeld.addEventListener("input", () => {
+ clearTimeout(warten);
+ warten = setTimeout(async () => {
+ const begriff = suchfeld.value.trim();
+ if (begriff.length < 2) return;
+
+ try {
+ const antwort = await aufruf("bericht", "quellen", { begriff });
+ const treffer = antwort.treffer || [];
+
+ liste.innerHTML = treffer.length ? treffer.map((t) => `
+
+
+
${sicher(t.name)}
+
geb. ${sicher(t.dob)}
+
+ ${t.blutgruppe
+ ? `
${sicher(t.blutgruppe)} ` : ""}
+
Keine Person gefunden.
`;
+
+ liste.querySelectorAll("[data-person]").forEach((el) => {
+ el.addEventListener("click", () => {
+ patient = +el.dataset.person;
+ behandlung = null;
+ einsatz = null;
+ liste.querySelectorAll("[data-person]")
+ .forEach((k) => k.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ ladeVorgaenge();
+ });
+ });
+ } catch (f) { meldung(f.message, "fehler"); }
+ }, 280);
+ });
+ },
+ });
+ }
+
+ /* ---- Wortlaut übernehmen ----------------------------------------------------- */
+
+ function uebernehmenFenster(behaelter, b, bogen) {
+ bestaetigen({
+ titel: "Wortlaut aus der Behandlung übernehmen",
+ inhalt: `
+ Aus ${sicher(b.behandlungKennung)} wird der dort dokumentierte Text
+ in diesen Bericht kopiert.
+
+
+
ℹ
+
Das System formuliert nichts um und fasst nichts zusammen —
+ es kopiert den Wortlaut. Bereits ausgefüllte Felder bleiben unberührt;
+ nur leere werden gefüllt. Was danach im Bericht steht, verantwortest du.
+
Ungespeicherte Änderungen im Bogen gehen dabei
+ verloren — der Entwurf wird zuerst gespeichert.
`,
+ bestaetigenText: "Übernehmen",
+ bestaetigt: async (_, zu) => {
+ try {
+ // Erst sichern, was der Verfasser bereits geschrieben hat
+ await aufruf("bericht", "speichern", bogen());
+ const antwort = await aufruf("bericht", "uebernehmen", {
+ id: b.id, behandlung: b.behandlung,
+ });
+ zu();
+ meldung(`Übernommen: ${antwort.uebernommen.join(", ")}.`, "gut");
+ oeffne(behaelter, b.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Anlage ------------------------------------------------------------------- */
+
+ function anlageFenster(behaelter, b) {
+ bestaetigen({
+ titel: "Anlage hinzufügen",
+ inhalt: `
+ Bezeichnung
+
+ Adresse
+
+ Die Anlage wird verlinkt, nicht hochgeladen.
+ Entfernen lässt sie sich nur, solange der Bericht ein Entwurf ist.
`,
+ bestaetigenText: "Hinzufügen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("bericht", "anlage", {
+ id: b.id,
+ titel: el.querySelector("[name=titel]").value.trim(),
+ adresse: el.querySelector("[name=adresse]").value.trim(),
+ });
+ zu();
+ meldung("Anlage hinzugefügt.", "gut");
+ oeffne(behaelter, b.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Einreichen und zurückziehen ------------------------------------------------ */
+
+ function einreichenFenster(behaelter, b, d, bogen) {
+ // Welche Felder sind im Bogen gerade leer?
+ const werte = bogen();
+ const leer = d.felder.filter((f) => !werte[f.id]).map((f) => f.name);
+
+ bestaetigen({
+ titel: "Bericht einreichen",
+ inhalt: `
+ ${sicher(b.nummer)} geht zur Freigabe. Du unterschreibst ihn damit
+ als Verfasser.
+
+ ${leer.length ? `
+
+
ℹ
+
Noch nicht ausgefüllt: ${sicher(leer.join(", "))}.
+ Das hält die Einreichung nicht auf — es steht nur so im Protokoll.
+
+
✍
+
Nach dem Einreichen ist der Text gesperrt. Zum Weiterschreiben musst du
+ den Bericht zurückziehen — das wird festgehalten.
+
${sicher(b.nummer)} geht zurück in den Entwurf und lässt sich
+ wieder bearbeiten.
+
+
ℹ
+
Deine Unterschrift als Verfasser bleibt stehen — sie wurde geleistet.
+ Dass du danach weitergeschrieben hast, steht im Protokoll.
+
Grund (Pflicht)
+
`,
+ bestaetigenText: "Zurückziehen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (!grund) return meldung("Bitte einen Grund angeben.", "fehler");
+ try {
+ await aufruf("bericht", "zurueckziehen", { id: b.id, grund });
+ zu();
+ meldung("Bericht zurückgezogen.", "gut");
+ oeffne(behaelter, b.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Freigabe ------------------------------------------------------------------- */
+
+ function freigebenFenster(behaelter, b, d) {
+ const leer = d.felder.filter((f) => !b[f.id]).map((f) => f.name);
+
+ bestaetigen({
+ titel: "Bericht freigeben",
+ inhalt: `
+ Du unterschreibst ${sicher(b.nummer)} — „${sicher(b.titel)}",
+ verfasst von ${sicher(b.autor)}.
+
+
+
🔒
+
Die Freigabe ist endgültig. Danach wird am Wortlaut nichts mehr
+ geändert — von niemandem.
+
+
ℹ
+
Du hast diesen Bericht selbst geschrieben. Verfasser und Freigabe in
+ einer Person ist zulässig und wird so im Dokument vermerkt.
+
+
📄
+
Nicht ausgefüllt: ${sicher(leer.join(", "))}.
+
Vermerk (freiwillig)
+
`,
+ bestaetigenText: "Freigeben",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("bericht", "freigeben", {
+ id: b.id, vermerk: el.querySelector("[name=vermerk]").value.trim(),
+ });
+ zu();
+ meldung("Bericht freigegeben.", "gut");
+ oeffne(behaelter, b.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ function zurueckweisenFenster(behaelter, b) {
+ bestaetigen({
+ titel: "Bericht zurückweisen",
+ gefahr: true,
+ inhalt: `
+ ${sicher(b.nummer)} geht als Entwurf an ${sicher(b.autor)} zurück.
+ Begründung (Pflicht)
+
+
Der Verfasser bekommt diese Begründung angezeigt.
Du setzt deine Unterschrift unter ${sicher(b.nummer)} .
+
+
✍
+
Eine Gegenzeichnung ändert nichts am Wortlaut und lässt sich nicht
+ zurücknehmen. Sie sagt nur: du hast diesen Bericht gelesen und trägst ihn mit.
+
Vermerk (freiwillig)
+
`,
+ bestaetigenText: "Gegenzeichnen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("bericht", "gegenzeichnen", {
+ id: b.id, vermerk: el.querySelector("[name=vermerk]").value.trim(),
+ });
+ zu();
+ meldung("Gegengezeichnet.", "gut");
+ oeffne(behaelter, b.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Laden -------------------------------------------------------------------- */
+
+ async function oeffne(behaelter, berichtId) {
+ try {
+ const d = await aufruf("bericht", "oeffnen", { id: berichtId });
+ z.offen = berichtId;
+ einzelAnsicht(behaelter, d);
+ } catch (f) {
+ meldung(f.message, "fehler");
+ z.offen = null;
+ }
+ }
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("bericht", "uebersicht", {
+ ordner: z.ordner, suche: z.suche,
+ });
+
+ // Sprungziel aus einem Hinweis, z. B. „Bericht zurückgewiesen"
+ const ziel = App.zustand.modulZiel;
+ if (ziel && ziel.bericht) {
+ App.zustand.modulZiel = null;
+ return oeffne(behaelter, ziel.bericht);
+ }
+
+ if (z.offen) await oeffne(behaelter, z.offen);
+ else uebersicht(behaelter);
+ } catch (f) {
+ behaelter.innerHTML = `Berichte
+
Konnte nicht geladen werden: ${sicher(f.message)}
+ ${eintraege.map((e) => `
+
+ ${sicher(e.text)}${e.zahl}
+ `).join("")}
+
`;
+ }
+
+ function kennzahlen(d) {
+ const zk = d.zaehler;
+
+ return `
+
+
Vorrätig
+
${zk.vorraetig}
+
frei verfügbare Konserven
+
+
+
Reserviert
+
${zk.reserviert}
+
für Patienten zurückgelegt
+
+
+
Läuft bald ab
+
${zk.baldAb}
+
innerhalb von ${d.vorlaufTage} Tagen
+
+
+
Über dem Datum
+
${zk.abgelaufen}
+
liegt weiter im Lager
+
+
+ ${d.bestand.map((b) => `
+
+
Blutgruppe ${sicher(b.gruppe)}
+
${b.vorraetig}
+
+ vorrätig · ${b.reserviert} reserviert
+ ${b.baldAb > 0 ? ` · ${b.baldAb} läuft ab` : ""}
+
+
`).join("")}
+
+
+
Blutbank
+
Das System verwirft keine Konserve und wählt keine aus. Ein abgelaufenes
+ Datum ist eine Erinnerung — ob eine Konserve noch brauchbar ist, beurteilt
+ ein Mensch.
+
+
+ Verträglichkeit nachschlagen
+ ${d.rechte.verwalten
+ ? `＋ Konserven einlagern ` : ""}
+
+
+
+ Alle Blutgruppen
+ ${d.gruppen.map((g) =>
+ `
+ ${sicher(g)} `).join("")}
+
+ ${z.ordner === "vorraetig"
+ ? "Die älteste Konserve steht oben — welche genommen wird, entscheidest du."
+ : "Klick auf eine Zeile öffnet die Konserve."}
+
+
+
+
+ ${z.ordner === "vorraetig" ? "Bestand"
+ : z.ordner === "reserviert" ? "Zurückgelegte Konserven"
+ : "Ausgegeben und verworfen"}
+ ${d.liste.length} Einträge
+
+
+ ${d.liste.length ? d.liste.map(zeile).join("")
+ : `
Keine Konserve in diesem Ordner.
`}
+
+
+
${sicher(k.konserve)}
+
${sicher(k.blutgruppe)}
+
+
+
${k.menge_ml} ml
+ ${k.lagerort ? `${sicher(k.lagerort)} ` : ""}
+
+ ${k.empfaenger ? "für " + sicher(k.empfaenger)
+ : "eingelagert " + zeit(k.eingelagert_am)}
+ · ${sicher(verfallText(k))}
+
+
+
+ ${k.vertraeglich === false
+ ? `
Tabelle ✕ ` : ""}
+ ${k.abgelaufen ? `
abgelaufen `
+ : k.laeuftBaldAb ? `
läuft ab ` : ""}
+
+
+ ${sicher(statusName(k.status))}
+
+
${k.status === "ausgegeben" ? zeit(k.ausgegeben_am)
+ : k.verfaellt_am ? sicher(String(k.verfaellt_am).slice(0, 10)) : "—"}
+
+
⚠
+
Weicht von der Verträglichkeitstabelle ab.
+ Konserve ${sicher(k.blutgruppe)} für einen Empfänger mit
+ ${sicher(k.empfaengerGruppe)}. Das System sperrt nichts —
+ die Entscheidung liegt bei dir.
+
+
📅
+
Über dem Verfallsdatum — ${sicher(verfallText(k))}.
+ Die Konserve bleibt im Bestand, bis jemand sie verwirft.
+
+
Status ${sicher(statusName(k.status))}
+
Blutgruppe ${sicher(k.blutgruppe)}
+
Menge ${k.menge} ml
+
Lagerort ${sicher(k.lagerort || "—")}
+
Eingelagert ${zeit(k.eingelagertAm)}
+
Eingelagert von ${sicher(k.eingelagertVon)}
+
Verfällt am
+ ${k.verfaelltAm ? sicher(String(k.verfaelltAm).slice(0, 10))
+ : "kein Datum"} · ${sicher(verfallText(k))}
+ ${k.empfaengerName ? `
+
Zurückgelegt für
+ ${sicher(k.empfaengerName)}
+ ${k.empfaengerGruppe ? ` (${sicher(k.empfaengerGruppe)})`
+ : " (Blutgruppe nicht bestimmt)"}
` : ""}
+ ${k.reserviertVon
+ ? `
Reserviert von ${sicher(k.reserviertVon)}
` : ""}
+ ${k.ausgegebenAm ? `
+
Ausgegeben ${zeit(k.ausgegebenAm)}
+
Ausgegeben von ${sicher(k.ausgegebenVon)}
` : ""}
+
+ ${k.status === "vorraetig"
+ ? `Für Patienten zurücklegen `
+ : `Reservierung aufheben `}
+ Ausgeben
+ Umlagern
+ Verwerfen
+
` : ""}
+
+
+ Weg der Konserve
+ aus dem Protokoll, unveränderlich
+
+
+ ${d.spur.length ? d.spur.map((s) => `
+
+
+
${sicher(s.aktion)}
+
${sicher(s.autor)}
+ ${s.grund ? " · " + sicher(s.grund) : ""}
+
+
${zeit(s.am)}
+
`).join("")
+ : `
Noch kein Eintrag.
`}
+
+
Blutgruppe
+
+ ${d.gruppen.map((g) =>
+ `${sicher(g)} `).join("")}
+
+
Anzahl
+
+
Menge je Konserve (ml)
+
+
Lagerort
+
+ ${(d.lagerorte || []).map((o) =>
+ `${sicher(o)} `).join("")}
+
+
+ Verfällt am (freiwillig)
+
+
Ohne Datum erinnert später nichts an einen Ablauf.
+ Mit Datum erinnert das System — verwerfen muss trotzdem jemand von Hand.
Vermerk (freiwillig)
+
`,
+ bestaetigenText: "Einlagern",
+ bestaetigt: async (el, zu) => {
+ try {
+ const antwort = await aufruf("blutbank", "einlagern", {
+ blutgruppe: el.querySelector("[name=blutgruppe]").value,
+ anzahl: +el.querySelector("[name=anzahl]").value,
+ menge: +el.querySelector("[name=menge]").value,
+ lagerort: el.querySelector("[name=lagerort]").value,
+ verfaellt: el.querySelector("[name=verfaellt]").value,
+ vermerk: el.querySelector("[name=vermerk]").value.trim(),
+ });
+ zu();
+ meldung(`${antwort.anzahl} Konserve(n) eingelagert.`, "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Reservieren ---------------------------------------------------------------- */
+
+ function reservierenFenster(behaelter, k) {
+ let gewaehlt = null;
+
+ bestaetigen({
+ titel: `${k.kennung} zurücklegen`,
+ inhalt: `
+ Konserve ${sicher(k.blutgruppe)} , ${k.menge} ml.
+
+ Patient suchen
+
+
+
Mindestens zwei Zeichen eingeben.
+
+
+ Vermerk (freiwillig)
+
`,
+ bestaetigenText: "Zurücklegen",
+ bestaetigt: async (el, zu) => {
+ if (!gewaehlt) return meldung("Bitte zuerst einen Patienten wählen.", "fehler");
+ try {
+ const antwort = await aufruf("blutbank", "reservieren", {
+ id: k.id,
+ patient: gewaehlt.id,
+ vermerk: el.querySelector("[name=vermerk]").value.trim(),
+ });
+ zu();
+ meldung(antwort.vertraeglich === false
+ ? "Zurückgelegt — die Abweichung wurde gemeldet."
+ : "Konserve zurückgelegt.", antwort.vertraeglich === false ? "" : "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ nachOeffnen: (hg) => {
+ const suchfeld = hg.querySelector("[name=suche]");
+ const liste = hg.querySelector("[data-treffer]");
+ const pruefung = hg.querySelector("[data-pruefung]");
+ let warten = null;
+
+ /** Zeigt, was die Nachschlagetabelle zu dieser Kombination sagt */
+ function zeigePruefung(person) {
+ const passt = vertraeglich(person.blutgruppe, k.blutgruppe);
+
+ pruefung.innerHTML = passt === null
+ ? `?
+
Blutgruppe nicht bestimmt. Zur Verträglichkeit lässt sich
+ nichts nachschlagen — das ist kein Hindernis, aber es steht so da.
✔
+
Laut Tabelle verträglich: Konserve ${sicher(k.blutgruppe)} für
+ Empfänger ${sicher(person.blutgruppe)}.
⚠
+
Laut Tabelle nicht verträglich: Konserve
+ ${sicher(k.blutgruppe)} für Empfänger ${sicher(person.blutgruppe)}.
+ Das System hält dich nicht auf — es meldet die Abweichung.
Mindestens zwei Zeichen eingeben.
`;
+ return;
+ }
+ try {
+ const antwort = await aufruf("blutbank", "patientSuche", { begriff });
+ const treffer = antwort.treffer || [];
+
+ liste.innerHTML = treffer.length ? treffer.map((t) => `
+
+
+
${sicher(t.firstname)} ${sicher(t.lastname)}
+
geb. ${sicher(t.dob)}
+
+ ${t.hinweis ? `
⚠ ` : ""}
+
+ ${sicher(t.blutgruppe || "nicht bestimmt")}
+ ${t.laufend ? `
${sicher(t.laufend)} ` : ""}
+
Keine Person gefunden.
`;
+
+ liste.querySelectorAll("[data-person]").forEach((el) => {
+ el.addEventListener("click", () => {
+ gewaehlt = treffer.find((t) => t.id === +el.dataset.person);
+ liste.querySelectorAll("[data-person]")
+ .forEach((zeile) => zeile.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ zeigePruefung(gewaehlt);
+ });
+ });
+ } catch (f) { meldung(f.message, "fehler"); }
+ }, 260);
+ });
+ },
+ });
+ }
+
+ function loesenFenster(behaelter, k) {
+ bestaetigen({
+ titel: "Reservierung aufheben",
+ inhalt: `
+ Konserve ${sicher(k.kennung)} war für
+ ${sicher(k.empfaengerName || "einen Patienten")} zurückgelegt und geht
+ zurück in den freien Bestand.
+ Grund (Pflicht)
+
`,
+ bestaetigenText: "Reservierung aufheben",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (!grund) return meldung("Bitte einen Grund angeben.", "fehler");
+ try {
+ await aufruf("blutbank", "reservierungLoesen", { id: k.id, grund });
+ zu();
+ meldung("Reservierung aufgehoben.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Ausgeben --------------------------------------------------------------------- */
+
+ function ausgebenFenster(behaelter, k) {
+ // Bei einer reservierten Konserve steht der Empfänger schon fest
+ let gewaehlt = k.empfaenger ? { id: k.empfaenger, blutgruppe: k.empfaengerGruppe } : null;
+
+ const passtSchon = k.empfaenger ? vertraeglich(k.empfaengerGruppe, k.blutgruppe) : null;
+
+ bestaetigen({
+ titel: `${k.kennung} ausgeben`,
+ gefahr: true,
+ inhalt: `
+ Konserve ${sicher(k.blutgruppe)} , ${k.menge} ml verlässt das Lager.
+
+
+
ℹ
+
Das System transfundiert nicht. Es hält fest, dass die Konserve
+ herausgegeben wurde. Alles Weitere verantwortet der Arzt am Patienten.
+
+
📅
+
Diese Konserve ist über dem Verfallsdatum —
+ ${sicher(verfallText(k))}. Die Ausgabe ist möglich und wird so vermerkt.
+
Empfänger
+
${sicher(k.empfaengerName)} ·
+ ${sicher(k.empfaengerGruppe || "Blutgruppe nicht bestimmt")}
+
⚠
+
Laut Tabelle nicht verträglich. Die Ausgabe wird trotzdem
+ dokumentiert und gemeldet.
+
Empfänger suchen (Pflicht)
+
+
+
Mindestens zwei Zeichen eingeben.
+
`}
+
+ Vermerk zur Ausgabe (Pflicht)
+
`,
+ bestaetigenText: "Ausgabe dokumentieren",
+ bestaetigt: async (el, zu) => {
+ if (!gewaehlt) return meldung("Bitte einen Empfänger wählen.", "fehler");
+
+ const vermerk = el.querySelector("[name=vermerk]").value.trim();
+ if (!vermerk) return meldung("Bitte einen Vermerk hinterlassen.", "fehler");
+
+ try {
+ const antwort = await aufruf("blutbank", "ausgeben", {
+ id: k.id, patient: gewaehlt.id, vermerk,
+ });
+ zu();
+ meldung(antwort.vertraeglich === false
+ ? "Ausgegeben — die Abweichung wurde gemeldet."
+ : "Ausgabe dokumentiert.", antwort.vertraeglich === false ? "" : "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ nachOeffnen: (hg) => {
+ const suchfeld = hg.querySelector("[name=suche]");
+ if (!suchfeld) return;
+
+ const liste = hg.querySelector("[data-treffer]");
+ const pruefung = hg.querySelector("[data-pruefung]");
+ let warten = null;
+
+ suchfeld.addEventListener("input", () => {
+ clearTimeout(warten);
+ warten = setTimeout(async () => {
+ const begriff = suchfeld.value.trim();
+ if (begriff.length < 2) return;
+ try {
+ const antwort = await aufruf("blutbank", "patientSuche", { begriff });
+ const treffer = antwort.treffer || [];
+
+ liste.innerHTML = treffer.length ? treffer.map((t) => `
+
+
+
${sicher(t.firstname)} ${sicher(t.lastname)}
+
geb. ${sicher(t.dob)}
+
+
+ ${sicher(t.blutgruppe || "nicht bestimmt")}
+
Keine Person gefunden.
`;
+
+ liste.querySelectorAll("[data-person]").forEach((el) => {
+ el.addEventListener("click", () => {
+ gewaehlt = treffer.find((t) => t.id === +el.dataset.person);
+ liste.querySelectorAll("[data-person]")
+ .forEach((zeile) => zeile.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+
+ const passt = vertraeglich(gewaehlt.blutgruppe, k.blutgruppe);
+ pruefung.innerHTML = passt === false
+ ? `⚠
+
Laut Tabelle nicht verträglich. Die Ausgabe bleibt
+ möglich und wird gemeldet.
?
+
Blutgruppe nicht bestimmt — nichts nachzuschlagen.
Konserve ${sicher(k.blutgruppe)} , ${k.menge} ml wird als verworfen
+ festgehalten und verschwindet aus dem Bestand.
+
+ ${k.empfaengerName ? `
+
+
🧍
+
Diese Konserve war für ${sicher(k.empfaengerName)} zurückgelegt.
+ Das wird allen im Dienst gemeldet.
+
Begründung (Pflicht)
+
+ Das Verfallsdatum allein verwirft nichts. Ob eine
+ Konserve noch brauchbar ist, beurteilst du.
`,
+ bestaetigenText: "Verwerfen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (grund.length < 3) return meldung("Bitte eine Begründung angeben.", "fehler");
+ try {
+ await aufruf("blutbank", "verwerfen", { id: k.id, grund });
+ zu();
+ meldung("Konserve verworfen.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Umlagern ------------------------------------------------------------------------ */
+
+ function umlagernFenster(behaelter, k) {
+ bestaetigen({
+ titel: `${k.kennung} umlagern`,
+ inhalt: `
+ Aktueller Lagerort: ${sicher(k.lagerort || "—")}
+ Neuer Lagerort
+
+ ${(z.daten.lagerorte || []).map((o) =>
+ `
+ ${sicher(o)} `).join("")}
+
+ Vermerk (freiwillig)
+
`,
+ bestaetigenText: "Umlagern",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("blutbank", "umlagern", {
+ id: k.id,
+ lagerort: el.querySelector("[name=lagerort]").value,
+ vermerk: el.querySelector("[name=vermerk]").value.trim(),
+ });
+ zu();
+ meldung("Lagerort geändert.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Verträglichkeitstabelle ------------------------------------------------------------ */
+
+ function tabellenFenster() {
+ const d = z.daten;
+
+ fenster({
+ titel: "Verträglichkeit nachschlagen",
+ inhalt: `
+
+
ℹ
+
Eine Nachschlagehilfe, keine Schranke. Das System sperrt keine
+ Konserve und wählt keine aus. Weicht eine Kombination ab, wird das
+ angezeigt und protokolliert — entschieden wird am Patienten.
+
+ ${d.gruppen.map((empfaenger) => {
+ const erlaubt = (d.vertraeglichkeit || {})[empfaenger] || [];
+ return `
+
${sicher(empfaenger)}
+
+
verträgt laut Tabelle
+
+ ${d.gruppen.map((spender) => `
+
+ ${sicher(spender)} `).join("")}
+
+
+
${erlaubt.length} von ${d.gruppen.length}
+
`;
+ }).join("")}
+
Blutbank
+
Konnte nicht geladen werden: ${sicher(f.message)}
+
${sicher(titel)}
+
${sicher(wert)}
+ ${zusatz ? `
${sicher(zusatz)}
` : ""}
+
+
${sicher(name)}
+
+
${belegt}/${gesamt}
+
+
+
Übersicht
+
Stand der Klinik. Alle Zahlen sind Momentaufnahmen —
+ sie lösen nichts aus und ersetzen keine Einschätzung am Patienten.
+
+
${zeit(new Date().toISOString())}
+
+ ${d.warnungen.map((w) => `
+
+
${w.art === "kritisch" ? "⚠" : "❗"}
+
${sicher(w.titel)} — ${sicher(w.text)}
+
`).join("")}
+
+ ${kachel(dienst.imDienst, "Im Dienst",
+ dienst.leitstelle ? "Leitstelle: " + dienst.leitstelle : "Leitstelle unbesetzt",
+ dienst.imDienst === 0 ? "hoch" : "gut")}
+ ${kachel(dienst.notaerzte, "Notärzte",
+ dienst.aufRtw + " auf RTW · " + dienst.imOp + " im OP")}
+ ${kachel(ein.offen, "Offene Notrufe",
+ ein.laufend + " laufend · " + ein.dringend + " dringend",
+ ein.offen > 0 ? "warn" : "", "leitstelle")}
+ ${kachel(pat.aufgenommen, "Patienten im Haus",
+ pat.wartend + " warten auf Aufnahme", "", "patienten")}
+
+
+
+ ${kachel(pat.intensiv, "Intensivpatienten",
+ pat.kritisch + " als kritisch eingetragen",
+ pat.kritisch > 0 ? "hoch" : "", "intensiv")}
+ ${kachel(bel.opLaufend + "/" + bel.opSaeleGesamt, "OP-Säle belegt",
+ bel.opGeplant + " geplant", "", "operation")}
+ ${kachel(bel.bettenFrei, "Freie Betten",
+ "von " + bel.bettenGesamt + " insgesamt",
+ bel.bettenFrei === 0 ? "hoch" : bel.bettenFrei <= 2 ? "warn" : "gut", "klinik")}
+ ${kachel(bel.behandlungFrei, "Freie Behandlungsräume",
+ "von " + bel.behandlungGesamt + " insgesamt",
+ bel.behandlungFrei === 0 ? "warn" : "", "klinik")}
+
+
+
+ ${kachel(offen.dokumentationen, "Offene Dokumentationen",
+ offen.eigeneDoku + " davon von dir",
+ offen.eigeneDoku > 0 ? "warn" : "", "behandlung")}
+ ${kachel(offen.laborOffen, "Laboraufträge offen",
+ offen.laborUnbefundet + " warten auf Bewertung", "", "labor")}
+ ${kachel(offen.berichteEntwurf, "Eigene Berichtsentwürfe",
+ "noch nicht eingereicht",
+ offen.berichteEntwurf > 0 ? "warn" : "", "bericht")}
+ ${kachel(pat.laengsteWartezeit > 0 ? minuten(pat.laengsteWartezeit) : "—",
+ "Längste Wartezeit",
+ pat.wartend + " Patienten warten",
+ pat.laengsteWartezeit >= 30 ? "hoch"
+ : pat.laengsteWartezeit >= 10 ? "warn" : "", "patienten")}
+
+
+
+
+
+ Wartende Patienten
+ Aufnahme entscheidet ein Mediziner
+
+
+ ${pat.warteliste.length ? pat.warteliste.map((p) => `
+
+
+
+
${sicher(p.firstname)} ${sicher(p.lastname)}
+
${sicher(String(p.grund).slice(0, 70))}
+
+
wartet ${minuten(p.wartet)}
+
`).join("")
+ : `
Niemand wartet auf Aufnahme.
`}
+
+
+
+
+
+ Offene und laufende Einsätze
+ Zuweisung durch die Leitstelle
+
+
+ ${ein.liste.length ? ein.liste.map((e) => `
+
+
+
${sicher(e.nummer)}
+
+
${sicher(e.titel)}
+
${sicher(e.ort || "Ort offen")}
+
+
+ ${e.status === "offen" ? "offen" : "laufend"}
+
`).join("")
+ : `
Keine offenen Einsätze.
`}
+
+
+
+
+
Belegung
+
+ ${belegungsBalken("Betten", bel.bettenBelegt, bel.bettenGesamt)}
+ ${belegungsBalken("Behandlungsräume",
+ bel.behandlungGesamt - bel.behandlungFrei, bel.behandlungGesamt)}
+ ${belegungsBalken("OP-Säle", bel.opLaufend, bel.opSaeleGesamt)}
+
+
+
+
+
+ Kollegen im Dienst
+ ${dienst.imDienst} anwesend
+
+
+ ${dienst.liste.length ? dienst.liste.slice(0, 8).map((m) => `
+
+
+
${sicher(m.personalnummer)}
+
+
${sicher(m.name)}
+
${sicher(m.rolleName)}
+ · ${sicher(stationsName(m.station))}
+
+ ${m.leitstelle ? `
Leitstelle ` : ""}
+
${sicher(funktionsName(m.funktion))}
+
`).join("")
+ : `
Niemand im Dienst.
`}
+
+
+
+ Das System unterstützt medizinische Entscheidungen — es trifft niemals selbst
+ welche. Es nimmt niemanden auf, entlässt niemanden, stellt keine Diagnose,
+ gibt kein Medikament aus und stellt keinen Tod fest. Wartezeiten und Fristen
+ laufen ab, ohne dass etwas passiert, bis ein Mediziner entscheidet.
+
+ `;
+
+ verdrahte(behaelter);
+ }
+
+ /** Farbe zum Dienststatus aus der Konfiguration */
+ function farbeZuStatus(status) {
+ const treffer = (App.zustand.status || []).find((s) => s.id === status);
+ return treffer ? treffer.farbe : "var(--flaeche-3)";
+ }
+
+ /** Klartextname einer Dienstfunktion */
+ function funktionsName(funktion) {
+ const treffer = (App.zustand.funktionen || []).find((f) => f.id === funktion);
+ return treffer ? treffer.name : (funktion || "—");
+ }
+
+ function verdrahte(behaelter) {
+ // Kacheln und Warnungen springen in das zuständige Modul
+ behaelter.querySelectorAll("[data-springe]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const ziel = el.dataset.springe;
+ if (!App.zustand.module.some((m) => m.id === ziel)) {
+ meldung("Dieses Modul steht dir nicht zur Verfügung.", "fehler");
+ return;
+ }
+ App.oeffneModul(ziel);
+ });
+ });
+ }
+
+ /* ---- Laden ------------------------------------------------------------ */
+
+ async function rendern(behaelter) {
+ z.behaelter = behaelter;
+ try {
+ z.daten = await aufruf("dashboard", "laden", {});
+ // Hinweise aus dem ersten Laden in den Kern übernehmen
+ App.zustand.hinweise = z.daten.hinweise || [];
+ zeichne(behaelter);
+ } catch (f) {
+ behaelter.innerHTML = `Übersicht
+
Konnte nicht geladen werden: ${sicher(f.message)}
+
+
Leitstelle
+
Notrufe erzeugen offene Einsätze. Wer hinfährt, entscheidet die
+ Leitstelle — und die angefragte Kraft selbst.
+
+
+ ${d.rechte.leitstelle && !d.istLeitstelle
+ ? `Leitstelle übernehmen ` : ""}
+ ${d.rechte.erstellen
+ ? `＋ Einsatz anlegen ` : ""}
+
+
+
+
Offen
+
${d.zaehler.offen}
+
noch niemand gebunden
+
+
+
Laufend
+
${d.zaehler.laufend}
+
Kräfte im Einsatz
+
+
+
Kräfte im Dienst
+
${d.kraefte.length}
+
${d.kraefte.filter((k) => !k.gebundenAn).length} ungebunden
+
+
+
Leitstelle
+
+ ${sicher(d.leitstelleName || "unbesetzt")}
+
${d.zaehler.heute} Einsätze heute beendet
+
+
+
+ Aktuelle Einsätze
+
+ Archiv
+
+
+
+
+
+ ${z.ordner === "archiv"
+ ? "Abgeschlossene Einsätze" : "Einsätze"}
+ ${d.rechte.zuweisen && z.ordner === "aktuell"
+ ? "Kraft von rechts auf einen Einsatz ziehen"
+ : d.einsaetze.length + " Einträge"}
+
+
+ ${d.einsaetze.length ? d.einsaetze.map(einsatzKarte).join("")
+ : `
${z.ordner === "archiv"
+ ? "Das Archiv ist leer." : "Keine offenen Einsätze."}
`}
+
+
+
+
+
+ Kräfte im Dienst
+ ${d.rechte.zuweisen ? "ziehbar" : "Übersicht"}
+
+
+ ${d.kraefte.length ? d.kraefte.map((k) => kraftZeile(k, d)).join("")
+ : `
Niemand im Dienst.
`}
+
+
+
+
+ ${sicher(e.nummer)}
+ ${sicher(e.status)}
+ ${e.ichDabei ? `du bist dabei ` : ""}
+ ${abgeschlossen
+ ? zeit(e.geschlossen_am) : "offen seit " + minuten(e.offenSeit)}
+
+
+
${sicher(e.titel)}
+
+
+ ${sicher(e.kategorieName)}
+ · ${sicher(prioText[e.prioritaet] || "")}
+ ${e.ort ? " · " + sicher(e.ort) : ""}
+ ${e.quelle === "notruf" ? ` · Notruf ` : ""}
+
+
+
+
${e.kraefte} Kraft/Kräfte gebunden
+ · angelegt von ${sicher(e.erstelltVon)}
+
+ ${e.pos_x ? `◎ ` : ""}
+ ${!abgeschlossen ? (e.ichDabei
+ ? `Abrücken `
+ : `Übernehmen `) : ""}
+ Details
+
+
+
+
+
${sicher(k.personalnummer)}
+
+
${sicher(k.name)}
+
${sicher(k.rolleName)} · ${sicher(funktion)}
+
+ ${k.leitstelle ? `
Leitstelle ` : ""}
+ ${k.gebundenAn
+ ? `
+ ${sicher(k.gebundenAn)} `
+ : `
frei `}
+
Du übernimmst die Disposition. Damit fragst du Kräfte für
+ Einsätze an — verpflichten kannst du niemanden.
`,
+ bestaetigenText: "Übernehmen",
+ bestaetigt: (_, zu) => {
+ zu();
+ anClient("leitstelle", {});
+ setTimeout(() => rendern(behaelter), 400);
+ },
+ });
+ });
+
+ behaelter.querySelectorAll("[data-oeffnen]").forEach((el) => {
+ el.addEventListener("click", (e) => {
+ e.stopPropagation();
+ oeffne(behaelter, +el.dataset.oeffnen);
+ });
+ });
+
+ behaelter.querySelectorAll("[data-beitreten]").forEach((el) => {
+ el.addEventListener("click", async (e) => {
+ e.stopPropagation();
+ try {
+ await aufruf("einsatz", "beitreten", { id: +el.dataset.beitreten });
+ meldung("Einsatz übernommen.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ });
+ });
+
+ behaelter.querySelectorAll("[data-verlassen]").forEach((el) => {
+ el.addEventListener("click", async (e) => {
+ e.stopPropagation();
+ try {
+ await aufruf("einsatz", "verlassen", { id: +el.dataset.verlassen });
+ meldung("Vom Einsatz abgerückt.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ });
+ });
+
+ behaelter.querySelectorAll("[data-wegpunkt]").forEach((el) => {
+ el.addEventListener("click", (e) => {
+ e.stopPropagation();
+ const einsatz = d.einsaetze.find((x) => x.id === +el.dataset.wegpunkt);
+ if (einsatz && einsatz.pos_x) {
+ anClient("wegpunkt", { x: einsatz.pos_x, y: einsatz.pos_y });
+ meldung("Wegpunkt gesetzt.");
+ }
+ });
+ });
+
+ if (d.rechte.zuweisen && z.ordner === "aktuell") verdrahteDisposition(behaelter);
+ }
+
+ /* ---- Disposition per Ziehen ---------------------------------------------- */
+
+ function verdrahteDisposition(behaelter) {
+ let gezogeneQuelle = null;
+
+ behaelter.querySelectorAll("[data-kraft]").forEach((el) => {
+ el.addEventListener("dragstart", (e) => {
+ gezogeneQuelle = +el.dataset.kraft;
+ el.classList.add("zieht");
+ // Ohne Nutzdaten lässt Firefox das Ziehen nicht zu
+ e.dataTransfer.setData("text/plain", String(gezogeneQuelle));
+ e.dataTransfer.effectAllowed = "link";
+ });
+
+ el.addEventListener("dragend", () => {
+ gezogeneQuelle = null;
+ el.classList.remove("zieht");
+ behaelter.querySelectorAll("[data-ziel]")
+ .forEach((ziel) => ziel.classList.remove("uebergabe"));
+ });
+ });
+
+ behaelter.querySelectorAll("[data-ziel]").forEach((el) => {
+ el.addEventListener("dragover", (e) => {
+ e.preventDefault();
+ e.dataTransfer.dropEffect = "link";
+ el.classList.add("uebergabe");
+ });
+
+ el.addEventListener("dragleave", () => el.classList.remove("uebergabe"));
+
+ el.addEventListener("drop", (e) => {
+ e.preventDefault();
+ el.classList.remove("uebergabe");
+ const quelle = gezogeneQuelle || +e.dataTransfer.getData("text/plain");
+ if (quelle) anfrageFenster(behaelter, +el.dataset.einsatz, quelle);
+ });
+ });
+ }
+
+ function anfrageFenster(behaelter, einsatzId, zielQuelle) {
+ const einsatz = z.daten.einsaetze.find((e) => e.id === einsatzId);
+ const kraft = z.daten.kraefte.find((k) => k.quelle === zielQuelle);
+ if (!einsatz || !kraft) return;
+
+ bestaetigen({
+ titel: "Kraft anfragen",
+ inhalt: `
+ ${sicher(kraft.name)} (${sicher(kraft.personalnummer)})
+ soll ${sicher(einsatz.nummer)} übernehmen:
+ ${sicher(einsatz.titel)}${einsatz.ort ? " — " + sicher(einsatz.ort) : ""}
+ ${kraft.gebundenAn ? `
+
+
⚠
+
Diese Kraft ist bereits an ${sicher(kraft.gebundenAn)} gebunden.
+
+
ℹ
+
Das ist eine Anfrage, keine Zuweisung. Die Kraft bekommt den
+ Einsatz mit Wegpunkt angezeigt und entscheidet selbst, ob sie übernimmt.
+
+
+
${sicher(e.nummer)} · ${sicher(e.titel)}
+
${sicher(e.kategorieName)} · ${sicher(prioText[e.prioritaet] || "")}
+ ${e.ort ? " · " + sicher(e.ort) : ""}
+
+
← Leitstelle
+
+
+
+ Einsatz
+ ${sicher(e.status)}
+
+
+
Angelegt ${zeit(e.erstelltAm)}
+
Von ${sicher(e.erstelltVon)}
+
Quelle ${sicher(e.quelle)}
+ ${e.geschlossenAm ? `
+
Abgeschlossen ${zeit(e.geschlossenAm)}
+
Durch ${sicher(e.geschlossenVon)}
` : ""}
+
+ ${e.beschreibung
+ ? `
${sicher(e.beschreibung).replace(/\n/g, "
` : ""}
+
+
+ ${e.position ? `
+ ◎ Wegpunkt ` : ""}
+ ${e.status !== "abgeschlossen" ? (d.ichDabei
+ ? `Abrücken `
+ : `Übernehmen `) : ""}
+ ${e.status !== "abgeschlossen" && d.rechte.zuweisen
+ ? `Priorität ` : ""}
+ ${e.status !== "abgeschlossen" && d.rechte.schliessen
+ ? `Abschließen ` : ""}
+
+
+
+
+
+ Beteiligte Kräfte
+ ${aktiveKraefte.length} gebunden
+
+
+ ${d.kraefte.length ? d.kraefte.map((k) => `
+
+
${sicher(k.personalnummer || "—")}
+
+
${sicher(k.name)}
+
${sicher(k.rolleName || "")} · seit ${zeit(k.seit)}
+
+
+ ${k.aktiv ? "im Einsatz" : "abgerückt"}
+
`).join("")
+ : `
Noch niemand übernommen.
`}
+
+
+
+
+ Einsatzverlauf
+ ＋ Notiz
+
+
+ ${d.notizen.length ? d.notizen.map((n) => `
+
+
+
${sicher(n.text)}
+
${sicher(n.autor)} · ${zeit(n.am)}
+
+
`).join("")
+ : `
Noch keine Einträge im Verlauf.
`}
+
+
+
+ Dokumentation zu diesem Einsatz
+ Das System legt keine an
+
+
+ ${d.behandlungen.length ? d.behandlungen.map((b) => `
+
+
${sicher(b.kennung)}
+
+
${sicher(b.patientName)}
+
${sicher(b.diagnose || "Noch keine Diagnose")}
+
+
+ ${sicher(b.status)}
+
`).join("")
+ : `
Noch keine Behandlung dokumentiert.
`}
+
+
Was ist passiert?
+
`,
+ knoepfe: [
+ { text: "Abbrechen", art: "leise", klick: (_, zu) => zu() },
+ { text: "Speichern", klick: async (el, zu) => {
+ try {
+ await aufruf("einsatz", "notiz", {
+ id: e.id, text: el.querySelector("[name=text]").value.trim(),
+ });
+ zu();
+ oeffne(behaelter, e.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ } },
+ ],
+ });
+ });
+
+ const prio = behaelter.querySelector("[data-prio]");
+ if (prio) prio.addEventListener("click", () => {
+ bestaetigen({
+ titel: "Priorität ändern",
+ inhalt: `
+ Aktuell: ${sicher(prioText[e.prioritaet])}
+ Neue Priorität
+
+ 1 — Sofort
+ 2 — Dringend
+ 3 — Regulär
+ 4 — Nachrangig
+
+ Begründung (Pflicht)
+
`,
+ bestaetigenText: "Setzen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (grund.length < 3) return meldung("Bitte eine Begründung angeben.", "fehler");
+ try {
+ await aufruf("einsatz", "prioritaet", {
+ id: e.id,
+ prioritaet: +el.querySelector("[name=prioritaet]").value,
+ grund,
+ });
+ zu();
+ meldung("Priorität geändert.", "gut");
+ oeffne(behaelter, e.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+
+ const schliessen = behaelter.querySelector("[data-schliessen]");
+ if (schliessen) schliessen.addEventListener("click", () => {
+ const dokumentiert = d.behandlungen.length;
+
+ bestaetigen({
+ titel: "Einsatz abschließen",
+ gefahr: true,
+ inhalt: `
+ ${sicher(e.nummer)} — ${sicher(e.titel)}
+ Alle noch gebundenen Kräfte werden abgemeldet.
+ ${dokumentiert === 0 ? `
+
+
📄
+
Zu diesem Einsatz ist noch keine Behandlung dokumentiert.
+ Das System legt keine an — du bekommst nur eine Erinnerung.
+ Abschließen ist trotzdem möglich.
+
Abschlussvermerk (Pflicht)
+
`,
+ bestaetigenText: "Abschließen",
+ bestaetigt: async (el, zu) => {
+ const vermerk = el.querySelector("[name=vermerk]").value.trim();
+ if (vermerk.length < 5) return meldung("Bitte einen Vermerk angeben.", "fehler");
+ try {
+ await aufruf("einsatz", "schliessen", { id: e.id, vermerk });
+ zu();
+ meldung("Einsatz abgeschlossen.", "gut");
+ z.offen = null;
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+ }
+
+ /* ---- Einsatz anlegen --------------------------------------------------------- */
+
+ function erstellenFenster(behaelter) {
+ const d = z.daten;
+
+ fenster({
+ titel: "Einsatz anlegen",
+ inhalt: `
+ Titel
+
+
+
Kategorie
+
+ ${d.kategorien.map((k) =>
+ `${sicher(k.name)} `).join("")}
+
+
Priorität
+
+ 1 — Sofort
+ 2 — Dringend
+ 3 — Regulär
+ 4 — Nachrangig
+
+
Ort
+
+ Beschreibung
+
+
Der Einsatz erscheint für alle als offen .
+ Alarmiert wird niemand gezielt.
Leitstelle
+
Konnte nicht geladen werden: ${sicher(f.message)}
+
+ ${sicher(titel)}
+ ${hat ? wert + " %" : "nie gemeldet"}
+
+
+
+
+ ${eintraege.map((e) => `
+
+ ${sicher(e.text)}${e.zahl}
+ `).join("")}
+
`;
+ }
+
+ function kennzahlen(d) {
+ const zk = d.zaehler;
+
+ return `
+
+
Verfügbar
+
${zk.verfuegbar}
+
so eingetragen
+
+
+
Im Einsatz
+
${zk.imEinsatz}
+
${zk.zugewiesen} Fahrzeuge zugewiesen
+
+
+
Wartung offen
+
${zk.werkstatt}
+
Werkstatt oder fällig
+
+
+
Außer Dienst
+
${zk.ausserDienst}
+
fahren nicht
+
+
+
+
Fuhrpark
+
Tank, Zustand und Position werden gemeldet, während jemand fährt.
+ Status, Wartung und Zuweisung trägt ein Mensch ein — das eine ändert
+ das andere nie.
+
+ ${d.rechte.pflegen
+ ? `
＋ Fahrzeug aufnehmen ` : ""}
+
+
+ Alle Fahrzeugarten
+ ${d.arten.map((a) =>
+ `
+ ${sicher(a.name)} `).join("")}
+
+ Eine Meldung älter als ${d.grenzen.meldung} Minuten
+ wird blass dargestellt.
+
+
+ ${d.liste.length
+ ? `${d.liste.map((f) => karte(f, d)).join("")}
`
+ : `Kein Fahrzeug in diesem Ordner.
+
+
+
${sicher(f.bezeichnung)}
+
${sicher(f.kennzeichen)}
+
+
+ ${sicher(f.statusName)}
+
+
+
+ ${sicher(f.artName)}
+ ${f.wartung !== "ok"
+ ? `${sicher(f.wartungName)} ` : ""}
+ ${f.zugewiesenAn
+ ? `${sicher(f.zugewiesenAn)} ` : ""}
+
+
+
+ ${balken("Tank", f.tank, d.grenzen.tank, f.meldungVeraltet)}
+ ${balken("Zustand", f.zustand, d.grenzen.zustand, f.meldungVeraltet)}
+
+
+
+ ${f.gemeldet_am
+ ? `gemeldet vor ${sicher(minuten(f.meldungAlter))}${
+ f.letzterFahrer ? " · " + sicher(f.letzterFahrer) : ""}`
+ : "noch nie gemeldet"}
+ ${f.notiz ? ` · ${sicher(f.notiz)}` : ""}
+
+
+
🔧
+
${sicher(f.wartungName)} ${f.notiz ? " — " + sicher(f.notiz) : ""}.
+ Eingetragen von Hand; ob das Fahrzeug fährt, steht im Einsatzstatus.
+
+
🕓
+
Die letzte Meldung ist ${sicher(minuten(f.meldungAlter))} alt.
+ Tank und Zustand sagen nichts über den jetzigen Stand.
+
+
Einsatzstatus ${sicher(f.statusName)}
+
Wartung ${sicher(f.wartungName)}
+
Art ${sicher(f.artName)}
+
Modell ${sicher(f.modell)}
+
Station ${sicher(f.station || "—")}
+
Zugewiesen an
+ ${sicher(f.zugewiesenAn || "niemand")}
+
+ Gemeldet
+ ${f.gemeldetAm
+ ? "vor " + sicher(minuten(f.meldungAlter)) + " von "
+ + sicher(f.letzterFahrer || "unbekannt")
+ : "noch nie"}
+
+
+ ${balken("Tank", f.tank, 20, f.meldungVeraltet)}
+ ${balken("Zustand", f.zustand, 60, f.meldungVeraltet)}
+
+ ${f.position
+ ? `Wegpunkt zur letzten Position `
+ : `Keine Position gemeldet.
`}
+
+
+ Ausstattung
+ notiert, nicht geprüft
+
+ ${ausstattung.length
+ ? `${ausstattung.map((a) =>
+ `${sicher(a)} `).join("")}
`
+ : `Nichts eingetragen.
`}
+
+
+ ${d.rechte.zuweisen
+ ? `Status setzen
+ Zuweisen ` : ""}
+ ${d.rechte.wartung
+ ? `Wartung ` : ""}
+ ${d.rechte.pflegen
+ ? `Bearbeiten ` : ""}
+ ${d.rechte.pflegen && f.status === "ausser_dienst"
+ ? `Aus dem Fuhrpark nehmen ` : ""}
+
+
+
+ Eingetragene Vorgänge
+ aus dem Protokoll, unveränderlich
+
+
+ ${d.spur.length ? d.spur.map((s) => `
+
+
+
${sicher(s.aktion)}
+
${sicher(s.autor)}
+ ${s.grund ? " · " + sicher(s.grund) : ""}
+
+
${zeit(s.am)}
+
`).join("")
+ : `
Noch kein Eintrag.
`}
+
Aktuell eingetragen: ${sicher(f.statusName)}
+
+ Neuer Status
+
+ ${d.status.map((s) =>
+ `
+ ${sicher(s.name)} `).join("")}
+
+
Werkstatt und Außer Dienst darf nur eintragen,
+ wer die Wartung führt — und beides braucht einen Grund.
Grund
+
+
+ ${f.zugewiesenAn ? `
+
+
🧍
+
Das Fahrzeug ist ${sicher(f.zugewiesenAn)} zugewiesen.
+ Bei Werkstatt oder Außer Dienst wird das gemeldet — die Zuweisung
+ selbst bleibt bestehen.
+
Zugewiesen ist zurzeit: ${sicher(f.zugewiesenAn || "niemand")}
+
+
+
ℹ
+
Eine Zuweisung ist ein Eintrag im Fahrzeugbuch. Sie spawnt kein
+ Fahrzeug, schließt keines auf und gibt keinen Schlüssel aus.
+
Im Dienst
+
+ ${k.liste.length ? k.liste.map((p) => `
+
+
+
${sicher(p.name)}
+ ${p.selbst ? `du ` : ""}
+
${sicher(p.rolleName)} ·
+ ${sicher(p.personalnummer || "")}
+
+
${sicher(p.funktion || "")}
+
`).join("")
+ : `
Niemand im Dienst.
`}
+
+
+
+ Vermerk / Grund
+
`,
+ bestaetigenText: "Eintragen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+
+ if (aufheben && !grund) {
+ return meldung("Bitte angeben, warum die Zuweisung entfällt.", "fehler");
+ }
+ if (!aufheben && !gewaehlt) {
+ return meldung("Bitte eine Person wählen.", "fehler");
+ }
+
+ try {
+ await aufruf("fahrzeug", "zuweisen", {
+ id: f.id,
+ charakter: aufheben ? null : gewaehlt,
+ grund,
+ });
+ zu();
+ meldung(aufheben ? "Zuweisung aufgehoben." : "Fahrzeug zugewiesen.", "gut");
+ rendern(behaelter);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ },
+ nachOeffnen: (hg) => {
+ hg.querySelectorAll("[data-person]").forEach((el) => {
+ el.addEventListener("click", () => {
+ gewaehlt = +el.dataset.person;
+ hg.querySelectorAll("[data-person]")
+ .forEach((zeile) => zeile.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ });
+ });
+
+ const haken = hg.querySelector("[name=aufheben]");
+ haken.addEventListener("change", () => {
+ aufheben = haken.checked;
+ hg.querySelector("[data-kollegen]").style.opacity = aufheben ? ".45" : "";
+ });
+ },
+ });
+ }
+
+ /* ---- Wartung ---------------------------------------------------------------------- */
+
+ function wartungFenster(behaelter, f, d) {
+ bestaetigen({
+ titel: "Wartungsstatus",
+ inhalt: `
+ Aktuell eingetragen: ${sicher(f.wartungName)}
+
+
+
ℹ
+
Ein gemeldeter Schaden setzt diesen Status nicht. Was das Spiel
+ meldet, ist eine Beobachtung — ob gewartet wird, beurteilst du.
+
Wartungsstatus
+
+ ${d.wartungsstatus.map((s) =>
+ `
+ ${sicher(s.name)} `).join("")}
+
+
+ Notiz
+
+ Ein leeres Feld löscht die Notiz.
`,
+ bestaetigenText: "Eintragen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("fahrzeug", "wartung", {
+ id: f.id,
+ wartung: el.querySelector("[name=wartung]").value,
+ notiz: el.querySelector("[name=notiz]").value.trim(),
+ });
+ zu();
+ meldung("Wartungsstatus eingetragen.", "gut");
+ rendern(behaelter);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Fahrzeug anlegen und bearbeiten ------------------------------------------------ */
+
+ function bearbeitenFenster(behaelter, f) {
+ const d = z.daten;
+ const neu = !f;
+ const vorhanden = String((f && f.ausstattung) || "")
+ .split(",").map((t) => t.trim()).filter(Boolean);
+ const eigene = vorhanden.filter((a) => !d.ausstattung.includes(a));
+
+ bestaetigen({
+ titel: neu ? "Fahrzeug aufnehmen" : `${f.bezeichnung} bearbeiten`,
+ inhalt: `
+
+ Über das Kennzeichen findet die Telemetrie das
+ Fahrzeug wieder — es muss genau dem im Spiel entsprechen.
+
+
+
Modell (Spawnname)
+
+
Art
+
+ ${d.arten.map((a) =>
+ `
+ ${sicher(a.name)} `).join("")}
+
+
Station
+
+ keine Zuordnung
+ ${d.stationen.map((s) =>
+ `
+ ${sicher(s.name)} `).join("")}
+
+
+ Ausstattung
+
+ ${d.ausstattung.map((a) => `
+ ${sicher(a)} `).join("")}
+
Weitere Ausstattung (mit Komma trennen)
+
`,
+ bestaetigenText: neu ? "Aufnehmen" : "Speichern",
+ bestaetigt: async (el, zu) => {
+ const gewaehlt = Array.from(el.querySelectorAll(".fz-teil-knopf.gewaehlt"))
+ .map((k) => k.dataset.teil);
+ const weitere = el.querySelector("[name=eigene]").value
+ .split(",").map((t) => t.trim()).filter(Boolean);
+
+ try {
+ await aufruf("fahrzeug", "speichern", {
+ id: neu ? null : f.id,
+ kennzeichen: el.querySelector("[name=kennzeichen]").value.trim(),
+ bezeichnung: el.querySelector("[name=bezeichnung]").value.trim(),
+ modell: el.querySelector("[name=modell]").value.trim(),
+ art: el.querySelector("[name=art]").value,
+ station: el.querySelector("[name=station]").value,
+ ausstattung: gewaehlt.concat(weitere).join(", "),
+ });
+ zu();
+ meldung(neu ? "Fahrzeug aufgenommen." : "Fahrzeug gespeichert.", "gut");
+ rendern(behaelter);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ },
+ nachOeffnen: (hg) => {
+ hg.querySelectorAll("[data-teil]").forEach((el) => {
+ el.addEventListener("click", () => el.classList.toggle("gewaehlt"));
+ });
+ },
+ });
+ }
+
+ function entfernenFenster(behaelter, f) {
+ bestaetigen({
+ titel: `${f.bezeichnung} aus dem Fuhrpark nehmen`,
+ gefahr: true,
+ inhalt: `
+ Das Fahrzeug verschwindet aus dem Fuhrpark. Die Protokolleinträge
+ dazu bleiben erhalten.
+ Grund (Pflicht)
+
`,
+ bestaetigenText: "Entfernen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (!grund) return meldung("Bitte einen Grund angeben.", "fehler");
+ try {
+ await aufruf("fahrzeug", "entfernen", { id: f.id, grund });
+ zu();
+ meldung("Fahrzeug entfernt.", "gut");
+ rendern(behaelter);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Laden ---------------------------------------------------------------------- */
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("fahrzeug", "uebersicht", { ordner: z.ordner, art: z.art });
+
+ uebersicht(behaelter);
+
+ // Sprungziel aus einem Hinweis, z. B. „Tankstand gemeldet"
+ const ziel = App.zustand.modulZiel;
+ if (ziel && ziel.fahrzeug) {
+ App.zustand.modulZiel = null;
+ return fahrzeugFenster(behaelter, ziel.fahrzeug);
+ }
+ } catch (f) {
+ behaelter.innerHTML = `Fuhrpark
+
Konnte nicht geladen werden: ${sicher(f.message)}
+ ${eintraege.map((e) => `
+
+ ${sicher(e.text)}${e.zahl}
+ `).join("")}
+
`;
+ }
+
+ function kennzahlen(d) {
+ const zk = d.zaehler;
+
+ return `
+
+
In Betreuung
+
${zk.laufend}
+
laufende Aufenthalte
+
+
+
Als kritisch eingetragen
+
${zk.kritisch}
+
von Hand eingestuft
+
+
+
Ohne zuständigen Arzt
+
${zk.ohneArzt}
+
niemand eingetragen
+
+
+
Ohne frischen Eintrag
+
${zk.langeStill}
+
seit über ${d.stilleNach} Minuten
+
+
+
+
Intensivstation
+
Das System misst nichts und schlägt keinen Alarm. Was hier steht, hat
+ jemand eingetragen — der Zustand ändert sich nie von selbst.
+
+ ${d.rechte.betreuen
+ ? `
＋ Intensivaufnahme ` : ""}
+
+
+ ${z.ordner === "laufend"
+ ? "Patienten in Intensivbetreuung" : "Beendete Aufenthalte"}
+ ${z.ordner === "laufend"
+ ? "Oben steht, was als am schwersten eingetragen wurde"
+ : d.liste.length + " Einträge"}
+
+
+ ${d.liste.length ? d.liste.map(zeile).join("")
+ : `
${z.ordner === "laufend"
+ ? "Zurzeit wird niemand intensiv betreut."
+ : "Noch keine beendeten Aufenthalte."}
`}
+
+
+
+
+
+
${sicher(a.name)}
+ geb. ${sicher(a.geburt)}
+
+ ${a.zimmerKennung ? "Zimmer " + sicher(a.zimmerKennung) : "ohne festen Platz"}
+ ${a.geraete ? " · " + sicher(String(a.geraete).slice(0, 60)) : ""}
+ ${laufend ? " · zuletzt dokumentiert vor " + sicher(minuten(a.stillSeit)) : ""}
+
+
+
+ ${a.warnhinweis ? `
⚠ ` : ""}
+ ${a.allergien ? `
A ` : ""}
+ ${a.blutgruppe ? `
${sicher(a.blutgruppe)} ` : ""}
+
+ ${a.langeStill ? `
Verlauf offen ` : ""}
+ ${laufend && !a.verantwortlichName
+ ? `
kein Arzt `
+ : a.verantwortlichName
+ ? `
${sicher(a.verantwortlichName)} ` : ""}
+
+
+ ${sicher(a.zustandName)}
+
+
${laufend
+ ? "seit " + sicher(minuten(a.liegtSeit))
+ : zeit(a.beendet_am)}
+
+
+
${sicher(a.name)}
+
geb. ${sicher(a.geburt)} · ${sicher(a.zustandName)}
+ ${a.zimmerKennung ? " · Zimmer " + sicher(a.zimmerKennung) : ""}
+ ${a.stationName ? " · " + sicher(a.stationName) : ""}
+
+
← Übersicht
+
+
✔
+
Intensivbetreuung beendet — ${zeit(a.beendetAm)} von
+ ${sicher(a.beendetVon || "unbekannt")}. Der Aufenthalt ist nur noch
+ zum Nachlesen da.
+
+
⚠
+
Warnhinweis — ${sicher(s.hinweis)}
+
+
💊
+
Allergien — ${sicher(s.allergien)}
+
+
🧑⚕️
+
Kein zuständiger Arzt eingetragen. Das System wählt keinen aus —
+ jemand muss die Verantwortung übernehmen.
+
+
${s.lichtbild
+ ? `
`
+ : `
Kein Lichtbild `}
+
+
+
Zustand
+
+ ${sicher(a.zustandName)}
+
In Betreuung seit
+ ${sicher(minuten(a.liegtSeit))}
+
Zuständig
+ ${sicher(a.verantwortlichName || "niemand eingetragen")}
+
Platz
+ ${sicher(a.zimmerKennung || "kein fester Platz")}
+
Blutgruppe
+ ${sicher(s.blutgruppe || "nicht bestimmt")}
+
Dauermedikation
+ ${sicher(s.dauermedikation || "keine erfasst")}
+
+
+
+ Patientenakte öffnen
+ ${a.aufnahme
+ ? `Aufnahme öffnen ` : ""}
+ ${a.laufend && d.rechte.betreuen ? `
+ Zustand eintragen
+ Geräte
+ Zuständigkeit
+ Betreuung beenden ` : ""}
+
+
+
+
Aufenthalt
+
+
Aufgenommen ${zeit(a.aufgenommenAm)}
+
Aufgenommen von ${sicher(a.aufgenommenVon)}
+ ${a.aufnahmeGrund
+ ? `
Grund der Aufnahme ${sicher(a.aufnahmeGrund)}
` : ""}
+ ${a.beendetAm ? `
+
Beendet ${zeit(a.beendetAm)}
+
Beendet von ${sicher(a.beendetVon)}
` : ""}
+
+
+
+ Angeschlossene Geräte
+ nur notiert, nicht gesteuert
+
+ ${geraete.length
+ ? `
${geraete.map((g) =>
+ `${sicher(g)} `).join("")}
`
+ : `
Nichts eingetragen.
`}
+
+
+ Grund der Intensivbetreuung
+
+
+ ${sicher(a.notiz || "Nichts eingetragen.")}
+
+
+
+
+ Verlauf
+ ${d.verlauf.length} Einträge
+
+
+ ${a.laufend && d.rechte.betreuen ? `
+
+
+
+ Eintrag schreiben
+ Der Wortlaut bleibt genau so stehen.
+
+
` : ""}
+
+ ${d.verlauf.length ? `
+
+ ${d.verlauf.map((v) => `
+
+
✎
+
+
+ ${sicher(v.autor)}
+ ${zeit(v.am)}
+
+
${sicher(v.text)}
+
+
`).join("")}
+
`
+ : `
Noch nichts dokumentiert.
`}
+
+
Patient (aufgenommen, ohne laufende Intensivbetreuung)
+
+ ${k.patienten.length ? k.patienten.map((p) => `
+
+
+
+
${sicher(p.name)}
+ geb. ${sicher(p.geburt)}
+
${sicher(String(p.grund || "").slice(0, 70))}
+
+ ${p.warnhinweis ? `
⚠ ` : ""}
+ ${p.allergien ? `
A ` : ""}
+ ${p.zimmerKennung ? `
${sicher(p.zimmerKennung)} ` : ""}
+
`).join("")
+ : `
Kein aufgenommener Patient verfügbar.
`}
+
+
Auf die Intensivstation kommt nur, wer bereits
+ aufgenommen ist. Die Reihenfolge ist die eingetragene Dringlichkeit.
+
Zustand bei Übernahme
+
+ ${(z.daten.zustaende || []).map((s) =>
+ `
+ ${sicher(s.name)} `).join("")}
+
+
Deine Einschätzung. Das System leitet sie aus nichts ab.
+
Platz auf der Intensivstation (freiwillig)
+
+ ${k.zimmer.length ? k.zimmer.map((zi) => `
+
+ ${sicher(zi.kennung)}
+ ${zi.belegt}/${zi.betten} belegt
+ ${zi.status !== "frei"
+ ? `${sicher(zi.status)} ` : ""}
+ `).join("")
+ : `
Kein Intensivplatz angelegt.
`}
+
+
Hier wird nur festgehalten, wo betreut wird.
+ Das Bett selbst belegt die Stationsverwaltung.
+
Angeschlossene Geräte (freiwillig)
+
+
+ Grund der Intensivbetreuung (Pflicht)
+
+
+ `,
+ bestaetigenText: "Aufnehmen",
+ bestaetigt: async (el, zu) => {
+ if (!gewaehlt) return meldung("Bitte zuerst einen Patienten wählen.", "fehler");
+
+ const notiz = el.querySelector("[name=notiz]").value.trim();
+ if (notiz.length < 5) return meldung("Bitte den Grund angeben.", "fehler");
+
+ try {
+ const antwort = await aufruf("intensiv", "aufnehmen", {
+ aufnahme: gewaehlt,
+ zimmer: gewaehltesZimmer,
+ zustand: el.querySelector("[name=zustand]").value,
+ geraete: el.querySelector("[name=geraete]").value.trim(),
+ notiz,
+ selbst: el.querySelector("[name=selbst]").checked,
+ });
+ zu();
+ meldung("Intensivaufenthalt eröffnet.", "gut");
+ z.ordner = "laufend";
+ oeffne(behaelter, antwort.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ nachOeffnen: (hg) => {
+ hg.querySelectorAll("[data-patient]").forEach((el) => {
+ el.addEventListener("click", () => {
+ gewaehlt = +el.dataset.patient;
+ hg.querySelectorAll("[data-patient]")
+ .forEach((zeile) => zeile.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ });
+ });
+
+ hg.querySelectorAll("[data-zimmer]").forEach((el) => {
+ el.addEventListener("click", () => {
+ // Ein zweiter Klick nimmt die Wahl wieder zurück
+ const schonGewaehlt = gewaehltesZimmer === +el.dataset.zimmer;
+ hg.querySelectorAll("[data-zimmer]").forEach((k) => k.classList.remove("gewaehlt"));
+ gewaehltesZimmer = schonGewaehlt ? null : +el.dataset.zimmer;
+ if (!schonGewaehlt) el.classList.add("gewaehlt");
+ });
+ });
+ },
+ });
+ }
+
+ /* ---- Zustand eintragen ------------------------------------------------------- */
+
+ function zustandFenster(behaelter, d) {
+ const a = d.aufenthalt;
+
+ bestaetigen({
+ titel: "Zustand eintragen",
+ inhalt: `
+ Aktuell eingetragen: ${sicher(a.zustandName)}
+ — von ${sicher(a.verantwortlichName || "niemandem")} verantwortet.
+
+ Neue Einschätzung
+
+ ${(d.zustaende || []).map((s) =>
+ `
+ ${sicher(s.name)} `).join("")}
+
+
+ Begründung (Pflicht)
+
+
Dieser Text wandert unverändert in den Verlauf.
+
ℹ
+
Das System steuert kein Gerät, liest keinen Wert aus und schlägt keinen
+ Alarm. Es hält fest, was jemand angeschlossen hat.
+
Aus der Liste
+
+ ${vorschlaege.map((g) => `
+ ${sicher(g)} `).join("")}
+
Weitere (mit Komma trennen)
+
`,
+ bestaetigenText: "Speichern",
+ bestaetigt: async (el, zu) => {
+ const gewaehlt = Array.from(el.querySelectorAll(".its-geraet-knopf.gewaehlt"))
+ .map((k) => k.dataset.geraet);
+ const eigeneTexte = geraeteTeile(el.querySelector("[name=eigene]").value);
+
+ try {
+ await aufruf("intensiv", "geraete", {
+ id: a.id,
+ geraete: gewaehlt.concat(eigeneTexte).join(", "),
+ });
+ zu();
+ meldung("Geräte eingetragen.", "gut");
+ oeffne(behaelter, a.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ nachOeffnen: (hg) => {
+ hg.querySelectorAll("[data-geraet]").forEach((el) => {
+ el.addEventListener("click", () => el.classList.toggle("gewaehlt"));
+ });
+ },
+ });
+ }
+
+ /* ---- Zuständigkeit -------------------------------------------------------------- */
+
+ async function zustaendigFenster(behaelter, d) {
+ const a = d.aufenthalt;
+
+ let b;
+ try {
+ b = await aufruf("intensiv", "betreuer", {});
+ } catch (f) { return meldung(f.message, "fehler"); }
+
+ let gewaehlt = a.verantwortlich || null;
+ let niederlegen = false;
+
+ bestaetigen({
+ titel: "Zuständigkeit",
+ inhalt: `
+ Zuständig ist zurzeit:
+ ${sicher(a.verantwortlichName || "niemand")}
+
+ Im Dienst und berechtigt
+
+ ${b.liste.length ? b.liste.map((p) => `
+
+
+
${sicher(p.name)}
+ ${p.selbst ? `du ` : ""}
+
${sicher(p.rolleName)} ·
+ ${sicher(p.personalnummer || "")}
+
+
${sicher(p.funktion || "")}
+
`).join("")
+ : `
Niemand mit diesem Recht ist im Dienst.
`}
+
+
Das System verteilt keine Zuständigkeit —
+ sie wird übernommen oder übertragen.
+
+
+ Vermerk${a.verantwortlich ? " / Grund" : " (freiwillig)"}
+
`,
+ bestaetigenText: "Übernehmen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+
+ if (niederlegen && !grund) {
+ return meldung("Bitte angeben, warum niemand mehr zuständig ist.", "fehler");
+ }
+ if (!niederlegen && !gewaehlt) {
+ return meldung("Bitte eine Person wählen.", "fehler");
+ }
+
+ try {
+ await aufruf("intensiv", "verantwortlich", {
+ id: a.id,
+ charakter: niederlegen ? null : gewaehlt,
+ grund,
+ });
+ zu();
+ meldung(niederlegen ? "Zuständigkeit niedergelegt." : "Zuständigkeit eingetragen.", "gut");
+ oeffne(behaelter, a.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ nachOeffnen: (hg) => {
+ hg.querySelectorAll("[data-person]").forEach((el) => {
+ el.addEventListener("click", () => {
+ gewaehlt = +el.dataset.person;
+ hg.querySelectorAll("[data-person]")
+ .forEach((zeile) => zeile.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ });
+ });
+
+ const haken = hg.querySelector("[name=niederlegen]");
+ haken.addEventListener("change", () => {
+ niederlegen = haken.checked;
+ // Die Personenliste wird unbrauchbar, sobald niedergelegt wird
+ hg.querySelector("[data-betreuer]").style.opacity = niederlegen ? ".45" : "";
+ });
+ },
+ });
+ }
+
+ /* ---- Betreuung beenden ------------------------------------------------------------ */
+
+ function beendenFenster(behaelter, d) {
+ const a = d.aufenthalt;
+
+ bestaetigen({
+ titel: "Intensivbetreuung beenden",
+ gefahr: true,
+ inhalt: `
+ ${sicher(a.name)} wird ab sofort nicht mehr intensiv betreut.
+
+
+
ℹ
+
Das ist keine Entlassung. Der Patient bleibt aufgenommen, sein Bett
+ bleibt belegt und keine Behandlung wird dadurch abgeschlossen.
+
+
⚠
+
Der Zustand steht weiterhin auf kritisch . Das Beenden ist
+ trotzdem möglich — es wird so festgehalten.
+
Begründung (Pflicht)
+
+
Dieser Text schließt den Verlauf ab.
Intensivstation
+
Konnte nicht geladen werden: ${sicher(f.message)}
+ ${eintraege.map((e) => `
+
+ ${sicher(e.text)}${e.zahl > 0 ? `${e.zahl} ` : ""}
+ `).join("")}
+
`;
+ }
+
+ function kennzahlen(d) {
+ const zk = d.zaehler;
+
+ return `
+
+
Ungelesen
+
${zk.ungelesen}
+
im Posteingang
+
+
+
Kenntnisnahme offen
+
${zk.offeneKenntnis}
+
von dir noch nicht bestätigt
+
+
+
Aushänge
+
${zk.aushaenge}
+
hängen gerade
+
+
+
Von dir gesendet
+
${zk.gesendet}
+
bleiben unverändert stehen
+
+
+
+
Nachrichten und Aushänge
+
Was hier steht, hat jemand geschrieben und unterschrieben. Eine gesendete
+ Nachricht lässt sich nicht mehr ändern, ein Aushang wird archiviert statt
+ gelöscht.
+
+
+ ${d.rechte.senden
+ ? `✉ Nachricht schreiben ` : ""}
+ ${d.rechte.schreiben
+ ? `＋ Aushang veröffentlichen ` : ""}
+
+
+
+ ${gesendet ? "Von dir gesendet" : "Posteingang"}
+ ${gesendet
+ ? "Gelesen heißt: jemand hat sie geöffnet"
+ : "Als gelesen gilt, was du geöffnet hast"}
+
+
+ ${d.liste.length ? d.liste.map(gesendet ? gesendetZeile : postZeile).join("")
+ : `
${gesendet
+ ? "Du hast noch nichts geschrieben." : "Keine Nachrichten."}
`}
+
+
+
+
+
+
${sicher(n.betreff || "(ohne Betreff)")}
+
${sicher(n.absenderName)} · ${sicher(n.vorschau)}
+
+
+
+ ${sicher(typName[n.empf_typ] || n.empf_typ)}
+
${zeit(n.gesendet)}
+
+
+
${sicher(n.betreff || "(ohne Betreff)")}
+
an ${sicher(n.empfaengerName)} · ${sicher(n.vorschau)}
+
+
+
+ ${sicher(typName[n.empf_typ] || n.empf_typ)}
+
${n.gelesenVon} gelesen
+
${zeit(n.gesendet)}
+
${archiv
+ ? "Nichts archiviert." : "Am Brett hängt nichts."}
${d.liste.map((a) => `
+
+
+
+ ${a.angeheftet ? `📌 ` : ""}
+ ${sicher(a.titel)}
+
${sicher(kategorieName(a.kategorie))}
+
+
+
${sicher(a.vorschau)}
+
+
+ ${sicher(a.autor)} · ${zeit(a.erstellt_am)}
+
+ ${a.station ? `${sicher(a.stationName)} ` : ""}
+ ${a.kenntnispflicht
+ ? (a.bestaetigt
+ ? `gelesen `
+ : `Kenntnis offen `)
+ : ""}
+ ${a.kenntnispflicht
+ ? `${a.kenntnisse} bestätigt ` : ""}
+ ${fristText(a)
+ ? `
+ ${sicher(fristText(a))} ` : ""}
+
+
+
+ ${archiv && a.archiviertVon
+ ? `
Abgenommen von ${sicher(a.archiviertVon)} ·
+ ${zeit(a.archiviert_am)}
` : ""}
+
`).join("")}
+
Von ${sicher(n.absenderName)}
+
An ${sicher(n.empfaengerName)}
+
Gesendet ${zeit(n.gesendet)}
+
${sicher(n.text)}
+
+ ${n.vonMir ? `
+
+ Gelesen von
+ ${d.leser.length} Person(en)
+
+
+ ${d.leser.length ? d.leser.map((l) => `
+
+
+
${zeit(l.gelesen_am)}
+
`).join("")
+ : `
Noch niemand hat sie geöffnet.
`}
+
+ Antworten
+
` : ""}
+ `,
+ nachOeffnen: (hg) => {
+ const antworten = hg.querySelector("[data-antworten]");
+ if (antworten) {
+ antworten.addEventListener("click", () => {
+ dialog.schliessen();
+ schreibenFenster(behaelter, {
+ typ: "person",
+ ziel: n.absender,
+ zielName: n.absenderName,
+ betreff: n.betreff && !/^Re:/i.test(n.betreff)
+ ? "Re: " + n.betreff : (n.betreff || ""),
+ });
+ });
+ }
+ },
+ });
+
+ // Der Posteingang zeigt sie danach als gelesen
+ rendernStill(behaelter);
+ }
+
+ /* ---- Nachricht schreiben -------------------------------------------------------- */
+
+ async function schreibenFenster(behaelter, vorgabe) {
+ let e;
+ try {
+ e = await aufruf("kommunikation", "empfaenger", {});
+ } catch (f) { return meldung(f.message, "fehler"); }
+
+ let typ = (vorgabe && vorgabe.typ) || "person";
+ let ziel = (vorgabe && vorgabe.ziel) || null;
+
+ bestaetigen({
+ titel: "Nachricht schreiben",
+ inhalt: `
+
+
ℹ
+
Eine abgeschickte Nachricht lässt sich weder ändern noch löschen.
+ Sie bleibt mit deinem Namen stehen.
+
Empfänger
+
+ Person
+ Station
+ ${e.rechte.rundmeldung
+ ? `Alle im Haus ` : ""}
+
+
+
+
+ ${e.personal.map((p) => `
+
+
+
${sicher(p.name)}
+ ${p.selbst ? `du ` : ""}
+
${sicher(p.rolleName)} ·
+ ${sicher(p.personalnummer || "")} · ${sicher(p.stationName)}
+
+ ${p.imDienst ? `
im Dienst `
+ : `
außer Dienst `}
+
`).join("")}
+
+
Wer nicht im Dienst ist, bekommt die Nachricht
+ beim nächsten Öffnen des Systems.
+
+ Station
+
+ ${e.stationen.map((s) =>
+ `${sicher(s.name)} `).join("")}
+
+
+
+
+
📣
+
Diese Nachricht geht an jeden im Haus und wird allen im Dienst
+ sofort gemeldet.
+
Betreff
+
+
+ Text
+
`,
+ bestaetigenText: "Abschicken",
+ bestaetigt: async (el, zu) => {
+ const text = el.querySelector("[name=text]").value.trim();
+ if (text.length < 2) return meldung("Bitte einen Text schreiben.", "fehler");
+
+ if (typ === "person" && !ziel) {
+ return meldung("Bitte einen Empfänger wählen.", "fehler");
+ }
+
+ const zielWert = typ === "station"
+ ? el.querySelector("[name=station]").value
+ : (typ === "person" ? ziel : null);
+
+ try {
+ const antwort = await aufruf("kommunikation", "senden", {
+ typ, ziel: zielWert,
+ betreff: el.querySelector("[name=betreff]").value.trim(),
+ text,
+ });
+ zu();
+ meldung(`Nachricht an ${antwort.empfaenger} abgeschickt.`, "gut");
+ z.ordner = "gesendet";
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ nachOeffnen: (hg) => {
+ // Empfängerart umschalten
+ hg.querySelectorAll("[data-typ]").forEach((el) => {
+ el.addEventListener("click", () => {
+ typ = el.dataset.typ;
+ hg.querySelectorAll("[data-typ]").forEach((k) => k.classList.remove("aktiv"));
+ el.classList.add("aktiv");
+ hg.querySelectorAll("[data-wahl]").forEach((block) => {
+ block.style.display = block.dataset.wahl === typ ? "" : "none";
+ });
+ });
+ });
+
+ // Person wählen
+ hg.querySelectorAll("[data-person]").forEach((el) => {
+ el.addEventListener("click", () => {
+ ziel = +el.dataset.person;
+ hg.querySelectorAll("[data-person]")
+ .forEach((zeile) => zeile.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ });
+ });
+
+ // Personenliste filtern
+ const suche = hg.querySelector("[name=suche]");
+ suche.addEventListener("input", () => {
+ const begriff = suche.value.trim().toLowerCase();
+ hg.querySelectorAll("[data-person]").forEach((el) => {
+ el.style.display = !begriff || el.dataset.suchtext.includes(begriff) ? "" : "none";
+ });
+ });
+ },
+ });
+ }
+
+ /* ---- Aushang lesen -------------------------------------------------------------- */
+
+ async function aushangFenster(behaelter, aushangId) {
+ let d;
+ try {
+ d = await aufruf("kommunikation", "aushang", { id: aushangId });
+ } catch (f) { return meldung(f.message, "fehler"); }
+
+ const a = d.aushang;
+
+ const dialog = fenster({
+ titel: a.titel,
+ inhalt: `
+ ${a.aktiv ? "" : `
+
+
📁
+
Archiviert — abgenommen von ${sicher(a.archiviertVon || "unbekannt")}
+ am ${zeit(a.archiviertAm)}. Der Wortlaut bleibt nachlesbar.
+
+
✋
+
Kenntnisnahme steht aus. Bestätigen kannst nur du selbst —
+ niemand kann das für dich tun.
+
+
🕓
+
${sicher(fristText(a))}. Eine abgelaufene Frist erinnert —
+ sie hat keine weitere Folge.
+
+
Kategorie ${sicher(kategorieName(a.kategorie))}
+
Gilt für ${sicher(a.stationName)}
+
Veröffentlicht ${zeit(a.erstelltAm)}
+
Von ${sicher(a.autor)}
+
${sicher(a.text)}
+
+
+ ${a.aktiv && a.kenntnispflicht && !a.bestaetigt
+ ? `Zur Kenntnis genommen ` : ""}
+ ${a.aktiv && d.rechte.schreiben
+ ? `Bearbeiten
+
+ ${a.angeheftet ? "Lösen" : "Anheften"} ` : ""}
+ ${a.aktiv && d.rechte.archivieren
+ ? `Abnehmen ` : ""}
+
+
+ ${a.textGesperrt && a.aktiv ? `
+
+ ${d.kenntnis.length} Person(en) haben diesen Wortlaut gelesen — Titel und Text
+ lassen sich deshalb nicht mehr ändern. Für eine Änderung: abnehmen und neu
+ veröffentlichen.
` : ""}
+
+ ${a.kenntnispflicht ? `
+
+
+
+ Zur Kenntnis genommen
+ ${d.kenntnis.length}
+
+
+ ${d.kenntnis.length ? d.kenntnis.map((k) => `
+
+
${sicher(k.personalnummer || "—")}
+
+
${zeit(k.bestaetigt_am)}
+
`).join("")
+ : `
Noch niemand.
`}
+
+
+
+
+
+ Steht noch aus
+ ${d.offen.length}
+
+
+ ${d.offen.length ? d.offen.map((o) => `
+
+
${sicher(o.personalnummer || "—")}
+
+
`).join("")
+ : `
Alle haben bestätigt.
`}
+
+
+
+
✋
+
Titel und Text sind gesperrt. Es haben bereits Personen diesen
+ Wortlaut zur Kenntnis genommen. Für eine inhaltliche Änderung den Aushang
+ abnehmen und neu veröffentlichen.
+
Titel
+
+
+
+
Kategorie
+
+ ${d.kategorien.map((k) =>
+ `
+ ${sicher(k.name)} `).join("")}
+
+
Gilt für
+
+ gesamte Klinik
+ ${d.stationen.map((s) =>
+ `
+ ${sicher(s.name)} `).join("")}
+
+
Text
+
+
+
+
+
+
+
+ Frist (freiwillig)
+
+
Läuft die Frist ab, geschieht nichts weiter —
+ es wird nur deutlicher erinnert.
„${sicher(a.titel)} " wird vom Brett genommen und wandert ins Archiv.
+ Gelöscht wird nichts — der Wortlaut und alle Kenntnisnahmen bleiben.
+ ${a.kenntnispflicht ? `
+
+
ℹ
+
Offene Kenntnisnahmen halten das Abnehmen nicht auf. Wie viele noch
+ ausstanden, wird im Protokoll festgehalten.
+
Grund (Pflicht)
+
`,
+ bestaetigenText: "Abnehmen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (!grund) return meldung("Bitte einen Grund angeben.", "fehler");
+ try {
+ const antwort = await aufruf("kommunikation", "aushangArchivieren",
+ { id: a.id, grund });
+ zu();
+ meldung(antwort.offen > 0
+ ? `Abgenommen — ${antwort.offen} Kenntnisnahme(n) standen noch aus.`
+ : "Aushang abgenommen.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Laden ------------------------------------------------------------------------ */
+
+ /** Frischt die Liste im Hintergrund auf, ohne ein offenes Fenster zu stören */
+ async function rendernStill(behaelter) {
+ try {
+ z.daten = await aufruf("kommunikation", "uebersicht", { ordner: z.ordner });
+ if (!document.querySelector(".fenster-hg")) uebersicht(behaelter);
+ } catch (f) { /* eine stille Auffrischung darf folgenlos scheitern */ }
+ }
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("kommunikation", "uebersicht", { ordner: z.ordner });
+
+ uebersicht(behaelter);
+
+ // Sprungziel aus einem Hinweis
+ const ziel = App.zustand.modulZiel;
+ if (ziel && ziel.nachricht) {
+ App.zustand.modulZiel = null;
+ return nachrichtFenster(behaelter, ziel.nachricht);
+ }
+ if (ziel && ziel.aushang) {
+ App.zustand.modulZiel = null;
+ return aushangFenster(behaelter, ziel.aushang);
+ }
+ } catch (f) {
+ behaelter.innerHTML = `Nachrichten und Aushänge
+
Konnte nicht geladen werden: ${sicher(f.message)}
+
+
Labor
+
Das Labor speichert Ergebnisse. Ob ein Wert etwas bedeutet,
+ entscheidet ein Mediziner — nicht das System.
+
+ ${d.rechte.beauftragen
+ ? `
＋ Laborauftrag stellen ` : ""}
+
+
+
Offen
+
${d.zaehler.offen}
+
wartet auf das Labor
+
+
+
Davon dringend
+
${d.zaehler.dringend}
+
vorrangig bearbeiten
+
+
+
Ohne Bewertung
+
${d.zaehler.befund}
+
Ergebnis da, Befund fehlt
+
+
+
Eigene Aufträge
+
${d.zaehler.meine}
+
von dir gestellt
+
+
+
+ Im Labor${d.zaehler.offen}
+
+ Bewertung offen${d.zaehler.befund}
+
+ Meine Aufträge
+
+ Archiv
+
+
+
+
+ Alle Probenarten
+ ${d.arten.map((a) =>
+ `
+ ${sicher(a.name)} `).join("")}
+
+
+
+
+
+ Aufträge
+ ${d.liste.length} Einträge
+
+
+ ${d.liste.length ? d.liste.map(zeile).join("")
+ : `
Kein Auftrag gefunden.
`}
+
+
+ ${l.dringend ? `
`
+ : `
`}
+
${sicher(l.kennung)}
+
+
${sicher(l.patientName)}
+ ${sicher(l.artName)}
+
${sicher(String(l.fragestellung || "").slice(0, 90))}
+
+
+ ${l.dringend ? `
dringend ` : ""}
+ ${l.hatErgebnis && !l.hatBefund
+ ? `
Befund fehlt ` : ""}
+ ${l.hatBefund ? `
befundet ` : ""}
+ ${l.eigene ? `
dein Auftrag ` : ""}
+
+
+ ${sicher(statusName[l.status] || l.status)}
+
${l.status === "offen" || l.status === "in_arbeit"
+ ? "seit " + minuten(l.offenSeit) : zeit(l.auftrag_am)}
+
+
+
${sicher(a.kennung)} · ${sicher(a.artName)}
+
${sicher(a.patientName)} · geb. ${sicher(a.geburt)}
+ ${a.dringend ? " · dringend " : ""}
+
+
← Übersicht
+
+
⚠
+
Warnhinweis — ${sicher(s.hinweis)}
+
+
+
Status ${sicher(statusName[a.status] || a.status)}
+
Beauftragt ${zeit(a.auftragAm)}
+
Von ${sicher(a.auftragVon)}
+ ${a.bearbeitetVon ? `
+
Im Labor ${sicher(a.bearbeitetVon)}
+
Angenommen ${zeit(a.bearbeitetAm)}
` : ""}
+
Blutgruppe (Stammdaten)
+ ${sicher(s.blutgruppe || "nicht bestimmt")}
+
+
+ Patientenakte
+ ${offen && d.rechte.bearbeiten
+ ? `In Arbeit nehmen ` : ""}
+ ${(offen || inArbeit) && d.rechte.bearbeiten
+ ? `Probe verwerfen ` : ""}
+
+
+
Fragestellung des Auftraggebers
+
${sicher(a.fragestellung || "—")}
+
+
+
+
+ Ergebnis — gemessene Werte
+ ${d.rechte.bearbeiten && !verworfen
+ ? `
+ ${a.ergebnis ? "Ergebnis ändern" : "Ergebnis eintragen"} ` : ""}
+
+
${a.ergebnis
+ ? sicher(a.ergebnis).replace(/\n/g, "
+
+ Reine Messwerte. Das System vergleicht sie mit nichts und markiert
+ nichts als auffällig.
+
+
+
+
+
+
+ Befund — ärztliche Bewertung
+ ${d.rechte.befunden && a.ergebnis && !verworfen
+ ? `
+ ${a.befund ? "Befund ändern" : "Befund eintragen"} ` : ""}
+
+
${a.befund
+ ? sicher(a.befund).replace(/\n/g, "
+
+ ${a.befundVon
+ ? `Bewertet von ${sicher(a.befundVon)} am ${zeit(a.befundAm)}.`
+ : "Die Bewertung stammt immer von einem Mediziner."}
+
+
+
+
+ Blutgruppe in die Stammdaten übernehmen
+
+
+ Falls in diesem Auftrag eine Blutgruppe bestimmt wurde: sie wandert
+ nicht von selbst in die Patientenakte. Du trägst sie ausdrücklich
+ ein und stehst dafür gerade.
+
+
+ Blutgruppe eintragen${s.blutgruppe ? " (aktuell: " + sicher(s.blutgruppe) + ")" : ""}
+
+
+
+ Frühere Aufträge dieses Patienten
+ zum Vergleich — nicht verrechnet
+
+
+ ${d.frueher.length ? d.frueher.map((f) => `
+
+
${sicher(f.kennung)}
+
+
${sicher(f.art)}
+
${zeit(f.auftrag_am)}
+
+
+ ${sicher(statusName[f.status] || f.status)}
+
`).join("")
+ : `
Keine früheren Aufträge.
`}
+
+
${sicher(a.kennung)} wird als verworfen abgelegt.
+ Der Auftraggeber wird informiert; ein neuer Auftrag muss von Hand
+ gestellt werden.
+ Begründung (Pflicht)
+
`,
+ bestaetigenText: "Verwerfen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (grund.length < 3) return meldung("Bitte eine Begründung angeben.", "fehler");
+ try {
+ await aufruf("labor", "verwerfen", { id: a.id, grund });
+ zu();
+ meldung("Auftrag verworfen.", "gut");
+ oeffne(behaelter, a.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+
+ const blutgruppe = behaelter.querySelector("[data-blutgruppe]");
+ if (blutgruppe) blutgruppe.addEventListener("click", () => blutgruppeFenster(behaelter, d));
+ }
+
+ /* ---- Ergebnis und Befund --------------------------------------------------- */
+
+ function ergebnisFenster(behaelter, d) {
+ const a = d.auftrag;
+
+ fenster({
+ titel: "Ergebnis eintragen · " + a.kennung,
+ inhalt: `
+
+ ${sicher(a.patientName)} · ${sicher(a.artName)}
+ Gemessene Werte
+
+
Nur Messwerte, keine Bewertung. Die Einordnung
+ nimmt anschließend ein Mediziner im Befund vor.
Vorlage einfügen ` : ""}`,
+ knoepfe: [
+ { text: "Abbrechen", art: "leise", klick: (_, zu) => zu() },
+ { text: "Ergebnis speichern", klick: async (el, zu) => {
+ try {
+ await aufruf("labor", "ergebnis", {
+ id: a.id, ergebnis: el.querySelector("[name=ergebnis]").value.trim(),
+ });
+ zu();
+ meldung("Ergebnis gespeichert. Der Auftraggeber wurde informiert.", "gut");
+ oeffne(behaelter, a.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ } },
+ ],
+ nachOeffnen: (hg) => {
+ const vorlage = hg.querySelector("[data-vorlage]");
+ if (vorlage) vorlage.addEventListener("click", () => {
+ const feld = hg.querySelector("[name=ergebnis]");
+ feld.value = d.vorlage;
+ feld.focus();
+ });
+ },
+ });
+ }
+
+ function befundFenster(behaelter, d) {
+ const a = d.auftrag;
+
+ bestaetigen({
+ titel: "Befund eintragen · " + a.kennung,
+ inhalt: `
+ Ergebnis des Labors
+
${sicher(a.ergebnis).replace(/\n/g, "
Deine Bewertung
+
+
Der Befund erscheint in der Patientenakte und im
+ Behandlungsbogen. Er trägt deinen Namen.
Ergebnis des Labors
+
${sicher(a.ergebnis).replace(/\n/g, "
Blutgruppe für ${sicher(a.patientName)}
+
+ — bitte wählen —
+ ${d.blutgruppen.map((b) =>
+ `
+ ${sicher(b)} `).join("")}
+
+
Das System liest die Blutgruppe nicht aus dem
+ Ergebnistext aus. Du wählst sie, und damit steht dein Name darunter.
+
⚠
+
In den Stammdaten steht bereits ${sicher(d.stamm.blutgruppe)} .
+ Ein Überschreiben wird protokolliert.
+
Patient suchen
+
+
+
Mindestens zwei Zeichen eingeben.
+
+
Probenart
+
+ ${d.arten.map((a) =>
+ `${sicher(a.name)} `).join("")}
+
+
Fragestellung
+
+
Je genauer die Frage, desto brauchbarer das
+ Ergebnis. Das Labor misst — bewerten musst du selbst.
+
+
+
Dringende Aufträge stehen im Labor oben und
+ erzeugen einen Hinweis mit hoher Priorität. Bearbeitet werden sie
+ trotzdem von einem Menschen.
+
+
Mindestens zwei Zeichen eingeben.
`;
+ return;
+ }
+ try {
+ const antwort = await aufruf("labor", "patientSuche", { begriff });
+ const treffer = antwort.treffer || [];
+
+ liste.innerHTML = treffer.length ? treffer.map((t) => `
+
+
+
${sicher(t.firstname)} ${sicher(t.lastname)}
+
geb. ${sicher(t.dob)}
+ ${t.blutgruppe ? " · " + sicher(t.blutgruppe)
+ : " · Blutgruppe nicht bestimmt"}
+
+ ${t.hinweis ? `
⚠ ` : ""}
+
Keine Person gefunden.
`;
+
+ liste.querySelectorAll("[data-person]").forEach((el) => {
+ el.addEventListener("click", () => {
+ gewaehlt = treffer.find((t) => t.id === +el.dataset.person);
+ liste.querySelectorAll("[data-person]")
+ .forEach((zeile) => zeile.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ formular.style.display = "";
+ });
+ });
+ } catch (f) { meldung(f.message, "fehler"); }
+ }, 260);
+ });
+ },
+ });
+ }
+
+ /* ---- Laden -------------------------------------------------------------------- */
+
+ async function oeffne(behaelter, laborId) {
+ try {
+ const d = await aufruf("labor", "oeffnen", { id: laborId });
+ z.offen = laborId;
+ einzelAnsicht(behaelter, d);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("labor", "uebersicht", {
+ ordner: z.ordner, art: z.art, begriff: z.suche,
+ });
+
+ // Sprungziel aus einem Hinweis, z. B. „Laborergebnis verfügbar"
+ const ziel = App.zustand.modulZiel;
+ if (ziel && ziel.labor) {
+ App.zustand.modulZiel = null;
+ return oeffne(behaelter, ziel.labor);
+ }
+
+ if (z.offen) await oeffne(behaelter, z.offen);
+ else uebersicht(behaelter);
+ } catch (f) {
+ behaelter.innerHTML = `Labor
+
Konnte nicht geladen werden: ${sicher(f.message)}
+
+
Medizinisches MDT
+
Patientensuche über Name, Geburtsdatum oder Telefonnummer.
+ Was in einer Akte steht, hat ein Mediziner eingetragen.
+
+
+
+
+
+
+ Treffer
+ ${z.treffer.length} Personen
+
+
+ ${z.treffer.length ? z.treffer.map(trefferZeile).join("")
+ : `
${z.suche.length >= 2
+ ? "Keine Person gefunden."
+ : "Mindestens zwei Zeichen eingeben."}
`}
+
+
+
${p.lichtbild
+ ? `
`
+ : `
— `}
+
+
${sicher(p.firstname)} ${sicher(p.lastname)}
+
+ geb. ${sicher(p.dob)}
+ ${p.telefon ? " · ☎ " + sicher(p.telefon) : ""}
+ ${p.blutgruppe ? " · " + sicher(p.blutgruppe) : " · Blutgruppe unbekannt"}
+
+
+ ${p.hinweis ? `
Warnhinweis ` : ""}
+ ${p.allergien ? `
Allergien ` : ""}
+ ${p.imHaus ? `
im Haus ` : ""}
+ ${p.wartet ? `
wartet ` : ""}
+
+
+
${sicher(p.name)}
+
geb. ${sicher(p.geburt)} · ${sicher(p.geschlecht === "w" ? "weiblich" : "männlich")}
+ ${p.telefon ? " · ☎ " + sicher(p.telefon) : ""}
+
+
← Suche
+
+
⚠
+
Warnhinweis — ${sicher(s.hinweis)}
+ ${s.gepflegtVon ? `Eingetragen von
+ ${sicher(s.gepflegtVon)}${s.gepflegtAm ? " am " + zeit(s.gepflegtAm) : ""}.
+ Das System hat diesen Hinweis nicht erzeugt. ` : ""}
+
+
+
🏥
+
${d.aufnahme.status === "wartend"
+ ? "Wartet auf Aufnahme" : "Aufgenommen"}
+ — ${sicher(d.aufnahme.grund)}
+ ${d.aufnahme.zimmer ? " · Zimmer " + sicher(d.aufnahme.zimmer) : ""}
+ Seit ${zeit(d.aufnahme.aufgenommen_am)}
+ durch ${sicher(d.aufnahme.aufgenommenVon)}.
+
+
+
🫀
+
Auf Intensivstation — Zustand als
+ ${sicher(d.intensiv.zustand)} eingetragen
+ ${d.intensiv.verantwortlichName
+ ? " · zuständig: " + sicher(d.intensiv.verantwortlichName) : ""}
+
+
+
${s.lichtbild
+ ? `
`
+ : `
Kein Lichtbild `}
+
+
+ ${wertZeile("Blutgruppe", s.blutgruppe, !s.blutgruppe && "nicht bestimmt")}
+ ${wertZeile("Allergien", s.allergien, "keine erfasst")}
+ ${wertZeile("Vorerkrankungen", s.vorerkrankungen, "keine erfasst")}
+ ${wertZeile("Dauermedikation", s.dauermedikation, "keine erfasst")}
+ ${wertZeile("Implantate", s.implantate, "keine erfasst")}
+ ${wertZeile("Organspende", s.organspenderName)}
+ ${wertZeile("Notfallkontakt", s.notfallkontakt, "keiner hinterlegt")}
+
+
+
+ ${d.rechte.stammdaten
+ ? `Stammdaten pflegen ` : ""}
+ ${d.rechte.hinweis
+ ? `
+ ${s.hinweis ? "Warnhinweis ändern" : "Warnhinweis setzen"} ` : ""}
+
+
+
+ Übersicht
+
+ Verlauf
+
+ Akten ${d.zaehler.akten}
+
+ Vermerke ${d.zaehler.notizen}
+
+
+
+ `;
+
+ verdrahteAkte(behaelter);
+ zeichneReiter(behaelter);
+ }
+
+ /** Eine Zeile im Stammdatenblock */
+ function wertZeile(name, wert, ersatz) {
+ const fehlt = !wert;
+ return `
+ ${sicher(name)}
+ ${fehlt ? sicher(ersatz || "nicht erfasst") : sicher(wert)}
+
`;
+ }
+
+ function verdrahteAkte(behaelter) {
+ behaelter.querySelector("[data-zurueck]").addEventListener("click", () => {
+ z.patient = null;
+ z.offeneAkte = null;
+ sucheAnsicht(behaelter);
+ });
+
+ behaelter.querySelectorAll("[data-reiter]").forEach((el) => {
+ el.addEventListener("click", () => {
+ z.reiter = el.dataset.reiter;
+ z.offeneAkte = null;
+ akteAnsicht(behaelter);
+ });
+ });
+
+ const stamm = behaelter.querySelector("[data-stamm]");
+ if (stamm) stamm.addEventListener("click", () => stammdatenFenster(behaelter));
+
+ const hinweis = behaelter.querySelector("[data-hinweis]");
+ if (hinweis) hinweis.addEventListener("click", () => hinweisFenster(behaelter));
+ }
+
+ /* ---- Reiterinhalte ------------------------------------------------------- */
+
+ async function zeichneReiter(behaelter) {
+ const ziel = behaelter.querySelector("#mdt-unterinhalt");
+ const patientId = z.patient.patient.id;
+
+ try {
+ if (z.reiter === "verlauf") {
+ z.unterdaten = await aufruf("mdt", "verlauf", { patient: patientId });
+ zeichneVerlauf(ziel);
+ } else if (z.reiter === "akten") {
+ z.unterdaten = await aufruf("mdt", "akten", { patient: patientId });
+ zeichneAkten(ziel, behaelter);
+ } else if (z.reiter === "notizen") {
+ z.unterdaten = await aufruf("mdt", "notizen", { patient: patientId });
+ zeichneNotizen(ziel, behaelter);
+ } else {
+ zeichneUebersicht(ziel);
+ }
+ } catch (f) {
+ ziel.innerHTML = `${sicher(f.message)}
`;
+ }
+ }
+
+ function zeichneUebersicht(ziel) {
+ const d = z.patient;
+ const zaehler = d.zaehler;
+
+ ziel.innerHTML = `
+
+
+
Behandlungen
+
${zaehler.behandlungen}
+
dokumentiert
+
+
+
Operationen
+
${zaehler.operationen}
+
dokumentiert
+
+
+
Laboraufträge
+
${zaehler.labor}
+
gestellt
+
+
+
Aufnahmen
+
${zaehler.aufnahmen}
+
insgesamt
+
+
+
Akten
+
${zaehler.akten}
+
angelegt
+
+
+
Vermerke
+
${zaehler.notizen}
+
geschrieben
+
+
+ Fehlende Angaben bedeuten „nicht erhoben", nicht „unauffällig".
+ Eine leere Allergieliste heißt, dass niemand danach gefragt oder es
+ eingetragen hat. Das System füllt keines dieser Felder von selbst und
+ schließt aus keinem etwas.
+
+ `;
+ }
+
+ function zeichneVerlauf(ziel) {
+ const eintraege = z.unterdaten.eintraege || [];
+
+ ziel.innerHTML = eintraege.length ? `
+
+
+ Zeitleiste
+ ${z.unterdaten.gesamt} Einträge insgesamt
+
+
+ ${eintraege.map((e) => {
+ const stil = verlaufsArt[e.art] || { symbol: "•", art: "neutral" };
+ return `
+
${stil.symbol}
+
+
+ ${sicher(e.titel)}
+ ${zeit(e.am)}
+
+ ${e.text ? `
${sicher(e.text)}
` : ""}
+ ${e.marker ? `
${sicher(e.marker)}
` : ""}
+
+
`;
+ }).join("")}
+
+
Für diesen Patienten ist noch nichts dokumentiert.
`;
+ }
+
+ function zeichneAkten(ziel, behaelter) {
+ const d = z.unterdaten;
+
+ // Eine einzelne Akte ist geöffnet
+ if (z.offeneAkte) return zeichneEinzelakte(ziel, behaelter);
+
+ ziel.innerHTML = `
+
+
+ Akten dieses Patienten
+ ${z.patient.rechte.akteErstellen
+ ? `＋ Akte anlegen ` : ""}
+
+
+ ${d.akten.length ? d.akten.map((a) => `
+
+
${sicher(a.aktenzeichen)}
+
+
${sicher(a.titel)}
+
${sicher(a.typName)} · ${sicher(a.autor)}
+ · ${zeit(a.erstellt_am)}
+
+
v${a.version}
+
${sicher(a.status)}
+
`).join("")
+ : `
Noch keine Akte angelegt.
`}
+
+
+
+
${sicher(a.aktenzeichen)} · Version ${a.version}
+
+ ${d.rechte.bearbeiten && a.status !== "geschlossen"
+ ? `Bearbeiten ` : ""}
+ ${d.rechte.freigeben && a.status !== "freigegeben" && a.status !== "geschlossen"
+ ? `Freigeben ` : ""}
+ ${d.rechte.schliessen && a.status !== "geschlossen"
+ ? `Schließen ` : ""}
+ ← Akten
+
+
+
+
${sicher(a.titel)}
+
+ ${sicher(a.status)}
+ Angelegt von ${sicher(a.autor)} am ${zeit(a.erstelltAm)}
+ ${a.freigabeVon ? ` · freigegeben von ${sicher(a.freigabeVon)}
+ am ${zeit(a.freigabeAm)}` : ""}
+
+
+
${a.inhalt
+ ? sicher(a.inhalt).replace(/\n/g, "Diese Akte hat noch keinen Inhalt. `}
+
+
+ Versionsverlauf
+ Nichts wird überschrieben
+
+
+ ${d.versionen.map((v) => `
+
+
+ v${v.version}
+
+
${sicher(v.kommentar || "ohne Kommentar")}
+
${sicher(v.autor)} · ${zeit(v.geaendert_am)}
+
+ ${v.version === a.version
+ ? `
aktuell `
+ : `
ansehen `}
+
`).join("")}
+
+
+
+ Vermerke
+ ＋ Vermerk
+
+
+ ${notizen.length ? notizen.map((n) => `
+
+
+
${sicher(n.text)}
+
${sicher(n.autor)}
+ ${n.personalnummer ? " (" + sicher(n.personalnummer) + ")" : ""}
+ · ${zeit(n.am)}
+
+ ${n.eigene ? `
von dir ` : ""}
+
`).join("")
+ : `
Keine Vermerke.
`}
+
+
Vermerk
+
+
Ein Vermerk ist keine Diagnose und ersetzt
+ keine Behandlungsdokumentation.
+
Blutgruppe
+
+ — nicht bestimmt —
+ ${d.blutgruppen.map((b) =>
+ `
+ ${sicher(b)} `).join("")}
+
+
Wird nicht aus dem Labor übernommen — die
+ Feststellung verantwortet ein Mediziner.
+
Organspende
+
+ ${Object.keys(d.organstatus).map((k) =>
+ `
+ ${sicher(d.organstatus[k])} `).join("")}
+
+
Allergien
+
+ Vorerkrankungen
+
+ Dauermedikation
+
+ Implantate
+
+ Notfallkontakt
+
+ Lichtbild (Bild-Adresse)
+
`,
+ knoepfe: [
+ { text: "Abbrechen", art: "leise", klick: (_, zu) => zu() },
+ { text: "Speichern", klick: async (el, zu) => {
+ const wert = (name) => el.querySelector(`[name=${name}]`).value.trim();
+ try {
+ await aufruf("mdt", "stammdaten", {
+ patient: d.patient.id,
+ blutgruppe: wert("blutgruppe"),
+ organspender: wert("organspender"),
+ allergien: wert("allergien"),
+ vorerkrankungen: wert("vorerkrankungen"),
+ dauermedikation: wert("dauermedikation"),
+ implantate: wert("implantate"),
+ notfallkontakt: wert("notfallkontakt"),
+ lichtbild: wert("lichtbild"),
+ });
+ zu();
+ meldung("Stammdaten gespeichert.", "gut");
+ oeffnePatient(behaelter, d.patient.id, z.reiter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ } },
+ ],
+ });
+ }
+
+ function hinweisFenster(behaelter) {
+ const d = z.patient;
+
+ bestaetigen({
+ titel: d.stamm.hinweis ? "Warnhinweis ändern" : "Warnhinweis setzen",
+ inhalt: `
+ Ein Warnhinweis erscheint bei jeder Suche und ganz oben in der Akte.
+ Er ist für Dinge gedacht, die vor jeder Maßnahme bekannt sein müssen.
+ Warnhinweis (leer lassen zum Entfernen)
+
+ Begründung
+
`,
+ bestaetigenText: "Übernehmen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("mdt", "hinweisSetzen", {
+ patient: d.patient.id,
+ hinweis: el.querySelector("[name=hinweis]").value.trim(),
+ grund: el.querySelector("[name=grund]").value.trim(),
+ });
+ zu();
+ meldung("Warnhinweis übernommen.", "gut");
+ oeffnePatient(behaelter, d.patient.id, z.reiter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ function akteAnlegenFenster(behaelter) {
+ const arten = z.unterdaten.aktenarten || [];
+
+ fenster({
+ titel: "Akte anlegen",
+ inhalt: `
+ Titel
+
+ Aktenart
+
+ ${arten.map((a) =>
+ `${sicher(a.name)} `).join("")}
+
+ Inhalt
+
+
Die Akte startet als Entwurf. Jede spätere Änderung
+ erzeugt eine neue Version — überschrieben wird nichts.
Titel
+
+ Inhalt
+
+ Was wurde geändert? (Pflicht)
+
+
Der Kommentar steht dauerhaft im Versionsverlauf.
+ Version ${a.version} bleibt unverändert erhalten.
nicht mehr ändern . Der Inhalt bleibt lesbar.",
+ };
+
+ bestaetigen({
+ titel: status === "freigegeben" ? "Akte freigeben" : "Akte schließen",
+ gefahr: status === "geschlossen",
+ inhalt: `${sicher(a.aktenzeichen)} — ${sicher(a.titel)}
+ ${beschreibung[status] || ""}
+ Vermerk (freiwillig)
+
`,
+ bestaetigenText: status === "freigegeben" ? "Freigeben" : "Schließen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("mdt", "akteStatus", {
+ id: a.id, status,
+ grund: el.querySelector("[name=grund]").value.trim(),
+ });
+ zu();
+ meldung("Status geändert.", "gut");
+ z.offeneAkte = await aufruf("mdt", "akteOeffnen", { id: a.id });
+ zeichneEinzelakte(behaelter.querySelector("#mdt-unterinhalt"), behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ async function versionAnsehen(version) {
+ try {
+ const v = await aufruf("mdt", "akteVersion", { id: z.offeneAkte.akte.id, version });
+
+ fenster({
+ titel: `Version ${v.version} · ${z.offeneAkte.akte.aktenzeichen}`,
+ inhalt: `
+ ${sicher(v.autor)} · ${zeit(v.geaendert_am)}
+ ${v.kommentar ? " · " + sicher(v.kommentar) : ""}
+ ${v.inhalt
+ ? sicher(v.inhalt).replace(/\n/g, "Diese Version hatte keinen Inhalt. `}
`,
+ });
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ /* ---- Laden ----------------------------------------------------------------- */
+
+ async function oeffnePatient(behaelter, patientId, reiter) {
+ try {
+ z.patient = await aufruf("mdt", "oeffnen", { patient: patientId });
+ z.reiter = reiter || "stamm";
+ z.offeneAkte = null;
+ akteAnsicht(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ async function rendern(behaelter) {
+ // Sprungziel aus einem anderen Modul oder aus einem Hinweis
+ const ziel = App.zustand.modulZiel;
+ if (ziel && ziel.patient) {
+ App.zustand.modulZiel = null;
+ return oeffnePatient(behaelter, ziel.patient);
+ }
+ if (ziel && ziel.akte) {
+ App.zustand.modulZiel = null;
+ try {
+ const akte = await aufruf("mdt", "akteOeffnen", { id: ziel.akte });
+ if (akte.akte.patient) {
+ await oeffnePatient(behaelter, akte.akte.patient, "akten");
+ z.offeneAkte = akte;
+ zeichneEinzelakte(behaelter.querySelector("#mdt-unterinhalt"), behaelter);
+ return;
+ }
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ if (z.patient) akteAnsicht(behaelter);
+ else sucheAnsicht(behaelter);
+ }
+
+ App.registriereAnsicht("mdt", { rendern });
+
+ App.registriereSuche(async (begriff) => {
+ try {
+ const d = await aufruf("mdt", "suche", { begriff });
+ return (d.treffer || []).slice(0, 5).map((p) => ({
+ bereich: "Patient",
+ titel: p.firstname + " " + p.lastname,
+ unter: "geb. " + p.dob + (p.blutgruppe ? " · " + p.blutgruppe : ""),
+ }));
+ } catch (e) { return []; }
+ });
+})();
diff --git a/resources/[aether]/aether-medical/html/js/module/medikament.js b/resources/[aether]/aether-medical/html/js/module/medikament.js
new file mode 100644
index 0000000..0eff4da
--- /dev/null
+++ b/resources/[aether]/aether-medical/html/js/module/medikament.js
@@ -0,0 +1,679 @@
+/* =====================================================================
+ aether-medical / Ansicht: Medikamentenverwaltung
+
+ Bestand, Buchungen und BTM-Buch. Das System zählt und erinnert —
+ nachbestellt, entnommen und entsorgt wird von Hand. Abgelaufene
+ Präparate werden auffällig markiert, aber nicht gesperrt.
+===================================================================== */
+"use strict";
+
+(() => {
+ const { sicher, zeit, aufruf, meldung, fenster, bestaetigen } = App;
+
+ const z = {
+ reiter: "bestand", // bestand | btm
+ filter: "",
+ kategorie: "",
+ suche: "",
+ stillgelegt: false,
+ daten: null,
+ offen: null,
+ btmMedikament: null,
+ // Aus der jeweils letzten Antwort uebernommen, damit Dialoge sie sicher haben
+ rechte: { bestand: false, btm: false, katalog: false },
+ kategorien: [],
+ };
+
+ /* ---- Übersicht ----------------------------------------------------------- */
+
+ function uebersicht(behaelter) {
+ const d = z.daten;
+
+ // Nach Kategorie gruppieren
+ const gruppen = {};
+ d.liste.forEach((m) => { (gruppen[m.kategorie] = gruppen[m.kategorie] || []).push(m); });
+
+ behaelter.innerHTML = `
+
+
+
Medikamente
+
Bestandsführung. Das System gibt nichts aus, verordnet nichts und
+ bestellt nichts nach — es zählt, was gebucht wurde.
+
+ ${d.rechte.katalog
+ ? `
＋ Medikament anlegen ` : ""}
+
+ ${kachel("gesamt", "Im Katalog", d.zaehler.gesamt, "aktive Präparate", "")}
+ ${kachel("knapp", "Unter Mindestbestand", d.zaehler.knapp,
+ "nachbestellen", d.zaehler.knapp > 0 ? "warn" : "")}
+ ${kachel("leer", "Nicht vorrätig", d.zaehler.leer,
+ "Bestand null", d.zaehler.leer > 0 ? "hoch" : "")}
+ ${kachel("verfall", "Läuft ab", d.zaehler.verfall,
+ "Verfallsdatum nahe", d.zaehler.verfall > 0 ? "warn" : "")}
+ ${kachel("btm", "Betäubungsmittel", d.zaehler.btm, "gesondert geführt", "")}
+
+
+
+
+ Bestand
+ ${d.rechte.btm
+ ? `
+ BTM-Buch ` : ""}
+
+
+
+
+ Alle Kategorien
+ ${d.kategorien.map((k) =>
+ `
+ ${sicher(k.name)} `).join("")}
+
+ ${z.filter
+ ? `Filter „${sicher(z.filter)}" aufheben `
+ : ""}
+ ${d.rechte.katalog
+ ? `
+ ${z.stillgelegt ? "Stillgelegte" : "Aktive"} ` : ""}
+
+
+ ${Object.keys(gruppen).length
+ ? Object.keys(gruppen).map((kategorie) => `
+
+
+ ${sicher(gruppen[kategorie][0].kategorieName)}
+ ${gruppen[kategorie].length} Präparate
+
+
${gruppen[kategorie].map(zeile).join("")}
+
Kein Medikament gefunden.
`}
+ `;
+
+ verdrahteUebersicht(behaelter);
+ }
+
+ function kachel(filter, titel, wert, zusatz, art) {
+ const aktiv = z.filter === filter;
+ return `
+
${sicher(titel)}
+
${wert}
+
${sicher(zusatz)}
+
+
${sicher(m.kennung)}
+
+
${sicher(m.name)}
+ ${m.btm ? `BTM ` : ""}
+
+ ${sicher(m.wirkstoff || "—")}
+ ${m.dosierung_standard ? " · " + sicher(m.dosierung_standard) : ""}
+ ${m.lagerort ? " · " + sicher(m.lagerort) : ""}
+
+
+
+ ${m.abgelaufen
+ ? `
abgelaufen `
+ : m.laeuftAb
+ ? `
+ in ${m.tageBisVerfall} Tagen ` : ""}
+ ${!m.aktiv ? `
stillgelegt ` : ""}
+
+
+
+
+ ${m.bestand} ${sicher(m.einheit)}
+
+
+
+
${sicher(m.kennung)} · ${sicher(m.name)}
+
${sicher(m.wirkstoff || "ohne Wirkstoffangabe")}
+ ${m.btm ? " · Betäubungsmittel " : ""}
+ ${m.aktiv ? "" : " · stillgelegt"}
+
+
← Bestand
+
+
⏳
+
Verfallsdatum überschritten — am ${zeit(m.verfaelltAm)}.
+ Das Präparat bleibt buchbar und
+ dokumentierbar. Ob es noch verwendbar ist, beurteilt die Apotheke —
+ das System sperrt nichts anhand eines Datums.
+
+
📦
+
${m.bestand <= 0 ? "Nicht vorrätig" : "Unter Mindestbestand"}
+ — ${m.bestand} von mindestens ${m.mindestbestand} ${sicher(m.einheit)}.
+ Nachbestellen muss jemand von Hand.
+
+
+
Bestand ${m.bestand} ${sicher(m.einheit)}
+
Mindestbestand ${m.mindestbestand} ${sicher(m.einheit)}
+
Standarddosierung
+ ${sicher(m.dosierung || "keine hinterlegt")}
+
Lagerort
+ ${sicher(m.lagerort || "nicht angegeben")}
+
Verfällt am
+ ${m.verfaelltAm ? String(m.verfaelltAm).slice(0, 10) : "kein Datum"}
+
Hinweis
+ ${sicher(m.hinweis || "keiner")}
+
+
+ ${d.rechte.bestand && m.aktiv
+ ? `Bestand buchen ` : ""}
+ ${d.rechte.katalog
+ ? `Stammdaten ` : ""}
+ ${d.rechte.katalog
+ ? `
+ ${m.aktiv ? "Stilllegen" : "Freigeben"} ` : ""}
+
+
+
+
+ Buchungen
+ Bestand nach jeder Buchung
+
+
+ ${d.buchungen.length ? d.buchungen.map((b) => `
+
+
+ ${sicher(b.artName)}
+
+
${b.art === "korrektur" ? "auf" : b.art === "ausgabe"
+ || b.art === "verfall" ? "−" : "+"} ${b.menge} ${sicher(m.einheit)}
+ Stand danach: ${b.bestand_danach}
+
${sicher(b.grund || "")}
+ ${b.patientName ? " · " + sicher(b.patientName) : ""}
+ · ${sicher(b.autor)} · ${zeit(b.gebucht_am)}
+
+
`).join("")
+ : `
Noch keine Buchung.
`}
+
+
+
+
+
+ Dokumentierte Gaben
+ aus den Behandlungsbögen
+
+
+ ${d.gaben.length ? d.gaben.map((g) => `
+
+
${sicher(g.behandlung)}
+
+
${sicher(g.patientName)}
+ ${g.menge} ${sicher(m.einheit)}
+
${g.dosierung ? sicher(g.dosierung) + " · " : ""}
+ ${sicher(g.autor)} · ${zeit(g.gegeben_am)}
+
+ ${g.ohneBuchung
+ ? `
+ ohne Buchung ` : ""}
+
`).join("")
+ : `
Noch keine Gabe dokumentiert.
`}
+
+
+
${sicher(m.kennung)} — ${sicher(m.name)}
+ ${freigeben
+ ? "Das Präparat steht wieder zur Auswahl."
+ : "Das Präparat lässt sich für neue Gaben nicht mehr auswählen."}
+ ${!freigeben && m.bestand > 0 ? `
+
+
📦
+
Es liegen noch ${m.bestand} ${sicher(m.einheit)} im Schrank.
+ Die Entnahme muss gebucht werden — das System bucht sie nicht weg.
+
Gelöscht wird nichts. Bestehende Gaben und Buchungen
+ bleiben vollständig nachvollziehbar.
+ Grund (freiwillig)
+
`,
+ bestaetigenText: freigeben ? "Freigeben" : "Stilllegen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("medikament", "schalten", {
+ id: m.id, aktiv: freigeben,
+ grund: el.querySelector("[name=grund]").value.trim(),
+ });
+ zu();
+ meldung(freigeben ? "Freigegeben." : "Stillgelegt.", "gut");
+ oeffne(behaelter, m.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+ }
+
+ /* ---- Buchen ----------------------------------------------------------------- */
+
+ function buchungsFenster(behaelter, d) {
+ const m = d.medikament;
+ // Die Ausgabe entsteht nur aus einer Gabe und fehlt hier bewusst
+ const arten = ["eingang", "ruecknahme", "verfall", "korrektur"];
+
+ bestaetigen({
+ titel: "Bestand buchen · " + m.name,
+ inhalt: `
+ Aktueller Bestand: ${m.bestand} ${sicher(m.einheit)}
+ Art der Buchung
+
+ ${arten.map((a) =>
+ `${sicher(d.buchungsarten[a].name)} `).join("")}
+
+
+ Wareneingang und Rücknahme erhöhen den Bestand,
+ Verfall entnommen verringert ihn.
+ Korrektur setzt ihn auf den gezählten Wert.
+ Eine Ausgabe entsteht ausschließlich aus einer dokumentierten Gabe.
+
Menge
+
+ Grund (Pflicht)
+
`,
+ bestaetigenText: "Buchen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (grund.length < 3) return meldung("Bitte einen Grund angeben.", "fehler");
+ try {
+ const antwort = await aufruf("medikament", "buchen", {
+ id: m.id,
+ art: el.querySelector("[name=art]").value,
+ menge: +el.querySelector("[name=menge]").value,
+ grund,
+ });
+ zu();
+ meldung("Gebucht. Neuer Bestand: " + antwort.bestand + " " + m.einheit + ".", "gut");
+ oeffne(behaelter, m.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ nachOeffnen: (hg) => {
+ // Bei einer Korrektur ist die Menge der neue Stand, nicht die Differenz
+ const art = hg.querySelector("[name=art]");
+ const label = hg.querySelector("[data-mengenlabel]");
+ art.addEventListener("change", () => {
+ label.textContent = art.value === "korrektur"
+ ? "Gezählter Bestand" : "Menge";
+ });
+ },
+ });
+ }
+
+ /* ---- Katalog ---------------------------------------------------------------- */
+
+ function katalogFenster(behaelter, m) {
+ const neu = !m;
+ m = m || {
+ kennung: "", name: "", wirkstoff: "", kategorie: "sonstiges",
+ dosierung: "", einheit: "Stück", mindestbestand: 0, lagerort: "",
+ verfaelltAm: null, hinweis: "", btm: false, sortierung: 0,
+ };
+
+ const darfBtm = z.rechte.btm;
+
+ fenster({
+ titel: neu ? "Medikament anlegen" : "Stammdaten · " + m.name,
+ inhalt: `
+
+
Kennung
+
+
Kategorie
+
+ ${z.kategorien.map((k) =>
+ `
+ ${sicher(k.name)} `).join("")}
+
+
Name
+
+ Wirkstoff
+
+
+
+
Standarddosierung
+
+
Ein Vorschlag im Gabe-Dialog, keine Verordnung.
+
Einheit
+
+
+
Mindestbestand
+
+
Ab hier erinnert das System.
+
Verfällt am
+
+
Hinweis
+
+
+
+
+
${darfBtm
+ ? "Betäubungsmittel erscheinen zusätzlich im BTM-Buch und erfordern für jede Gabe und Buchung das BTM-Recht."
+ : "Zum Kennzeichnen als Betäubungsmittel fehlt dir das BTM-Recht."}
+
+
ℹ
+
Ein neues Präparat startet mit Bestand 0 . Den Zugang buchst du
+ anschließend als Wareneingang — damit steht jede Menge im Schrank
+ nachvollziehbar in der Historie.
+
+
+
BTM-Buch
+
Lückenlose Bewegungsliste aller Betäubungsmittel. Reine Auskunft —
+ hier lässt sich nichts ändern.
+
+
← Bestand
+
+
Aktueller Stand
+
+ ${d.bestaende.length ? d.bestaende.map((b) => `
+
+
${sicher(b.kennung)}
+
+
${sicher(b.name)}
+
${sicher(b.lagerort || "kein Lagerort")}
+ ${b.verfaellt_am ? " · verfällt "
+ + String(b.verfaellt_am).slice(0, 10) : ""}
+
+ ${b.abgelaufen ? `
abgelaufen ` : ""}
+
+ ${b.bestand} ${sicher(b.einheit)}
+
`).join("")
+ : `
Keine Betäubungsmittel im Katalog.
`}
+
+
+
+ Gaben ohne Bestandsbuchung
+ ${d.ohneBuchung.length} Einträge
+
+
+ Diese Gaben wurden bewusst ohne Bestandsbuchung dokumentiert — etwa weil
+ das Präparat aus einem Fahrzeug stammte. Sie stehen hier, damit die
+ Zahlen im Buch erklärbar bleiben, nicht als Beanstandung.
+
+
+ ${d.ohneBuchung.map((g) => `
+
+
${sicher(g.behandlung)}
+
+
${sicher(g.name)}
+ ${g.menge} ${sicher(g.einheit)}
+
${sicher(g.patientName)}
+ · ${sicher(g.autor)} · ${zeit(g.gegeben_am)}
+
+
ohne Buchung
+
`).join("")}
+
+
+
+ Bewegungen
+ ${d.bewegungen.length} Einträge
+ ${d.gewaehlt ? "· gefiltert" : ""}
+
+ ${d.gewaehlt
+ ? `
Alle Präparate zeigen ` : ""}
+
+ ${d.bewegungen.length ? d.bewegungen.map((b) => `
+
+
+ ${sicher(b.artName)}
+
${sicher(b.kennung)}
+
+
${sicher(b.name)}
+ ${b.art === "korrektur" ? "auf"
+ : b.art === "ausgabe" || b.art === "verfall" ? "−" : "+"}
+ ${b.menge} ${sicher(b.einheit)} · Stand danach: ${b.bestand_danach}
+
${sicher(b.grund || "")}
+ ${b.patientName ? " · " + sicher(b.patientName) : ""}
+ · ${sicher(b.autor)}
+
+
${zeit(b.gebucht_am)}
+
`).join("")
+ : `
Keine Bewegungen erfasst.
`}
+
+
Medikamente
+
Konnte nicht geladen werden: ${sicher(f.message)}
+
+
Operationen
+
Der OP-Plan erinnert an Termine. Begonnen und beendet wird eine
+ Operation ausschließlich durch Eintrag des OP-Teams.
+
+ ${d.rechte.planen
+ ? `
＋ Operation planen ` : ""}
+
+
+
Geplant
+
${d.zaehler.geplant}
+
im OP-Plan
+
+
+
Termin erreicht
+
${d.zaehler.faellig}
+
wartet auf Beginn
+
+
+
Laufend
+
${d.zaehler.laufend}
+
Eingriffe im Gange
+
+
+
Heute beendet
+
${d.zaehler.heute}
+
abgeschlossen
+
+
+
+ OP-Säle
+ Belegung ergibt sich aus laufenden Eingriffen
+
+
+ ${d.saele.length ? d.saele.map(saalKachel).join("")
+ : `
Keine OP-Säle angelegt.
`}
+
+
+
+ OP-Plan${d.zaehler.geplant + d.zaehler.laufend}
+
+ Laufend${d.zaehler.laufend}
+
+ Archiv
+
+
+
+
+ ${z.ordner === "archiv"
+ ? "Abgeschlossene und abgesagte Operationen" : "Eingriffe"}
+ ${d.liste.length} Einträge
+
+
+ ${d.liste.length ? d.liste.map(zeile).join("")
+ : `
Nichts geplant.
`}
+
+
+
+ ${sicher(s.kennung)}
+
+ ${belegt ? "belegt" : gesperrt ? "gesperrt" : "frei"}
+
+ ${belegt ? `
+
+
${sicher(s.laufend.kennung)} · ${sicher(s.laufend.art)}
+
${sicher(s.laufend.patientName)}
+ · läuft seit ${minuten(s.laufend.dauer)}
+
`
+ : `
+
${s.geplant} geplante Eingriffe
+ ${s.hinweis ? " · " + sicher(s.hinweis) : ""}
+
`}
+
+
${sicher(o.kennung)}
+
+
${sicher(o.art)}
+ ${sicher(o.patientName)}
+
+ ${o.saalName ? "Saal " + sicher(o.saalName) : "kein Saal"}
+ · ${o.teamGroesse} im Team
+ · geplant von ${sicher(o.erstelltVon)}
+
+
+
+ ${o.hinweis ? `
⚠ ` : ""}
+ ${o.allergien ? `
A ` : ""}
+ ${o.blutgruppe ? `
${sicher(o.blutgruppe)} ` : ""}
+ ${o.hatKomplikationen ? `
Komplikationen ` : ""}
+ ${o.ichDabei ? `
du bist im Team ` : ""}
+ ${faellig ? `
Termin erreicht ` : ""}
+
+
${sicher(o.status)}
+
${laufend
+ ? "läuft seit " + minuten(o.dauerMinuten)
+ : o.status === "geplant"
+ ? (o.geplant_fuer
+ ? (o.restMinuten > 0 ? "in " + minuten(o.restMinuten) : "seit " + minuten(-o.restMinuten) + " fällig")
+ : "ohne Termin")
+ : zeit(o.ende)}
+
+
+
${sicher(o.kennung)} · ${sicher(o.art)}
+
${sicher(o.patientName)} · geb. ${sicher(o.geburt)}
+ ${o.saalName ? " · Saal " + sicher(o.saalName) : ""}
+
+
← OP-Plan
+
+
⚠
+
Warnhinweis — ${sicher(s.hinweis)}
+
+
💊
+
Allergien — ${sicher(s.allergien)}
+
+
🔩
+
Implantate — ${sicher(s.implantate)}
+
+
🕐
+
Zeitgleich im selben Saal:
+ ${d.ueberschneidungen.map((u) =>
+ `${sicher(u.kennung)} (${sicher(u.patientName)})`).join(", ")}
+ Das System verhindert nichts — vielleicht
+ ist der andere Eingriff früher fertig. Die Entscheidung liegt bei dir.
+
+
+
+
Status ${sicher(o.status)}
+
Geplant für ${o.geplantFuer
+ ? zeit(o.geplantFuer) : "ohne Termin"}
+
Beginn ${o.beginn ? zeit(o.beginn) : "noch nicht begonnen"}
+
Ende ${o.ende ? zeit(o.ende) : "—"}
+
Geplant von ${sicher(o.erstelltVon)}
+
Blutgruppe
+ ${sicher(s.blutgruppe || "nicht bestimmt")}
+
+
+ Patientenakte
+ ${geplant && d.rechte.dokumentieren
+ ? `Operation beginnen ` : ""}
+ ${laufend && d.rechte.dokumentieren
+ ? `Operation beenden ` : ""}
+ ${geplant && d.rechte.planen
+ ? `Umplanen ` : ""}
+ ${!beendet && d.rechte.dokumentieren
+ ? `
+ ${d.ichDabei ? "Team verlassen" : "Ins Team eintreten"} ` : ""}
+ ${!beendet && d.rechte.planen
+ ? `Absagen ` : ""}
+
+
+
+
+ OP-Team
+ ${!beendet && d.rechte.planen
+ ? `＋ Mitglied ` : ""}
+
+
+ ${d.team.length ? d.team.map((t) => `
+
+
+ ${sicher(t.funktionName)}
+
+
${sicher(t.name)}
+
${sicher(t.personalnummer || "—")}
+ · ${sicher(t.rolleName || "")}
+
+ ${!beendet && d.rechte.planen
+ ? `
✕ ` : ""}
+
`).join("")
+ : `
Noch niemand eingeteilt.
`}
+
+
+
+
+
Relevante Vorgeschichte
+
+
Vorerkrankungen
+ ${sicher(s.vorerkrankungen || "keine erfasst")}
+
Dauermedikation
+ ${sicher(s.dauermedikation || "keine erfasst")}
+
Implantate
+ ${sicher(s.implantate || "keine erfasst")}
+ ${o.aufnahmeGrund
+ ? `
Aufnahmegrund ${sicher(o.aufnahmeGrund)}
` : ""}
+
+
+ Fehlende Angaben heißen „nicht erhoben". Das System schließt daraus nichts.
+
+
+
+ ${bogenFeld("verlauf", "Operationsverlauf", o.verlauf, schreibbar,
+ "Zugang, Vorgehen, Befund, Versorgung…")}
+ ${bogenFeld("komplikationen", "Komplikationen", o.komplikationen, schreibbar,
+ "Nur eintragen, wenn welche auftraten.")}
+ ${bogenFeld("nachsorge", "Nachsorge", o.nachsorge, schreibbar,
+ "Drainagen, Verbandwechsel, Kontrolle, Belastung…")}
+
+
+ ${schreibbar ? `
+
+ OP-Bericht speichern
+
` : ""}
+ `;
+
+ verdrahteEinzel(behaelter, d);
+ }
+
+ /** Ein Feld des Operationsberichts */
+ function bogenFeld(name, titel, wert, schreibbar, hinweis) {
+ if (!schreibbar) {
+ return `
+
${sicher(titel)}
+
${wert
+ ? sicher(wert).replace(/\n/g, "
+
+
${sicher(titel)}
+
+
${sicher(hinweis || "")}
+
${sicher(o.kennung)} — ${sicher(o.art)}
+ bei ${sicher(o.patientName)}.
+ Der Beginn wird mit der aktuellen Uhrzeit vermerkt und der Saal gilt
+ als belegt. ${o.geplantFuer
+ ? "Der geplante Termin war " + zeit(o.geplantFuer) + "." : ""}
+ ${d.team.length === 0 ? `
+
+
👥
+
Es ist noch niemand im OP-Team. Du wirst mit dem Beginn
+ als Beteiligter eingetragen.
+
${sicher(o.kennung)} wird abgeschlossen. Der Bericht
+ ist danach schreibgeschützt.
+ ${!aktuell.verlauf && !o.verlauf ? `
+
+
📄
+
Der Operationsverlauf ist leer. Ohne Verlauf lässt sich
+ nicht abschließen — bitte zuerst dokumentieren.
+
Was gerade im Bogen steht, wird mit übernommen.
`,
+ bestaetigenText: "Beenden",
+ gefahr: true,
+ bestaetigt: async (_, zu) => {
+ try {
+ await aufruf("operation", "beenden",
+ Object.assign({ id: o.id }, aktuell));
+ zu();
+ meldung("Operation abgeschlossen.", "gut");
+ oeffne(behaelter, o.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+
+ const umplanen = behaelter.querySelector("[data-umplanen]");
+ if (umplanen) umplanen.addEventListener("click", () => umplanungsFenster(behaelter, d));
+
+ const absagen = behaelter.querySelector("[data-absagen]");
+ if (absagen) absagen.addEventListener("click", () => {
+ bestaetigen({
+ titel: "Operation absagen",
+ gefahr: true,
+ inhalt: `${sicher(o.kennung)} — ${sicher(o.art)}
+ Die Operation wird als abgesagt abgelegt. Die Begründung wandert
+ in den Verlauf und bleibt dauerhaft lesbar.
+ Begründung (Pflicht)
+
`,
+ bestaetigenText: "Absagen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (grund.length < 5) return meldung("Bitte eine Begründung angeben.", "fehler");
+ try {
+ await aufruf("operation", "absagen", { id: o.id, grund });
+ zu();
+ meldung("Operation abgesagt.", "gut");
+ z.offen = null;
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+
+ const team = behaelter.querySelector("[data-team]");
+ if (team) team.addEventListener("click", async () => {
+ try {
+ const antwort = await aufruf("operation", "teamWechsel", {
+ id: o.id, beitreten: !d.ichDabei, funktion: "assistenz",
+ });
+ meldung(antwort.dabei ? "Du bist im OP-Team." : "Team verlassen.", "gut");
+ oeffne(behaelter, o.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ });
+
+ const teamZu = behaelter.querySelector("[data-teamzu]");
+ if (teamZu) teamZu.addEventListener("click", () => teamFenster(behaelter, d));
+
+ behaelter.querySelectorAll("[data-teamweg]").forEach((el) => {
+ el.addEventListener("click", async () => {
+ try {
+ await aufruf("operation", "teamEntfernen", {
+ id: o.id, charakterId: +el.dataset.teamweg,
+ });
+ meldung("Aus dem Team genommen.", "gut");
+ oeffne(behaelter, o.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ });
+ });
+ }
+
+ /* ---- Team ergänzen --------------------------------------------------------- */
+
+ async function teamFenster(behaelter, d) {
+ const o = d.operation;
+
+ let auswahl;
+ try {
+ auswahl = await aufruf("operation", "kollegen", {});
+ } catch (f) { return meldung(f.message, "fehler"); }
+
+ const imTeam = new Set(d.team.map((t) => t.character));
+ const frei = (auswahl.kollegen || []).filter((k) => !imTeam.has(k.charakterId));
+
+ let gewaehlt = null;
+
+ fenster({
+ titel: "OP-Team ergänzen",
+ inhalt: `
+ Kollege im Dienst
+
+ ${frei.length ? frei.map((k) => `
+
+
${sicher(k.personalnummer)}
+
+
${sicher(k.name)}
+
${sicher(k.rolleName)}
+
+
`).join("")
+ : `
Niemand weiter im Dienst.
`}
+
Funktion im Team
+
+ ${d.funktionen.map((f) =>
+ `${sicher(f.name)} `).join("")}
+
+
Die Einteilung ist eine Zuordnung im Bericht —
+ teilnehmen muss der Kollege trotzdem selbst.
Patient suchen
+
+
+
Mindestens zwei Zeichen eingeben.
+
+
Art des Eingriffs
+
+
+
OP-Saal
+ — später festlegen —
+
Beginn in … Minuten
+
+
0 = ohne Termin
+
+
+
+
+
ℹ
+
Der Termin ist eine Erinnerung . Zum geplanten Zeitpunkt passiert
+ nichts von selbst — das System meldet sich, beginnen musst du.
+
+
Mindestens zwei Zeichen eingeben.
`;
+ return;
+ }
+ try {
+ const antwort = await aufruf("operation", "patientSuche", { begriff });
+ const treffer = antwort.treffer || [];
+ saele = antwort.saele || [];
+
+ liste.innerHTML = treffer.length ? treffer.map((t) => `
+
+
+
${sicher(t.firstname)} ${sicher(t.lastname)}
+
geb. ${sicher(t.dob)}
+ ${t.blutgruppe ? " · " + sicher(t.blutgruppe) : ""}
+
+ ${t.hinweis ? `
⚠ ` : ""}
+ ${t.allergien ? `
A ` : ""}
+ ${t.aufnahme ? `
im Haus ` : ""}
+
Keine Person gefunden.
`;
+
+ liste.querySelectorAll("[data-person]").forEach((el) => {
+ el.addEventListener("click", () => {
+ gewaehlt = treffer.find((t) => t.id === +el.dataset.person);
+ liste.querySelectorAll("[data-person]")
+ .forEach((zeile) => zeile.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ formular.style.display = "";
+
+ hg.querySelector("[name=saal]").innerHTML =
+ `— später festlegen — ` +
+ saele.map((s) =>
+ `
+ ${sicher(s.kennung)}${s.belegt > 0 ? " (gerade belegt)" : ""}
+ ${s.status === "gesperrt" ? " — gesperrt" : ""} `).join("");
+ });
+ });
+ } catch (f) { meldung(f.message, "fehler"); }
+ }, 260);
+ });
+ },
+ });
+ }
+
+ function umplanungsFenster(behaelter, d) {
+ const o = d.operation;
+
+ bestaetigen({
+ titel: "Operation umplanen",
+ inhalt: `
+ ${sicher(o.kennung)} — ${sicher(o.art)}
+
+
OP-Saal
+
+ — kein Saal —
+ ${d.saele.map((s) =>
+ `
+ ${sicher(s.kennung)}${s.status === "gesperrt" ? " — gesperrt" : ""}
+ `).join("")}
+
+
Neuer Beginn in … Minuten
+
+
0 = Termin entfernen
+
Begründung (Pflicht)
+
`,
+ bestaetigenText: "Umplanen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (grund.length < 3) return meldung("Bitte eine Begründung angeben.", "fehler");
+ const saalFeld = el.querySelector("[name=saal]");
+ try {
+ await aufruf("operation", "umplanen", {
+ id: o.id,
+ saal: saalFeld.value ? +saalFeld.value : null,
+ vorlaufMinuten: +el.querySelector("[name=vorlauf]").value,
+ grund,
+ });
+ zu();
+ meldung("Umgeplant.", "gut");
+ oeffne(behaelter, o.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Laden ------------------------------------------------------------------- */
+
+ async function oeffne(behaelter, operationId) {
+ try {
+ const d = await aufruf("operation", "oeffnen", { id: operationId });
+ z.offen = operationId;
+ einzelAnsicht(behaelter, d);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("operation", "uebersicht", { ordner: z.ordner });
+
+ // Sprungziel aus einem Hinweis, z. B. „Operation beginnt in 10 Minuten"
+ const ziel = App.zustand.modulZiel;
+ if (ziel && ziel.operation) {
+ App.zustand.modulZiel = null;
+ return oeffne(behaelter, ziel.operation);
+ }
+
+ if (z.offen) await oeffne(behaelter, z.offen);
+ else uebersicht(behaelter);
+ } catch (f) {
+ behaelter.innerHTML = `Operationen
+
Konnte nicht geladen werden: ${sicher(f.message)}
+ ${eintraege.map((e) => `
+
+ ${sicher(e.text)}${e.zahl}
+ `).join("")}
+
`;
+ }
+
+ /* ---- Übersicht -------------------------------------------------------- */
+
+ function uebersicht(behaelter) {
+ const d = z.daten;
+
+ // Belegung der Stationen als Kachelreihe
+ const stationsKacheln = d.stationen.map((s) => `
+
+
${sicher(s.name)}
+
${s.frei}
+
frei von ${s.betten} · ${s.zimmer} Zimmer
+
+
+
Patientenverwaltung
+
Angemeldet wird von Hand, aufgenommen wird von Hand, entlassen wird von Hand.
+ Das System führt nur die Liste.
+
+ ${d.rechte.aufnehmen
+ ? `
＋ Patient anmelden ` : ""}
+
${stationsKacheln}
+
+ ${reiterleiste(d)}
+
+
+
+ Alle Stationen
+ ${d.stationen.map((s) =>
+ `
+ ${sicher(s.name)} `).join("")}
+
+ ${d.rechte.belegen
+ ? `Zimmerübersicht ` : ""}
+
+
+
+
+ ${z.ordner === "warteliste" ? "Wartende Patienten"
+ : z.ordner === "station" ? "Patienten im Haus" : "Zuletzt entlassen"}
+ ${z.ordner === "warteliste"
+ ? "Sortiert nach eingetragener Dringlichkeit, nicht nach Wartezeit"
+ : d.liste.length + " Einträge"}
+
+
+ ${d.liste.length ? d.liste.map(zeile).join("")
+ : `
${z.ordner === "warteliste"
+ ? "Niemand wartet." : "Keine Einträge."}
`}
+
+
+
+
+
${sicher(a.name)}
+ geb. ${sicher(a.geburt)}
+
${sicher(String(a.grund).slice(0, 90))}
+
+
+ ${a.hinweis ? `
⚠ ` : ""}
+ ${a.allergien ? `
A ` : ""}
+ ${a.blutgruppe ? `
${sicher(a.blutgruppe)} ` : ""}
+ ${a.aufIntensiv ? `
Intensiv ` : ""}
+
+ ${a.zimmer ? `
${sicher(a.zimmer)} `
+ : a.stationName ? `
${sicher(a.stationName)} ` : ""}
+
+
+ ${sicher(a.dringlichkeit)}
+
+
${entlassen
+ ? zeit(a.entlassen_am)
+ : (z.ordner === "warteliste" ? "wartet " : "seit ") + minuten(a.wartet)}
+
+
+
${sicher(a.name)}
+
geb. ${sicher(a.geburt)} · ${sicher(a.dringlichkeit)}
+ ${a.stationName ? " · " + sicher(a.stationName) : ""}
+ ${a.zimmer ? " · Zimmer " + sicher(a.zimmer)
+ + (a.bett ? " / Bett " + a.bett : "") : ""}
+
+
← Übersicht
+
+
⚠
+
Warnhinweis — ${sicher(s.hinweis)}
+
+
💊
+
Allergien — ${sicher(s.allergien)}
+
+
${s.lichtbild
+ ? `
`
+ : `
Kein Lichtbild `}
+
+
+
Status
+ ${sicher(statusName(a.status))}
+
Dringlichkeit
+ ${sicher(a.dringlichkeit)}
+
Blutgruppe
+ ${sicher(s.blutgruppe || "nicht bestimmt")}
+
Vorerkrankungen
+ ${sicher(s.vorerkrankungen || "keine erfasst")}
+
Dauermedikation
+ ${sicher(s.dauermedikation || "keine erfasst")}
+
Notfallkontakt
+ ${sicher(s.notfallkontakt || "keiner hinterlegt")}
+
+
+
+ Patientenakte öffnen
+ ${a.status === "wartend" && d.rechte.aufnehmen
+ ? `Aufnehmen ` : ""}
+ ${a.status === "aufgenommen" && d.rechte.verlegen
+ ? `Verlegen ` : ""}
+ ${a.status !== "entlassen" && d.rechte.aufnehmen
+ ? `Dringlichkeit ` : ""}
+ ${a.status !== "entlassen" && d.rechte.entlassen
+ ? `Entlassen ` : ""}
+
+
+
+
Vorgang
+
+
Grund der Vorstellung ${sicher(a.grund)}
+
Angemeldet ${zeit(a.aufgenommenAm)}
+
Angemeldet von ${sicher(a.aufgenommenVon)}
+ ${a.entlassenAm ? `
+
Entlassen ${zeit(a.entlassenAm)}
+
Entlassen von ${sicher(a.entlassenVon)}
` : ""}
+
+ ${a.entlassGrund ? `
+
Entlassgrund: ${sicher(a.entlassGrund)}
` : ""}
+
+
+
+
+ Behandlungen zu dieser Aufnahme
+
+
+ ${d.behandlungen.length ? d.behandlungen.map((b) => `
+
+
${sicher(b.kennung)}
+
+
${sicher(b.diagnose || "Noch keine Diagnose eingetragen")}
+
${sicher(b.autor)} · ${zeit(b.erstellt_am)}
+
+
+ ${sicher(b.status)}
+
`).join("")
+ : `
Noch nichts dokumentiert.
`}
+
+
+
Person suchen
+
+
+
Mindestens zwei Zeichen eingeben.
+
+
Grund der Vorstellung
+
+
Dringlichkeit
+
+ 1 — Sofort (lebensbedrohlich)
+ 2 — Dringend (zeitkritisch)
+ 3 — Regulär
+ 4 — Nachrangig
+
+
Diese Einstufung nimmst du vor. Das System
+ ändert sie nie — auch nicht, wenn jemand lange wartet.
+
Mindestens zwei Zeichen eingeben.
`;
+ return;
+ }
+ try {
+ const antwort = await aufruf("patienten", "patientSuche", { begriff });
+ const treffer = antwort.treffer || [];
+
+ liste.innerHTML = treffer.length ? treffer.map((t) => `
+
+
+
${sicher(t.firstname)} ${sicher(t.lastname)}
+
geb. ${sicher(t.dob)}
+ ${t.blutgruppe ? " · " + sicher(t.blutgruppe) : ""}
+
+ ${t.hinweis ? `
⚠ ` : ""}
+ ${t.laufend ? `
${sicher(t.laufend)} ` : ""}
+
Keine Person gefunden.
`;
+
+ liste.querySelectorAll("[data-person]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const person = treffer.find((t) => t.id === +el.dataset.person);
+ if (person && person.laufend) {
+ return meldung("Für diesen Patienten läuft bereits eine Aufnahme.", "fehler");
+ }
+ gewaehlt = person;
+ liste.querySelectorAll("[data-person]")
+ .forEach((zeile) => zeile.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ formular.style.display = "";
+ });
+ });
+ } catch (f) { meldung(f.message, "fehler"); }
+ }, 260);
+ });
+ },
+ });
+ }
+
+ /* ---- Aufnahme und Verlegung ----------------------------------------------- */
+
+ async function zuweisungsFenster(behaelter, d, istVerlegung) {
+ const a = d.aufnahme;
+
+ let zimmerDaten;
+ try {
+ zimmerDaten = await aufruf("patienten", "freieZimmer", {});
+ } catch (f) { return meldung(f.message, "fehler"); }
+
+ // Zimmer nach Station gruppieren
+ const nachStation = {};
+ zimmerDaten.zimmer.forEach((zi) => {
+ (nachStation[zi.station] = nachStation[zi.station] || {
+ name: zi.stationName, zimmer: [],
+ }).zimmer.push(zi);
+ });
+
+ let gewaehltesZimmer = null;
+ let gewaehlteStation = null;
+
+ bestaetigen({
+ titel: istVerlegung ? "Patient verlegen" : "Patient aufnehmen",
+ inhalt: `
+ ${sicher(a.name)} — ${sicher(a.grund)}
+ ${istVerlegung
+ ? `Grund der Verlegung
+
`
+ : `Vermerk (freiwillig)
+
`}
+
+ Station und Zimmer
+
+ ${Object.keys(nachStation).map((kennung) => {
+ const st = nachStation[kennung];
+ return `
+
+ ${sicher(st.name)}
+
+ ohne Zimmer
+
+
+ ${st.zimmer.map((zi) => `
+
+ ${sicher(zi.kennung)}
+ ${zi.frei}/${zi.betten} frei
+ ${zi.status !== "frei"
+ ? `${sicher(zi.status)} ` : ""}
+ `).join("")}
+
+
`;
+ }).join("")}
+
+
Das System zeigt nur, was frei ist. Welches Zimmer
+ zu diesem Patienten passt, entscheidest du.
+
Aktuell: ${sicher(a.dringlichkeit)}
+ Neue Einstufung
+
+ ${[1, 2, 3, 4].map((stufe) => `
+
+ ${stufe} — ${sicher(d.dringlichkeit[stufe].name)}
+ (${sicher(d.dringlichkeit[stufe].hinweis)}) `).join("")}
+
+ Begründung (Pflicht)
+
`,
+ bestaetigenText: "Einstufung setzen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (grund.length < 3) return meldung("Bitte eine Begründung angeben.", "fehler");
+ try {
+ await aufruf("patienten", "prioritaet", {
+ id: a.id,
+ prioritaet: +el.querySelector("[name=prioritaet]").value,
+ grund,
+ });
+ zu();
+ meldung("Einstufung geändert.", "gut");
+ oeffne(behaelter, a.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Entlassung ------------------------------------------------------------ */
+
+ function entlassungsFenster(behaelter, d) {
+ const a = d.aufnahme;
+ const offeneDoku = d.behandlungen.filter((b) => b.status === "laufend").length;
+
+ bestaetigen({
+ titel: "Patient entlassen",
+ gefahr: true,
+ inhalt: `
+ ${sicher(a.name)} wird aus der Klinik entlassen.
+ Ein belegtes Bett wird dabei frei.
+ ${offeneDoku > 0 ? `
+
+
📄
+
${offeneDoku} Behandlung(en) noch nicht abgeschlossen.
+ Sie bleiben offen — das System schließt nichts für dich ab.
+ Die Entlassung ist trotzdem möglich.
+
Begründung / Entlassbrief (Pflicht)
+
`,
+ bestaetigenText: "Entlassen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (grund.length < 5) return meldung("Bitte eine Begründung angeben.", "fehler");
+ try {
+ await aufruf("patienten", "entlassen", { id: a.id, grund });
+ zu();
+ meldung("Patient entlassen.", "gut");
+ z.offen = null;
+ z.ordner = "entlassen";
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Zimmerübersicht -------------------------------------------------------- */
+
+ async function zimmerUebersicht(behaelter) {
+ let d;
+ try {
+ d = await aufruf("patienten", "freieZimmer", {});
+ } catch (f) { return meldung(f.message, "fehler"); }
+
+ const nachStation = {};
+ d.zimmer.forEach((zi) => {
+ (nachStation[zi.station] = nachStation[zi.station] || {
+ name: zi.stationName, zimmer: [],
+ }).zimmer.push(zi);
+ });
+
+ const dialog = fenster({
+ titel: "Zimmerübersicht",
+ inhalt: `
+ Ein leer gewordenes Zimmer meldet sich als frei, setzt
+ seinen Status aber nicht selbst zurück — Reinigung und Freigabe bleiben
+ eine Entscheidung.
+ ${Object.keys(nachStation).map((kennung) => {
+ const st = nachStation[kennung];
+ return `
+
${sicher(st.name)}
+
+ ${st.zimmer.map((zi) => `
+
+
${sicher(zi.kennung)}
+
+
${zi.frei} von ${zi.betten} Betten frei
+
${sicher(zi.art)}
+ ${zi.hinweis ? " · " + sicher(zi.hinweis) : ""}
+
+
0 ? "gut" : "warn")
+ : zi.status === "reinigung" ? "warn" : "kritisch"}">
+ ${sicher(zi.status)}
+
+ Status ändern…
+ frei
+ Reinigung
+ gesperrt
+
+
`).join("")}
+
+
Patientenverwaltung
+
Konnte nicht geladen werden: ${sicher(f.message)}
+ ${eintraege.map((e) => `
+
+ ${sicher(e.text)}${e.zahl}
+ `).join("")}
+
`;
+ }
+
+ function kennzahlen(d) {
+ const zk = d.zaehler;
+ const auslastung = zk.betten > 0 ? Math.round((zk.belegt / zk.betten) * 100) : 0;
+
+ return `
+
+
Freie Betten
+
${zk.frei}
+
von ${zk.betten} Betten insgesamt
+
+
+
Belegt
+
${zk.belegt}
+
${auslastung} % ausgelastet
+
+
+
Nicht belegbar
+
${zk.gesperrt + zk.reinigung}
+
${zk.gesperrt} gesperrt · ${zk.reinigung} in Reinigung
+
+
+
Ohne Bett
+
${d.ohneBett.length}
+
aufgenommen, aber in keinem Zimmer
+
+
+ ${bett.nummer}
+ frei
+
`;
+ }
+
+ return `
+ ${bett.nummer}
+ ${sicher(b.name)}
+
+ ${b.warnhinweis ? `⚠ ` : ""}
+ ${b.allergien ? `A ` : ""}
+ ${b.aufIntensiv ? `ITS ` : ""}
+ ${b.prioritaet ? `
+ ${b.prioritaet} ` : ""}
+
+
`;
+ }
+
+ /** Eine Zimmerkachel */
+ function zimmerKachel(zi) {
+ return `
+
+ ${sicher(zi.kennung)}
+
+ ${zi.status === "frei" ? zi.frei + " / " + zi.betten + " frei"
+ : sicher(statusName(zi.status))}
+
+
${zi.bettenListe.map(bettZelle).join("")}
+ ${zi.hinweis
+ ? `
${sicher(zi.hinweis)}
` : ""}
+
+
+
+ ${sicher(s.name)}
+ ${s.etage ? ` · ${sicher(s.etage)}` : ""}
+ ${s.aktiv ? "" : ` abgeschaltet `}
+
+
+ ${s.belegt} von ${s.betten} Betten belegt · ${s.frei} frei
+
+
+ ${s.zimmer.length
+ ? `
${s.zimmer.map(zimmerKachel).join("")}
`
+ : `
Für diese Station ist kein Zimmer angelegt.
`}
+
${stationen.map(stationsKarte).join("")}
`
+ : ``;
+ }
+
+ /* ---- Patienten ohne Bett -------------------------------------------------- */
+
+ function ohneBettAnsicht(d) {
+ return `
+
+ Aufgenommen, aber ohne Bett
+ Das System legt niemanden von selbst hin
+
+
+ ${d.ohneBett.length ? d.ohneBett.map((a) => `
+
+
+
+
${sicher(a.name)}
+
${sicher(String(a.grund || "").slice(0, 90))}
+
+ ${a.warnhinweis ? `
⚠ ` : ""}
+ ${a.allergien ? `
A ` : ""}
+ ${a.blutgruppe ? `
${sicher(a.blutgruppe)} ` : ""}
+ ${a.stationName ? `
${sicher(a.stationName)} ` : ""}
+
seit ${sicher(minuten(a.wartet))}
+ ${d.rechte.belegen
+ ? `
Bett zuweisen ` : ""}
+
`).join("")
+ : `
Jeder aufgenommene Patient liegt in einem Bett.
`}
+
+
+
ℹ
+
Stationen und Zimmer werden abgeschaltet oder gesperrt, nicht gelöscht.
+ Nur ein Zimmer, in dem nie jemand gelegen hat, lässt sich noch entfernen —
+ sonst verlöre der Belegungsverlauf seinen Ort.
+
+
+
+ ＋ Station anlegen
+
+
+ ${d.stationen.map((s) => `
+
+
+
+ ${sicher(s.kennung)}
+ ${sicher(s.name)}
+ ${s.aktiv ? "" : ` abgeschaltet `}
+
+
+ Bearbeiten
+ ＋ Zimmer
+
+ ${s.aktiv ? "Abschalten" : "Einschalten"}
+
+
+
+
+ ${s.zimmer.length ? s.zimmer.map((zi) => `
+
+
${sicher(zi.kennung)}
+
+
${zi.betten} Bett(en) · ${sicher(artName(zi.art))}
+
${zi.belegt} belegt${
+ zi.hinweis ? " · " + sicher(zi.hinweis) : ""}
+
+
+ ${sicher(statusName(zi.status))}
+
Bearbeiten
+ ${zi.belegt === 0
+ ? `
Entfernen `
+ : ""}
+
`).join("")
+ : `
Noch kein Zimmer angelegt.
`}
+
+
+
+
Stationen und Belegung
+
Belegt und frei gegeben wird von Hand. Ein leer gewordenes Zimmer meldet
+ sich, setzt seinen Status aber nicht selbst zurück — Reinigung und Freigabe
+ bleiben eine Entscheidung.
+
+
+
+ Alle Stationen
+ ${d.stationen.map((s) =>
+ `
+ ${sicher(s.name)} `).join("")}
+
+ Klick auf ein Zimmer öffnet die Belegung.
+
` : ""}
+
+ ${z.reiter === "spiegel" ? spiegelAnsicht(d)
+ : z.reiter === "ohnebett" ? ohneBettAnsicht(d)
+ : verwaltungsAnsicht(d)}
+ `;
+
+ verdrahteUebersicht(behaelter);
+ }
+
+ function verdrahteUebersicht(behaelter) {
+ behaelter.querySelectorAll("[data-reiter]").forEach((el) => {
+ el.addEventListener("click", () => {
+ z.reiter = el.dataset.reiter;
+ // Abgeschaltete Stationen gehören nur in die Verwaltung
+ if (z.reiter !== "verwaltung") z.zeigeInaktive = false;
+ rendern(behaelter);
+ });
+ });
+
+ const filter = behaelter.querySelector("[data-stationsfilter]");
+ if (filter) {
+ filter.addEventListener("change", (e) => {
+ z.station = e.target.value;
+ uebersicht(behaelter);
+ });
+ }
+
+ behaelter.querySelectorAll("[data-zimmer]").forEach((el) => {
+ el.addEventListener("click", () => zimmerFenster(behaelter, +el.dataset.zimmer));
+ });
+
+ behaelter.querySelectorAll("[data-zuweisen]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const aufnahme = z.daten.ohneBett.find((a) => a.id === +el.dataset.zuweisen);
+ if (aufnahme) zuweisungsFenster(behaelter, aufnahme);
+ });
+ });
+
+ /* --- Verwaltung --- */
+
+ const inaktive = behaelter.querySelector("[data-inaktive]");
+ if (inaktive) {
+ inaktive.addEventListener("change", () => {
+ z.zeigeInaktive = inaktive.checked;
+ rendern(behaelter);
+ });
+ }
+
+ const neueStation = behaelter.querySelector("[data-neuestation]");
+ if (neueStation) {
+ neueStation.addEventListener("click", () => stationsFenster(behaelter, null));
+ }
+
+ behaelter.querySelectorAll("[data-station-bearbeiten]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const station = z.daten.stationen.find((s) => s.id === +el.dataset.stationBearbeiten);
+ if (station) stationsFenster(behaelter, station);
+ });
+ });
+
+ behaelter.querySelectorAll("[data-station-aktiv]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const station = z.daten.stationen.find((s) => s.id === +el.dataset.stationAktiv);
+ if (station) aktivFenster(behaelter, station, el.dataset.ziel === "1");
+ });
+ });
+
+ behaelter.querySelectorAll("[data-neueszimmer]").forEach((el) => {
+ el.addEventListener("click", () =>
+ zimmerBearbeitenFenster(behaelter, null, +el.dataset.neueszimmer));
+ });
+
+ behaelter.querySelectorAll("[data-zimmer-bearbeiten]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const zimmer = findeZimmer(+el.dataset.zimmerBearbeiten);
+ if (zimmer) zimmerBearbeitenFenster(behaelter, zimmer, zimmer.station);
+ });
+ });
+
+ behaelter.querySelectorAll("[data-zimmer-entfernen]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const zimmer = findeZimmer(+el.dataset.zimmerEntfernen);
+ if (zimmer) entfernenFenster(behaelter, zimmer);
+ });
+ });
+ }
+
+ /** Sucht ein Zimmer über alle Stationen hinweg */
+ function findeZimmer(zimmerId) {
+ for (const station of z.daten.stationen) {
+ const treffer = station.zimmer.find((zi) => zi.id === zimmerId);
+ if (treffer) return treffer;
+ }
+ return null;
+ }
+
+ /* ---- Zimmerfenster ---------------------------------------------------------- */
+
+ async function zimmerFenster(behaelter, zimmerId) {
+ let d;
+ try {
+ d = await aufruf("station", "zimmer", { id: zimmerId });
+ } catch (f) { return meldung(f.message, "fehler"); }
+
+ const zi = d.zimmer;
+
+ const dialog = fenster({
+ titel: `Zimmer ${zi.kennung} · ${zi.stationName}`,
+ inhalt: `
+
+
Art ${sicher(artName(zi.art))}
+
Status ${sicher(statusName(zi.status))}
+
Betten ${zi.betten}
+ ${zi.etage ? `
Etage ${sicher(zi.etage)}
` : ""}
+
ℹ
+
${sicher(zi.hinweis)}
+ Belegung
+
+
+ ${d.betten.map((bett) => {
+ const b = bett.belegung;
+ if (!b) {
+ return `
+
Bett ${bett.nummer}
+
+
`;
+ }
+ return `
+
Bett ${bett.nummer}
+
+
${sicher(b.name)}
+ geb. ${sicher(b.geburt)}
+
liegt seit ${sicher(minuten(b.liegtSeit))} ·
+ belegt von ${sicher(b.belegtVon)}
+
+ ${b.warnhinweis ? `
⚠ ` : ""}
+ ${b.allergien ? `
A ` : ""}
+ ${b.blutgruppe ? `
${sicher(b.blutgruppe)} ` : ""}
+ ${b.aufnahme
+ ? `
Vorgang ` : ""}
+ ${d.rechte.belegen
+ ? `
+ Bett freigeben ` : ""}
+
`;
+ }).join("")}
+
+
Zimmerstatus setzen
+
+
+ ${(d.zimmerstatus || []).map((s) =>
+ `
+ ${sicher(s.name)} `).join("")}
+
+ Setzen
+
+
Ein leeres Zimmer bleibt so lange in Reinigung oder
+ gesperrt, bis jemand es wieder freigibt. Das System tut das nie.
+
+ Frühere Belegungen
+ bleibt dauerhaft erhalten
+
+
+ ${d.verlauf.map((v) => `
+
+
Bett ${v.bett}
+
+
${sicher(v.name)}
+
${zeit(v.belegt_am)} → ${zeit(v.frei_am)} ·
+ freigegeben von ${sicher(v.freiVon)}
+
+
`).join("")}
+
${sicher(belegung.name)} liegt in Zimmer
+ ${sicher(belegung.zimmer)}, Bett ${sicher(belegung.bett)}.
+
+
🧍
+
Das ist keine Entlassung. Der Patient bleibt aufgenommen und
+ steht danach ohne Bett auf der Station. Entlassen wird ausschließlich
+ über die Patientenverwaltung.
+
Grund (Pflicht)
+
`,
+ bestaetigenText: "Bett freigeben",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (grund.length < 3) return meldung("Bitte einen Grund angeben.", "fehler");
+ try {
+ await aufruf("station", "bettFreigeben", { id: belegung.id, grund });
+ zu();
+ meldung("Bett freigegeben.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Bett zuweisen ------------------------------------------------------------ */
+
+ function zuweisungsFenster(behaelter, aufnahme) {
+ const d = z.daten;
+
+ let gewaehltesZimmer = null; // Zimmerobjekt aus dem Bettenspiegel
+ let gewaehltesBett = null; // Bettnummer oder null für „erstes freies"
+
+ // Nur Stationen mit belegbaren Zimmern anbieten
+ const stationen = d.stationen.filter(
+ (s) => s.aktiv && s.zimmer.some((zi) => zi.verfuegbar));
+
+ bestaetigen({
+ titel: "Bett zuweisen",
+ inhalt: `
+ ${sicher(aufnahme.name)} — ${sicher(aufnahme.grund || "")}
+ ${aufnahme.warnhinweis
+ ? `⚠
+
Warnhinweis — ${sicher(aufnahme.warnhinweis)}
Zimmer wählen
+
+ ${stationen.length ? stationen.map((s) => `
+
+
+ ${sicher(s.name)}
+ ${s.kennung !== aufnahme.station
+ ? `andere Station ` : ""}
+
+
+ ${s.zimmer.filter((zi) => zi.verfuegbar).map((zi) => `
+
+ ${sicher(zi.kennung)}
+ ${zi.frei}/${zi.betten} frei
+ `).join("")}
+
+
`).join("")
+ : `
Zurzeit ist kein Zimmer belegbar.
`}
+
+
Angezeigt wird nur, was frei und nicht gesperrt ist.
+ Welches Zimmer zu diesem Patienten passt, entscheidest du.
+
Vermerk (freiwillig)
+
`,
+ bestaetigenText: "Zuweisen",
+ bestaetigt: async (el, zu) => {
+ if (!gewaehltesZimmer) return meldung("Bitte ein Zimmer wählen.", "fehler");
+ try {
+ const antwort = await aufruf("station", "bettZuweisen", {
+ aufnahme: aufnahme.id,
+ zimmer: gewaehltesZimmer.id,
+ bett: gewaehltesBett,
+ vermerk: el.querySelector("[name=vermerk]").value.trim(),
+ });
+ zu();
+ meldung(`Zimmer ${antwort.zimmer}, Bett ${antwort.bett} belegt.`, "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ nachOeffnen: (hg) => {
+ const bettwahl = hg.querySelector("[data-bettwahl]");
+ const bettreihe = hg.querySelector("[data-bettreihe]");
+
+ hg.querySelectorAll("[data-zimmer]").forEach((el) => {
+ el.addEventListener("click", () => {
+ gewaehltesZimmer = findeZimmer(+el.dataset.zimmer);
+ gewaehltesBett = null;
+
+ hg.querySelectorAll("[data-zimmer]").forEach((k) => k.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+
+ // Freie Betten des gewählten Zimmers zur Auswahl stellen
+ const frei = gewaehltesZimmer.bettenListe.filter((b) => !b.belegung);
+ bettwahl.style.display = frei.length > 1 ? "" : "none";
+ bettreihe.innerHTML = frei.map((b) => `
+
+ Bett ${b.nummer}
+ `).join("");
+
+ bettreihe.querySelectorAll("[data-bett]").forEach((knopf) => {
+ knopf.addEventListener("click", () => {
+ gewaehltesBett = +knopf.dataset.bett;
+ bettreihe.querySelectorAll("[data-bett]")
+ .forEach((k) => k.classList.remove("gewaehlt"));
+ knopf.classList.add("gewaehlt");
+ });
+ });
+ });
+ });
+ },
+ });
+ }
+
+ /* ---- Station anlegen und bearbeiten -------------------------------------------- */
+
+ function stationsFenster(behaelter, station) {
+ const d = z.daten;
+ const neu = !station;
+
+ bestaetigen({
+ titel: neu ? "Station anlegen" : `Station ${station.kennung} bearbeiten`,
+ inhalt: `
+
+ Name
+
+
+
Art
+
+ ${(d.stationsarten || []).map((a) =>
+ `
+ ${sicher(a.name)} `).join("")}
+
+
Etage
+
+
Wird die Kennung geändert, ziehen alle Aufnahmen mit,
+ die auf diese Station verweisen.
`}`,
+ bestaetigenText: neu ? "Anlegen" : "Speichern",
+ bestaetigt: async (el, zu) => {
+ const kennung = el.querySelector("[name=kennung]").value.trim();
+ const name = el.querySelector("[name=name]").value.trim();
+ if (!kennung) return meldung("Bitte eine Kennung angeben.", "fehler");
+ if (!name) return meldung("Bitte einen Namen angeben.", "fehler");
+
+ try {
+ await aufruf("station", "stationSpeichern", {
+ id: neu ? null : station.id,
+ kennung,
+ name,
+ art: el.querySelector("[name=art]").value,
+ etage: el.querySelector("[name=etage]").value.trim(),
+ sortierung: +el.querySelector("[name=sortierung]").value,
+ });
+ zu();
+ meldung(neu ? "Station angelegt." : "Station gespeichert.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ function aktivFenster(behaelter, station, einschalten) {
+ bestaetigen({
+ titel: einschalten ? "Station einschalten" : "Station abschalten",
+ gefahr: !einschalten,
+ inhalt: einschalten
+ ? `Station ${sicher(station.name)} steht danach wieder für
+ Aufnahmen und Belegungen zur Verfügung.
+ Vermerk (freiwillig)
+
`
+ : `Station ${sicher(station.name)} wird abgeschaltet. Zimmer und
+ Belegungsverlauf bleiben erhalten — es lässt sich dort nur niemand
+ mehr aufnehmen.
+ ℹ
+
Solange dort Patienten liegen, ist das Abschalten nicht möglich.
Grund (freiwillig)
+
`,
+ bestaetigenText: einschalten ? "Einschalten" : "Abschalten",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("station", "stationAktiv", {
+ id: station.id,
+ aktiv: einschalten,
+ grund: el.querySelector("[name=grund]").value.trim(),
+ });
+ zu();
+ meldung(einschalten ? "Station eingeschaltet." : "Station abgeschaltet.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Zimmer anlegen und bearbeiten ---------------------------------------------- */
+
+ function zimmerBearbeitenFenster(behaelter, zimmer, stationId) {
+ const d = z.daten;
+ const neu = !zimmer;
+ const station = d.stationen.find((s) => s.id === stationId);
+
+ bestaetigen({
+ titel: neu ? `Zimmer anlegen · ${station ? station.name : ""}`
+ : `Zimmer ${zimmer.kennung} bearbeiten`,
+ inhalt: `
+
+ Art
+
+ ${(d.zimmerarten || []).map((a) =>
+ `
+ ${sicher(a.name)} `).join("")}
+
+ Hinweis (freiwillig)
+
+ ${neu
+ ? "Ein neues Zimmer startet gesperrt. Erst wenn es jemand freigibt, lässt es sich belegen."
+ : "Belegte Betten lassen sich nicht wegkürzen."}
`,
+ bestaetigenText: neu ? "Anlegen" : "Speichern",
+ bestaetigt: async (el, zu) => {
+ const kennung = el.querySelector("[name=kennung]").value.trim();
+ if (!kennung) return meldung("Bitte eine Kennung angeben.", "fehler");
+
+ try {
+ await aufruf("station", "zimmerSpeichern", {
+ id: neu ? null : zimmer.id,
+ station: stationId,
+ kennung,
+ betten: +el.querySelector("[name=betten]").value,
+ art: el.querySelector("[name=art]").value,
+ hinweis: el.querySelector("[name=hinweis]").value.trim(),
+ });
+ zu();
+ meldung(neu ? "Zimmer angelegt." : "Zimmer gespeichert.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ function entfernenFenster(behaelter, zimmer) {
+ bestaetigen({
+ titel: `Zimmer ${zimmer.kennung} entfernen`,
+ gefahr: true,
+ inhalt: `
+ Das Zimmer verschwindet aus dem Bettenspiegel.
+
+
ℹ
+
Möglich ist das nur, solange nie jemand darin gelegen hat. Sobald es
+ eine Belegung gab, bleibt das Zimmer bestehen und lässt sich nur sperren.
+
Grund (freiwillig)
+
`,
+ bestaetigenText: "Entfernen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("station", "zimmerEntfernen", {
+ id: zimmer.id,
+ grund: el.querySelector("[name=grund]").value.trim(),
+ });
+ zu();
+ meldung("Zimmer entfernt.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Laden ------------------------------------------------------------------- */
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("station", "uebersicht", { alle: z.zeigeInaktive });
+
+ // Sprungziel aus einem Hinweis, z. B. „Zimmer wurde frei"
+ const ziel = App.zustand.modulZiel;
+ if (ziel && ziel.zimmer) {
+ App.zustand.modulZiel = null;
+ uebersicht(behaelter);
+ return zimmerFenster(behaelter, ziel.zimmer);
+ }
+
+ uebersicht(behaelter);
+ } catch (f) {
+ behaelter.innerHTML = `Stationen und Belegung
+
Konnte nicht geladen werden: ${sicher(f.message)}
+ ${d.bereiche.map((b) => `
+
+ ${sicher(b.name)}${b.anzahl}
+ `).join("")}
+
`;
+ }
+
+ /* ---- Übersicht ---------------------------------------------------------- */
+
+ function uebersicht(behaelter) {
+ const d = z.daten;
+
+ behaelter.innerHTML = `
+
+
+
Bausteine
+
Vorformulierter Text für die Bögen. Ein Baustein füllt beim Einsetzen nur
+ das Formular — gespeichert wird danach von Hand, und vorhandener Text
+ bleibt stehen.
+
+
＋ Baustein anlegen
+
+
+ Bausteine für diesen Bogen
+ Die Reihenfolge bestimmt nur die Anzeige
+
+
+ ${d.liste.length ? d.liste.map(zeile).join("")
+ : `
Für diesen Bogen ist noch nichts hinterlegt.
`}
+
+
+
+ Felder dieses Bogens
+
+
+ ${d.felder.map((f) => `${sicher(f.name)} `).join("")}
+
+
+ Ein Baustein kann nur füllen, was es im Bogen auch gibt. Felder, für die
+ jemandem das Recht fehlt, bleiben beim Einsetzen unberührt.
+
+
+
${sicher(b.kennung)}
+
+
+
${sicher(b.name)}
+
${b.felder.length
+ ? sicher(b.felder.join(" · ")) : "füllt kein Feld"}
+
+
+
Reihenfolge ${b.sortierung}
+
+ ${b.aktiv ? "einsetzbar" : "abgeschaltet"}
+
+
Ansehen
+
Bearbeiten
+
+ ${b.aktiv ? "Abschalten" : "Einschalten"}
+
Entfernen
+
So sieht der Text aus, der beim Einsetzen in die
+ Felder wandert. Vorhandener Text im Bogen bleibt erhalten.
+ ${d.felder.filter((f) => b.inhalt[f.id]).map((f) => `
+
+
${sicher(f.name)}
+
${sicher(b.inhalt[f.id]).replace(/\n/g, "
+
Dieser Baustein ist leer.
`}`,
+ });
+ }
+
+ /* ---- Anlegen und bearbeiten ------------------------------------------------ */
+
+ function bearbeitenFenster(behaelter, b) {
+ const d = z.daten;
+ const neu = !b;
+
+ bestaetigen({
+ titel: neu ? `Baustein für den ${d.bereiche.find((e) => e.id === z.bereich).name}`
+ : `„${b.name}" bearbeiten`,
+ inhalt: `
+
+
+ Leer gelassene Felder bleiben beim Einsetzen
+ unberührt. Ein Baustein muss mindestens ein Feld füllen.
+
+ ${d.felder.map((f) => `
+ ${sicher(f.name)}
+
`).join("")}
+
+ ${neu ? "" : `Der Bogen eines Bausteins lässt sich
+ nicht wechseln — die Felder des einen passen nicht auf den anderen.
`}`,
+ bestaetigenText: neu ? "Anlegen" : "Speichern",
+ bestaetigt: async (el, zu) => {
+ const name = el.querySelector("[name=name]").value.trim();
+ if (!name) return meldung("Bitte einen Namen angeben.", "fehler");
+
+ // Nur gefüllte Felder wandern in den Baustein
+ const inhalt = {};
+ d.felder.forEach((f) => {
+ const wert = el.querySelector(`[name=${f.id}]`).value.trim();
+ if (wert) inhalt[f.id] = wert;
+ });
+
+ if (!Object.keys(inhalt).length) {
+ return meldung("Bitte mindestens ein Feld ausfüllen.", "fehler");
+ }
+
+ try {
+ await aufruf("vorlage", "speichern", {
+ id: neu ? null : b.id,
+ bereich: z.bereich,
+ name,
+ sortierung: +el.querySelector("[name=sortierung]").value,
+ inhalt,
+ });
+ zu();
+ meldung(neu ? "Baustein angelegt." : "Baustein gespeichert.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ function entfernenFenster(behaelter, b) {
+ bestaetigen({
+ titel: `„${b.name}" entfernen`,
+ gefahr: true,
+ inhalt: `
+ Der Baustein verschwindet aus der Auswahl.
+
+
ℹ
+
Was damit bereits geschrieben wurde, steht in den Bögen und bleibt
+ unberührt. Soll der Baustein nur vorübergehend verschwinden, ist
+ Abschalten der sanftere Weg.
+
Grund (Pflicht)
+
`,
+ bestaetigenText: "Entfernen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (!grund) return meldung("Bitte einen Grund angeben.", "fehler");
+ try {
+ await aufruf("vorlage", "entfernen", { id: b.id, grund });
+ zu();
+ meldung("Baustein entfernt.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Laden -------------------------------------------------------------------- */
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("vorlage", "uebersicht", { bereich: z.bereich });
+ uebersicht(behaelter);
+ } catch (f) {
+ behaelter.innerHTML = `Bausteine
+
Konnte nicht geladen werden: ${sicher(f.message)}
AetherOS — RP Handy
+
+
+
+
+
+ Ein voll interaktiver Web-Prototyp eines RP-Smartphones für deinen deutschsprachigen FiveM GTA-Server. Alles läuft ohne Server — reines HTML/CSS/JS zum Ansehen.
+ So bedienst du es
+
+ ↑ Wischen/Tippen auf den Sperrbildschirm entsperrt das Handy.← Mitteilungen am Sperrbildschirm nach links wegwischen . ▬ Die Leiste unten bringt dich zurück zum Homescreen. 🔐 Beim Erststart Code festlegen . Entsperren per Face-ID oder Code (Einstellungen → Sicherheit).
+
+ Push-Mitteilung auslösen
+ Im Server kommen diese Events vom Backend. Hier zum Testen manuell:
+
+ 💬 Nachricht
+ 🏦 Bank
+ 📡 Dispatch
+ 🐦 Birdy
+
+
+ Gesperrte Apps
+ Manche Apps (z. B. Darkchat) sind nicht für jeden verfügbar — im Spiel per Gamemechanik freizuschalten. Hier zum Testen:
+ 🔓 Darkchat freischalten
+
+ Hardware & Items
+ Handy, SIM-Karte und Akku sind im Spiel eigene Items , die kombiniert werden. Akkustand: 78%
+
+ 🪫 Akku entladen
+ 🔋 Neuen Akku einsetzen
+ 📶 SIM entfernen / einsetzen
+ 📱 Handy aus / an
+
+
+
+
+
+
+
+
+
+
+
+
+ 14:32
+
+ Kein Netz
+
+
+
+ 78%
+
+
+
+
+
+
+
Dienstag, 21. Juli
+
14:32
+
+
Tippen zum Entsperren · ← Mitteilung wegwischen
+
+
+
+
+
+
+
+
+
+
+
+
Unbekannt
+
Anruf läuft…
+
?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
🪫
+
Akku leer
+
Setze einen geladenen Akku (Item) ein, um das Handy zu nutzen.
+
+
+
+
+
+
+ Enthaltene Apps
+
+ 📞 Telefon & Wähler
+ 💬 Nachrichten
+ 🏦 Bank / Fleeca
+ 🐦 Birdy (Social)
+ 📸 Kamera & Galerie
+ 🎵 Musik
+ 📡 Dispatch / Leitstelle
+ 🏛️ Staat / Staatskasse
+ 🚗 Garage
+ 📒 Gelbe Seiten
+ 🔒 Darkchat (freischaltbar)
+ 🌤️ Wetter
+ 🧮 Rechner
+ ⚙️ Einstellungen
+
+ Für FiveM gedacht
+ Datenmodelle (Kontakte, Konten, Chats, Posts) sind bewusst getrennt vom UI gehalten — später einfach an NUI-Callbacks & deine Datenbank anbinden.
+
+
+
+
+
+
diff --git a/resources/[aether]/aether-phone/server/main.lua b/resources/[aether]/aether-phone/server/main.lua
new file mode 100644
index 0000000..d8f1ffb
--- /dev/null
+++ b/resources/[aether]/aether-phone/server/main.lua
@@ -0,0 +1,554 @@
+-- =====================================================================
+-- Aether Phone — Serverlogik
+-- Telefonnummer, Kontakte, Nachrichten, Anrufe und Sicherheit.
+-- Die PIN verlaesst den Server nicht.
+-- =====================================================================
+
+local Core = exports['aether-core']
+local Inventory = exports['aether-inventory']
+
+-- Laufende Anrufe: [anruferQuelle] = { ziel = quelle, nummer = ..., seit = ... }
+local aktiveAnrufe = {}
+
+-- Wer hat sein Handy gerade entsperrt? (fuer Aktionen, die das voraussetzen)
+local entsperrt = {}
+
+-- ---------------------------------------------------------------------
+-- Hilfsfunktionen
+-- ---------------------------------------------------------------------
+
+local function CharakterVon(quelle)
+ return Core:HoleCharakterId(quelle)
+end
+
+--- Erzeugt eine freie Telefonnummer im Format 555-XXXX
+--- @return string
+local function ErzeugeNummer()
+ for _ = 1, 50 do
+ local nummer = ('555-%04d'):format(math.random(0, 9999))
+ local belegt = MySQL.scalar.await('SELECT `character` FROM aether_phone WHERE number = ?', { nummer })
+ if not belegt then return nummer end
+ end
+ -- Notfalls eine Nummer mit anderer Vorwahl
+ return ('%03d-%04d'):format(math.random(200, 999), math.random(0, 9999))
+end
+
+--- Laedt (oder erzeugt) den Handy-Datensatz eines Charakters
+--- @param charakterId number Charakter-ID
+--- @return table
+local function HoleGeraet(charakterId)
+ local zeilen = MySQL.query.await('SELECT * FROM aether_phone WHERE `character` = ?', { charakterId })
+
+ if zeilen and zeilen[1] then return zeilen[1] end
+
+ local nummer = ErzeugeNummer()
+ MySQL.insert.await('INSERT INTO aether_phone (`character`, number) VALUES (?, ?)',
+ { charakterId, nummer })
+ Aether.Info(('Telefonnummer %s fuer Charakter #%d vergeben.'):format(nummer, charakterId))
+
+ local neue = MySQL.query.await('SELECT * FROM aether_phone WHERE `character` = ?', { charakterId })
+ return neue[1]
+end
+
+--- Sucht den Charakter zu einer Telefonnummer
+--- @param nummer string Telefonnummer
+--- @return number|nil Charakter-ID
+local function CharakterZuNummer(nummer)
+ return MySQL.scalar.await('SELECT `character` FROM aether_phone WHERE number = ?', { nummer })
+end
+
+--- Sucht die Server-ID zu einer Telefonnummer (nur wenn online)
+--- @param nummer string Telefonnummer
+--- @return number|nil
+local function QuelleZuNummer(nummer)
+ local charakterId = CharakterZuNummer(nummer)
+ if not charakterId then return nil end
+ return Core:HoleQuelleNachCharakter(charakterId)
+end
+
+--- Prueft die Hardware: Handy, SIM und Akku muessen vorhanden sein
+--- @param quelle number Server-ID
+--- @return boolean hatHandy, boolean hatSim
+local function PruefeHardware(quelle)
+ local handy = (Inventory:ZaehleItem(quelle, Handy.ITEM_HANDY) or 0) > 0
+ local sim = (Inventory:ZaehleItem(quelle, Handy.ITEM_SIM) or 0) > 0
+ return handy, sim
+end
+
+--- Laedt die Kontakte eines Charakters
+local function HoleKontakte(charakterId)
+ local zeilen = MySQL.query.await(
+ 'SELECT id, name, number FROM aether_phone_contacts WHERE `character` = ? ORDER BY name ASC',
+ { charakterId }) or {}
+
+ local liste = {}
+ -- Notrufe stehen immer oben
+ for nummer, eintrag in pairs(Handy.NOTRUFE) do
+ liste[#liste + 1] = { id = 0, name = eintrag.name, nummer = nummer, notruf = true }
+ end
+ for _, zeile in ipairs(zeilen) do
+ liste[#liste + 1] = { id = zeile.id, name = zeile.name, nummer = zeile.number }
+ end
+ return liste
+end
+
+--- Laedt die Unterhaltungen (letzte Nachricht je Gegenstelle)
+local function HoleChats(nummer)
+ local zeilen = MySQL.query.await([[
+ SELECT sender, receiver, text, gelesen, created_at
+ FROM aether_phone_messages
+ WHERE sender = ? OR receiver = ?
+ ORDER BY id DESC
+ LIMIT 300
+ ]], { nummer, nummer }) or {}
+
+ local chats = {}
+ for _, zeile in ipairs(zeilen) do
+ local gegenstelle = (zeile.sender == nummer) and zeile.receiver or zeile.sender
+ chats[gegenstelle] = chats[gegenstelle] or {}
+ table.insert(chats[gegenstelle], 1, {
+ von = (zeile.sender == nummer) and 'me' or 'them',
+ text = zeile.text,
+ zeit = tostring(zeile.created_at):sub(12, 16),
+ })
+ end
+ return chats
+end
+
+--- Laedt den Anrufverlauf
+local function HoleAnrufe(nummer)
+ local zeilen = MySQL.query.await([[
+ SELECT caller, callee, verpasst, created_at
+ FROM aether_phone_calls
+ WHERE caller = ? OR callee = ?
+ ORDER BY id DESC LIMIT 30
+ ]], { nummer, nummer }) or {}
+
+ local liste = {}
+ for _, zeile in ipairs(zeilen) do
+ local eingehend = zeile.callee == nummer
+ liste[#liste + 1] = {
+ nummer = eingehend and zeile.caller or zeile.callee,
+ art = eingehend and 'eingehend' or 'ausgehend',
+ verpasst = zeile.verpasst == 1,
+ zeit = tostring(zeile.created_at):sub(1, 16),
+ }
+ end
+ return liste
+end
+
+--- Baut den kompletten Zustand fuer die Oberflaeche (ohne PIN!)
+--- @param quelle number Server-ID
+--- @return table|nil
+local function BaueZustand(quelle)
+ local charakterId = CharakterVon(quelle)
+ if not charakterId then return nil end
+
+ local person = Core:HoleSpielerInfo(quelle)
+ local geraet = HoleGeraet(charakterId)
+ local hatHandy, hatSim = PruefeHardware(quelle)
+
+ local dock = { 'phone', 'messages', 'bank', 'camera' }
+ local erfolg, entschluesselt = pcall(json.decode, geraet.dock or '')
+ if erfolg and type(entschluesselt) == 'table' then dock = entschluesselt end
+
+ local freigeschaltet = {}
+ local ok2, entsch2 = pcall(json.decode, geraet.unlocked or '{}')
+ if ok2 and type(entsch2) == 'table' then freigeschaltet = entsch2 end
+
+ return {
+ name = ((person and person.vorname or '') .. ' ' .. (person and person.nachname or '')),
+ nummer = geraet.number,
+ kontostand = person and person.konto or 0,
+ kontonummer = person and person.iban or '—',
+ theme = geraet.theme,
+ wallpaper = geraet.wallpaper,
+ dockApps = dock,
+ freigeschaltet = freigeschaltet,
+ handy = hatHandy,
+ sim = hatSim,
+ akku = geraet.battery,
+ -- Die PIN selbst wird NIE geschickt, nur ob eine eingerichtet ist
+ pinGesetzt = geraet.pin ~= nil,
+ faceId = geraet.faceid == 1,
+ kontakte = HoleKontakte(charakterId),
+ chats = HoleChats(geraet.number),
+ anrufe = HoleAnrufe(geraet.number),
+ }
+end
+
+--- Schickt den Zustand an einen Spieler
+local function SendeZustand(quelle, hinweis)
+ local zustand = BaueZustand(quelle)
+ if not zustand then return end
+ zustand.hinweis = hinweis
+ TriggerClientEvent('aether:phone:zustand', quelle, zustand)
+end
+
+local function Ablehnen(quelle, grund)
+ TriggerClientEvent('aether:phone:fehler', quelle, grund)
+end
+
+-- ---------------------------------------------------------------------
+-- Handy oeffnen
+-- ---------------------------------------------------------------------
+RegisterNetEvent('aether:phone:oeffnen', function()
+ local quelle = source
+ local charakterId = CharakterVon(quelle)
+ if not charakterId then return end
+
+ local hatHandy = PruefeHardware(quelle)
+ if not hatHandy then
+ Ablehnen(quelle, 'Du hast kein Handy dabei.')
+ return
+ end
+
+ local geraet = HoleGeraet(charakterId)
+ if geraet.battery <= 0 then
+ Ablehnen(quelle, 'Der Akku ist leer.')
+ return
+ end
+
+ local zustand = BaueZustand(quelle)
+ if zustand then
+ TriggerClientEvent('aether:phone:zeige', quelle, zustand)
+ end
+end)
+
+-- ---------------------------------------------------------------------
+-- Sicherheit: Ersteinrichtung und Entsperren
+-- ---------------------------------------------------------------------
+RegisterNetEvent('aether:phone:pinEinrichten', function(pin, faceId)
+ local quelle = source
+ local charakterId = CharakterVon(quelle)
+ if not charakterId then return end
+
+ if type(pin) ~= 'string' or not pin:match('^%d%d%d%d$') then
+ Ablehnen(quelle, 'Der Code muss aus vier Ziffern bestehen.')
+ return
+ end
+
+ MySQL.update.await('UPDATE aether_phone SET pin = ?, faceid = ? WHERE `character` = ?',
+ { pin, faceId and 1 or 0, charakterId })
+
+ entsperrt[quelle] = true
+ TriggerClientEvent('aether:phone:entsperrt', quelle, true)
+end)
+
+RegisterNetEvent('aether:phone:entsperren', function(pin)
+ local quelle = source
+ local charakterId = CharakterVon(quelle)
+ if not charakterId then return end
+
+ local gespeichert = MySQL.scalar.await(
+ 'SELECT pin FROM aether_phone WHERE `character` = ?', { charakterId })
+
+ if gespeichert and gespeichert == pin then
+ entsperrt[quelle] = true
+ TriggerClientEvent('aether:phone:entsperrt', quelle, true)
+ else
+ entsperrt[quelle] = false
+ TriggerClientEvent('aether:phone:entsperrt', quelle, false)
+ end
+end)
+
+--- Entsperren per Face-ID (nur wenn dafuer eingerichtet)
+RegisterNetEvent('aether:phone:faceId', function()
+ local quelle = source
+ local charakterId = CharakterVon(quelle)
+ if not charakterId then return end
+
+ local aktiv = MySQL.scalar.await(
+ 'SELECT faceid FROM aether_phone WHERE `character` = ?', { charakterId })
+
+ if aktiv == 1 then
+ entsperrt[quelle] = true
+ TriggerClientEvent('aether:phone:entsperrt', quelle, true)
+ else
+ TriggerClientEvent('aether:phone:entsperrt', quelle, false)
+ end
+end)
+
+-- ---------------------------------------------------------------------
+-- Kontakte
+-- ---------------------------------------------------------------------
+RegisterNetEvent('aether:phone:kontaktSpeichern', function(name, nummer, kontaktId)
+ local quelle = source
+ local charakterId = CharakterVon(quelle)
+ if not charakterId or not entsperrt[quelle] then return end
+
+ if type(name) ~= 'string' or #name < 1 or #name > 48 then
+ Ablehnen(quelle, 'Bitte einen Namen angeben.') return
+ end
+ if not Handy.NummerGueltig(nummer) then
+ Ablehnen(quelle, 'Ungültige Telefonnummer.') return
+ end
+
+ if type(kontaktId) == 'number' and kontaktId > 0 then
+ MySQL.update.await(
+ 'UPDATE aether_phone_contacts SET name = ?, number = ? WHERE id = ? AND `character` = ?',
+ { name, nummer, kontaktId, charakterId })
+ else
+ MySQL.insert.await(
+ 'INSERT INTO aether_phone_contacts (`character`, name, number) VALUES (?, ?, ?)',
+ { charakterId, name, nummer })
+ end
+
+ SendeZustand(quelle, 'Kontakt gespeichert.')
+end)
+
+RegisterNetEvent('aether:phone:kontaktLoeschen', function(kontaktId)
+ local quelle = source
+ local charakterId = CharakterVon(quelle)
+ if not charakterId or not entsperrt[quelle] then return end
+ if type(kontaktId) ~= 'number' then return end
+
+ MySQL.update.await('DELETE FROM aether_phone_contacts WHERE id = ? AND `character` = ?',
+ { kontaktId, charakterId })
+ SendeZustand(quelle, 'Kontakt gelöscht.')
+end)
+
+-- ---------------------------------------------------------------------
+-- Nachrichten
+-- ---------------------------------------------------------------------
+RegisterNetEvent('aether:phone:senden', function(anNummer, text)
+ local quelle = source
+ local charakterId = CharakterVon(quelle)
+ if not charakterId or not entsperrt[quelle] then return end
+
+ local hatHandy, hatSim = PruefeHardware(quelle)
+ if not hatHandy or not hatSim then
+ Ablehnen(quelle, 'Ohne SIM-Karte kannst du keine Nachrichten senden.')
+ return
+ end
+
+ if not Handy.NummerGueltig(anNummer) then
+ Ablehnen(quelle, 'Ungültige Telefonnummer.') return
+ end
+ if type(text) ~= 'string' then return end
+
+ text = text:gsub('^%s+', ''):gsub('%s+$', '')
+ if #text < 1 or #text > 512 then
+ Ablehnen(quelle, 'Die Nachricht ist leer oder zu lang.') return
+ end
+
+ local geraet = HoleGeraet(charakterId)
+
+ MySQL.insert.await(
+ 'INSERT INTO aether_phone_messages (sender, receiver, text) VALUES (?, ?, ?)',
+ { geraet.number, anNummer, text })
+
+ -- Empfaenger benachrichtigen, falls online
+ local zielQuelle = QuelleZuNummer(anNummer)
+ if zielQuelle then
+ TriggerClientEvent('aether:phone:neueNachricht', zielQuelle, {
+ von = geraet.number,
+ text = text,
+ zeit = os.date('%H:%M'),
+ })
+ SendeZustand(zielQuelle)
+ end
+
+ SendeZustand(quelle)
+end)
+
+-- ---------------------------------------------------------------------
+-- Anrufe
+-- ---------------------------------------------------------------------
+RegisterNetEvent('aether:phone:anrufen', function(nummer)
+ local quelle = source
+ local charakterId = CharakterVon(quelle)
+ if not charakterId or not entsperrt[quelle] then return end
+
+ local hatHandy, hatSim = PruefeHardware(quelle)
+ if not hatHandy or not hatSim then
+ Ablehnen(quelle, 'Ohne SIM-Karte kannst du nicht telefonieren.')
+ return
+ end
+ if not Handy.NummerGueltig(nummer) then
+ Ablehnen(quelle, 'Ungültige Telefonnummer.') return
+ end
+
+ local geraet = HoleGeraet(charakterId)
+ if nummer == geraet.number then
+ Ablehnen(quelle, 'Du kannst dich nicht selbst anrufen.') return
+ end
+
+ -- Notrufe gehen an die Leitstelle der jeweiligen Fraktion
+ if Handy.NOTRUFE[nummer] then
+ TriggerEvent('aether:phone:notruf', quelle, Handy.NOTRUFE[nummer].fraktion, geraet.number)
+ MySQL.insert('INSERT INTO aether_phone_calls (caller, callee) VALUES (?, ?)',
+ { geraet.number, nummer })
+ TriggerClientEvent('aether:phone:anrufStatus', quelle, 'notruf',
+ Handy.NOTRUFE[nummer].name)
+ return
+ end
+
+ local zielQuelle = QuelleZuNummer(nummer)
+ if not zielQuelle then
+ MySQL.insert('INSERT INTO aether_phone_calls (caller, callee, verpasst) VALUES (?, ?, 1)',
+ { geraet.number, nummer })
+ TriggerClientEvent('aether:phone:anrufStatus', quelle, 'nichtErreichbar')
+ return
+ end
+
+ -- Ist die Gegenstelle schon im Gespraech?
+ for _, anruf in pairs(aktiveAnrufe) do
+ if anruf.ziel == zielQuelle or anruf.anrufer == zielQuelle then
+ TriggerClientEvent('aether:phone:anrufStatus', quelle, 'besetzt')
+ return
+ end
+ end
+
+ aktiveAnrufe[quelle] = {
+ anrufer = quelle, ziel = zielQuelle,
+ nummer = geraet.number, zielNummer = nummer, angenommen = false,
+ }
+
+ TriggerClientEvent('aether:phone:eingehenderAnruf', zielQuelle, geraet.number)
+ TriggerClientEvent('aether:phone:anrufStatus', quelle, 'klingelt', nummer)
+end)
+
+RegisterNetEvent('aether:phone:annehmen', function()
+ local quelle = source
+
+ for anruferQuelle, anruf in pairs(aktiveAnrufe) do
+ if anruf.ziel == quelle then
+ anruf.angenommen = true
+ MySQL.insert('INSERT INTO aether_phone_calls (caller, callee) VALUES (?, ?)',
+ { anruf.nummer, anruf.zielNummer })
+ TriggerClientEvent('aether:phone:anrufStatus', anruferQuelle, 'verbunden')
+ TriggerClientEvent('aether:phone:anrufStatus', quelle, 'verbunden')
+ return
+ end
+ end
+end)
+
+RegisterNetEvent('aether:phone:auflegen', function()
+ local quelle = source
+
+ for anruferQuelle, anruf in pairs(aktiveAnrufe) do
+ if anruferQuelle == quelle or anruf.ziel == quelle then
+ -- Nicht angenommene Anrufe als verpasst protokollieren
+ if not anruf.angenommen then
+ MySQL.insert('INSERT INTO aether_phone_calls (caller, callee, verpasst) VALUES (?, ?, 1)',
+ { anruf.nummer, anruf.zielNummer })
+ end
+ TriggerClientEvent('aether:phone:anrufStatus', anruferQuelle, 'beendet')
+ TriggerClientEvent('aether:phone:anrufStatus', anruf.ziel, 'beendet')
+ aktiveAnrufe[anruferQuelle] = nil
+ return
+ end
+ end
+end)
+
+-- ---------------------------------------------------------------------
+-- Einstellungen speichern
+-- ---------------------------------------------------------------------
+RegisterNetEvent('aether:phone:einstellungen', function(einstellungen)
+ local quelle = source
+ local charakterId = CharakterVon(quelle)
+ if not charakterId or not entsperrt[quelle] then return end
+ if type(einstellungen) ~= 'table' then return end
+
+ local theme = (einstellungen.theme == 'light') and 'light' or 'dark'
+ local wallpaper = tostring(einstellungen.wallpaper or 'wp-aurora'):sub(1, 32)
+ local dock = type(einstellungen.dockApps) == 'table' and einstellungen.dockApps or nil
+
+ MySQL.update.await([[
+ UPDATE aether_phone SET theme = ?, wallpaper = ?, dock = COALESCE(?, dock)
+ WHERE `character` = ?
+ ]], { theme, wallpaper, dock and json.encode(dock) or nil, charakterId })
+end)
+
+-- ---------------------------------------------------------------------
+-- Akkuverbrauch
+-- ---------------------------------------------------------------------
+CreateThread(function()
+ while true do
+ Wait(Handy.AKKU_INTERVALL)
+
+ for _, quelle in ipairs(GetPlayers()) do
+ quelle = tonumber(quelle)
+ local charakterId = CharakterVon(quelle)
+
+ if charakterId then
+ local hatHandy = PruefeHardware(quelle)
+ if hatHandy then
+ local geraet = HoleGeraet(charakterId)
+ if geraet.battery > 0 then
+ local neu = math.max(0, geraet.battery - 1)
+ MySQL.update('UPDATE aether_phone SET battery = ? WHERE `character` = ?',
+ { neu, charakterId })
+ TriggerClientEvent('aether:phone:akku', quelle, neu)
+ end
+ end
+ end
+ end
+ end
+end)
+
+--- Akku austauschen: verbraucht ein Akku-Item und laedt auf 100 %
+RegisterNetEvent('aether:phone:akkuTauschen', function()
+ local quelle = source
+ local charakterId = CharakterVon(quelle)
+ if not charakterId then return end
+
+ if not Inventory:EntferneItem(quelle, Handy.ITEM_AKKU, 1) then
+ Ablehnen(quelle, 'Du hast keinen Ersatz-Akku dabei.')
+ return
+ end
+
+ MySQL.update.await('UPDATE aether_phone SET battery = 100 WHERE `character` = ?', { charakterId })
+ TriggerClientEvent('aether:phone:akku', quelle, 100)
+ SendeZustand(quelle, 'Akku getauscht.')
+end)
+
+-- ---------------------------------------------------------------------
+-- Aufraeumen
+-- ---------------------------------------------------------------------
+RegisterNetEvent('aether:phone:schliessen', function()
+ entsperrt[source] = false
+end)
+
+AddEventHandler('playerDropped', function()
+ local quelle = source
+ entsperrt[quelle] = nil
+
+ -- Laufende Anrufe beenden
+ for anruferQuelle, anruf in pairs(aktiveAnrufe) do
+ if anruferQuelle == quelle or anruf.ziel == quelle then
+ local anderer = (anruferQuelle == quelle) and anruf.ziel or anruferQuelle
+ TriggerClientEvent('aether:phone:anrufStatus', anderer, 'beendet')
+ aktiveAnrufe[anruferQuelle] = nil
+ end
+ end
+end)
+
+-- =====================================================================
+-- EXPORTS
+-- =====================================================================
+
+--- Liefert die Telefonnummer eines Spielers
+exports('HoleNummer', function(quelle)
+ local charakterId = CharakterVon(quelle)
+ if not charakterId then return nil end
+ return HoleGeraet(charakterId).number
+end)
+
+--- Schickt eine Nachricht von einer Dienstnummer an einen Spieler
+--- (z. B. Rechnung vom EMS, Bestaetigung eines Jobs)
+exports('SendeNachricht', function(anNummer, vonNummer, text)
+ if not Handy.NummerGueltig(anNummer) then return false end
+
+ MySQL.insert('INSERT INTO aether_phone_messages (sender, receiver, text) VALUES (?, ?, ?)',
+ { vonNummer or 'System', anNummer, tostring(text):sub(1, 512) })
+
+ local zielQuelle = QuelleZuNummer(anNummer)
+ if zielQuelle then
+ TriggerClientEvent('aether:phone:neueNachricht', zielQuelle, {
+ von = vonNummer or 'System', text = text, zeit = os.date('%H:%M'),
+ })
+ end
+ return true
+end)
diff --git a/resources/[aether]/aether-phone/shared/config.lua b/resources/[aether]/aether-phone/shared/config.lua
new file mode 100644
index 0000000..269b76d
--- /dev/null
+++ b/resources/[aether]/aether-phone/shared/config.lua
@@ -0,0 +1,33 @@
+-- =====================================================================
+-- Aether Phone — Einstellungen
+-- =====================================================================
+
+Handy = Handy or {}
+
+-- Items, die zusammen ein funktionsfaehiges Handy ergeben
+Handy.ITEM_HANDY = 'handy'
+Handy.ITEM_SIM = 'sim'
+Handy.ITEM_AKKU = 'akku'
+
+-- Akkuverbrauch: alle X Millisekunden ein Prozent
+Handy.AKKU_INTERVALL = 180000 -- 3 Minuten
+-- Ab diesem Stand warnt das Handy
+Handy.AKKU_WARNUNG = 15
+
+-- Notrufnummern, die immer erreichbar sind (auch ohne Kontakt)
+Handy.NOTRUFE = {
+ ['110'] = { name = 'Polizei (Notruf)', fraktion = 'lspd' },
+ ['112'] = { name = 'Rettungsdienst', fraktion = 'ems' },
+}
+
+-- Wie viele Nachrichten je Unterhaltung geladen werden
+Handy.MAX_NACHRICHTEN = 50
+
+--- Prueft, ob eine Telefonnummer das erwartete Format hat
+--- @param nummer any Zu pruefender Wert
+--- @return boolean
+function Handy.NummerGueltig(nummer)
+ if type(nummer) ~= 'string' then return false end
+ if Handy.NOTRUFE[nummer] then return true end
+ return nummer:match('^%d%d%d%-%d%d%d%d$') ~= nil
+end
diff --git a/resources/[aether]/aether-police/client/main.lua b/resources/[aether]/aether-police/client/main.lua
new file mode 100644
index 0000000..ab89c2d
--- /dev/null
+++ b/resources/[aether]/aether-police/client/main.lua
@@ -0,0 +1,376 @@
+-- =====================================================================
+-- aether-police — Clientlogik
+-- Öffnet das Tablet und vermittelt zwischen Oberfläche und Server.
+-- =====================================================================
+
+local istOffen = false
+local istGeladen = false
+local imDienst = false
+
+local function SendeAnNui(nachricht)
+ SendNuiMessage(json.encode(nachricht))
+end
+
+local function ZeigeSpielmeldung(text)
+ if not text or text == '' then return end
+ BeginTextCommandThefeedPost('STRING')
+ AddTextComponentSubstringPlayerName(text)
+ EndTextCommandThefeedPostTicker(false, true)
+end
+
+local function Schliessen()
+ if not istOffen then return end
+ istOffen = false
+ SetNuiFocus(false, false)
+ SendeAnNui({ aktion = 'schliessen' })
+ pcall(function() exports['aether-hud']:SetzeSichtbar(true) end)
+end
+
+-- ---------------------------------------------------------------------
+-- Ereignisse vom Server
+-- ---------------------------------------------------------------------
+AddEventHandler('aether:client:bereit', function()
+ istGeladen = true
+end)
+
+--- Tablet mit vollem Zustand anzeigen
+RegisterNetEvent('aether:police:zeige', function(daten)
+ istOffen = true
+ imDienst = true
+ SetNuiFocus(true, true)
+ pcall(function() exports['aether-hud']:SetzeSichtbar(false) end)
+ daten.aktion = 'oeffnen'
+ SendeAnNui(daten)
+end)
+
+--- Anmeldebildschirm (noch nicht im Dienst)
+RegisterNetEvent('aether:police:anmeldung', function(daten)
+ istOffen = true
+ SetNuiFocus(true, true)
+ pcall(function() exports['aether-hud']:SetzeSichtbar(false) end)
+ daten.aktion = 'anmeldung'
+ SendeAnNui(daten)
+end)
+
+RegisterNetEvent('aether:police:schliessen', function()
+ imDienst = false
+ Schliessen()
+ ZeigeSpielmeldung('Dienst beendet.')
+end)
+
+--- Antwort auf einen Modul-Aufruf
+RegisterNetEvent('aether:police:antwort', function(ruf, ergebnis, fehler)
+ SendeAnNui({ aktion = 'antwort', ruf = ruf, ergebnis = ergebnis, fehler = fehler })
+end)
+
+--- Dienstliste (Beamte im Dienst, für Dashboard und Karte)
+RegisterNetEvent('aether:police:dienstliste', function(liste)
+ if istOffen then
+ SendeAnNui({ aktion = 'dienstliste', beamte = liste })
+ end
+end)
+
+--- Hinweis / Erinnerung
+RegisterNetEvent('aether:police:hinweis', function(hinweis)
+ if istOffen then
+ SendeAnNui({ aktion = 'hinweis', hinweis = hinweis })
+ else
+ -- Auch ausserhalb des Tablets erreichbar, damit Fristen nicht untergehen
+ local praefix = hinweis.prioritaet == 'kritisch' and '~r~' or
+ hinweis.prioritaet == 'hoch' and '~o~' or '~b~'
+ ZeigeSpielmeldung(praefix .. hinweis.titel .. '~s~' ..
+ (hinweis.text and ('\n' .. hinweis.text) or ''))
+ end
+end)
+
+RegisterNetEvent('aether:police:fehler', function(text)
+ if istOffen then
+ SendeAnNui({ aktion = 'fehler', text = text })
+ else
+ ZeigeSpielmeldung(text)
+ end
+end)
+
+-- ---------------------------------------------------------------------
+-- Fahrzeug-Telemetrie
+--
+-- Meldet Tatsachen über das gefahrene Dienstfahrzeug: Position,
+-- Tankstand, Zustand. Der Server verwirft die Meldung, wenn das
+-- Kennzeichen nicht zum Fuhrpark gehört.
+-- ---------------------------------------------------------------------
+CreateThread(function()
+ while true do
+ Wait(30000) -- alle 30 Sekunden genügt
+
+ if imDienst then
+ local ped = PlayerPedId()
+ if IsPedInAnyVehicle(ped, false) then
+ local fahrzeug = GetVehiclePedIsIn(ped, false)
+ -- Nur melden, wenn man selbst am Steuer sitzt
+ if GetPedInVehicleSeat(fahrzeug, -1) == ped then
+ local position = GetEntityCoords(fahrzeug)
+ TriggerServerEvent('aether:police:fahrzeugMelden', {
+ kennzeichen = GetVehicleNumberPlateText(fahrzeug),
+ tank = GetVehicleFuelLevel(fahrzeug),
+ zustand = GetVehicleBodyHealth(fahrzeug),
+ x = position.x, y = position.y, z = position.z,
+ })
+ end
+ end
+ end
+ end
+end)
+
+-- ---------------------------------------------------------------------
+-- Gewahrsam
+-- Der Client führt nur aus, was ein Beamter entschieden hat.
+-- ---------------------------------------------------------------------
+
+--- In eine Zelle verbracht werden
+RegisterNetEvent('aether:police:gewahrsamVerbringen', function(daten)
+ Schliessen()
+ DoScreenFadeOut(600)
+ Wait(800)
+
+ local ped = PlayerPedId()
+ SetEntityCoordsNoOffset(ped, daten.x + 0.0, daten.y + 0.0, daten.z + 0.0, false, false, false)
+ SetEntityHeading(ped, daten.w or 0.0)
+
+ -- Warten, bis die Umgebung geladen ist
+ local versuche = 0
+ while not HasCollisionLoadedAroundEntity(ped) and versuche < 60 do
+ Wait(50)
+ versuche = versuche + 1
+ end
+
+ DoScreenFadeIn(800)
+
+ if daten.rest then
+ ZeigeSpielmeldung(('~y~Gewahrsam~s~ · %s\n%s\nRestzeit laut Akte: %d Minuten')
+ :format(daten.zelle or '', daten.grund or '', math.max(0, daten.rest)))
+ else
+ ZeigeSpielmeldung(('~y~Du wurdest in Gewahrsam genommen~s~ · %s'):format(daten.zelle or ''))
+ end
+end)
+
+--- Entlassung durch einen Beamten
+RegisterNetEvent('aether:police:gewahrsamEntlassen', function(daten)
+ DoScreenFadeOut(600)
+ Wait(800)
+
+ local ped = PlayerPedId()
+ SetEntityCoordsNoOffset(ped, daten.x + 0.0, daten.y + 0.0, daten.z + 0.0, false, false, false)
+ SetEntityHeading(ped, daten.w or 0.0)
+
+ local versuche = 0
+ while not HasCollisionLoadedAroundEntity(ped) and versuche < 60 do
+ Wait(50)
+ versuche = versuche + 1
+ end
+
+ DoScreenFadeIn(800)
+ ZeigeSpielmeldung('~g~Du wurdest aus dem Gewahrsam entlassen.~s~')
+end)
+
+-- ---------------------------------------------------------------------
+-- Terminals an den Wachen
+-- ---------------------------------------------------------------------
+CreateThread(function()
+ for _, terminal in ipairs(Polizei.Config.Terminals) do
+ local blip = AddBlipForCoord(terminal.pos.x, terminal.pos.y, terminal.pos.z)
+ SetBlipSprite(blip, 60)
+ SetBlipColour(blip, 3)
+ SetBlipScale(blip, 0.8)
+ SetBlipAsShortRange(blip, true)
+ BeginTextCommandSetBlipName('STRING')
+ AddTextComponentString('Polizeiwache ' .. terminal.name)
+ EndTextCommandSetBlipName(blip)
+ end
+
+ while true do
+ local pause = 800
+
+ if istGeladen and not istOffen then
+ local position = GetEntityCoords(PlayerPedId())
+
+ for _, terminal in ipairs(Polizei.Config.Terminals) do
+ if #(position - terminal.pos) <= Polizei.Config.TerminalWeite then
+ pause = 0
+ SetTextFont(4)
+ SetTextScale(0.34, 0.34)
+ SetTextColour(255, 255, 255, 215)
+ SetTextCentre(true)
+ SetTextOutline()
+ SetTextEntry('STRING')
+ AddTextComponentString('[E] Terminal ' .. terminal.name)
+ SetDrawOrigin(terminal.pos.x, terminal.pos.y, terminal.pos.z + 0.9, 0)
+ DrawText(0.0, 0.0)
+ ClearDrawOrigin()
+
+ if IsControlJustReleased(0, 38) then
+ TriggerServerEvent('aether:police:oeffnen')
+ end
+ break
+ end
+ end
+ end
+
+ Wait(pause)
+ end
+end)
+
+--- Tablet jederzeit öffnen, sobald man im Dienst ist
+RegisterCommand('mdt', function()
+ if istGeladen and not istOffen then
+ TriggerServerEvent('aether:police:oeffnen')
+ end
+end, false)
+RegisterKeyMapping('mdt', 'Polizei-Tablet öffnen', 'keyboard', 'F5')
+
+-- ---------------------------------------------------------------------
+-- Panikknopf (10-13)
+-- ---------------------------------------------------------------------
+local panikGesperrtBis = 0
+
+RegisterCommand('panik', function()
+ if not imDienst then return end
+
+ -- Kurze Sperre, damit der Alarm nicht versehentlich mehrfach ausgeht
+ if GetGameTimer() < panikGesperrtBis then return end
+ panikGesperrtBis = GetGameTimer() + 10000
+
+ TriggerServerEvent('aether:police:panik')
+ ZeigeSpielmeldung('~r~10-13 ausgelöst~s~ — Verstärkung wird alarmiert.')
+end, false)
+RegisterKeyMapping('panik', 'Panikknopf (10-13)', 'keyboard', 'F7')
+
+-- ---------------------------------------------------------------------
+-- Einsatzmarkierungen auf der Karte
+-- ---------------------------------------------------------------------
+local einsatzBlips = {}
+
+--- Entfernt alle Einsatzmarkierungen
+local function LeereEinsatzBlips()
+ for id, blip in pairs(einsatzBlips) do
+ RemoveBlip(blip)
+ einsatzBlips[id] = nil
+ end
+end
+
+--- Setzt Markierungen für die übergebenen Einsätze
+local function SetzeEinsatzBlips(einsaetze)
+ LeereEinsatzBlips()
+
+ for _, einsatz in ipairs(einsaetze or {}) do
+ if einsatz.pos_x then
+ local blip = AddBlipForCoord(einsatz.pos_x + 0.0, einsatz.pos_y + 0.0, einsatz.pos_z + 0.0)
+ SetBlipSprite(blip, 161)
+ -- Offene Einsätze fallen durch Blinken auf
+ SetBlipColour(blip, einsatz.status == 'offen' and 1 or 5)
+ SetBlipScale(blip, einsatz.prioritaet == 1 and 1.0 or 0.8)
+ SetBlipFlashes(blip, einsatz.status == 'offen' and einsatz.prioritaet <= 2)
+ BeginTextCommandSetBlipName('STRING')
+ AddTextComponentString(einsatz.nummer .. ' · ' .. einsatz.titel)
+ EndTextCommandSetBlipName(blip)
+ einsatzBlips[einsatz.id] = blip
+ end
+ end
+end
+
+--- Es hat sich etwas an den Einsätzen geändert
+RegisterNetEvent('aether:police:einsatzAenderung', function()
+ if istOffen then
+ SendeAnNui({ aktion = 'einsatzAenderung' })
+ end
+end)
+
+--- Panikalarm einer anderen Einheit
+RegisterNetEvent('aether:police:panikAlarm', function(daten)
+ PlaySoundFrontend(-1, 'Lose_1st', 'GTAO_FM_Events_Soundset', true)
+ ZeigeSpielmeldung(('~r~10-13~s~ — %s (%s) benötigt Verstärkung!')
+ :format(daten.name, daten.dienstnummer))
+
+ if daten.position then
+ SetNewWaypoint(daten.position.x, daten.position.y)
+ end
+
+ if istOffen then
+ SendeAnNui({ aktion = 'panikAlarm', daten = daten })
+ end
+end)
+
+--- Die Leitstelle bittet um Übernahme eines Einsatzes
+RegisterNetEvent('aether:police:einsatzZuweisung', function(daten)
+ PlaySoundFrontend(-1, 'Event_Start_Text', 'GTAO_FM_Events_Soundset', true)
+
+ if daten.position then
+ SetNewWaypoint(daten.position.x, daten.position.y)
+ end
+
+ if istOffen then
+ SendeAnNui({ aktion = 'einsatzZuweisung', daten = daten })
+ else
+ ZeigeSpielmeldung(('~b~Zuweisung von %s~s~\n%s — %s')
+ :format(daten.von, daten.nummer, daten.titel))
+ end
+end)
+
+-- ---------------------------------------------------------------------
+-- NUI-Callbacks
+-- ---------------------------------------------------------------------
+RegisterNUICallback('schliessen', function(_, rueckgabe)
+ Schliessen()
+ rueckgabe({ ok = true })
+end)
+
+--- Zentraler Modul-Aufruf: die Oberfläche fragt, der Server antwortet
+RegisterNUICallback('aufruf', function(daten, rueckgabe)
+ TriggerServerEvent('aether:police:aufruf',
+ tostring(daten.modul or ''), tostring(daten.aktion or ''),
+ daten.daten or {}, daten.ruf)
+ rueckgabe({ ok = true })
+end)
+
+RegisterNUICallback('dienstAntreten', function(_, rueckgabe)
+ TriggerServerEvent('aether:police:dienstAntreten')
+ rueckgabe({ ok = true })
+end)
+
+RegisterNUICallback('dienstBeenden', function(_, rueckgabe)
+ TriggerServerEvent('aether:police:dienstBeenden')
+ rueckgabe({ ok = true })
+end)
+
+RegisterNUICallback('status', function(daten, rueckgabe)
+ TriggerServerEvent('aether:police:status', tostring(daten.status or ''))
+ rueckgabe({ ok = true })
+end)
+
+RegisterNUICallback('leitstelle', function(daten, rueckgabe)
+ TriggerServerEvent('aether:police:leitstelle', tonumber(daten.quelle))
+ rueckgabe({ ok = true })
+end)
+
+--- Einsatzmarkierungen auf der Karte auffrischen
+RegisterNUICallback('einsatzBlips', function(daten, rueckgabe)
+ SetzeEinsatzBlips(daten.einsaetze or {})
+ rueckgabe({ ok = true })
+end)
+
+--- Wegpunkt auf der Karte setzen (z. B. zu einem Einsatzort)
+RegisterNUICallback('wegpunkt', function(daten, rueckgabe)
+ if daten.x and daten.y then
+ SetNewWaypoint(daten.x + 0.0, daten.y + 0.0)
+ ZeigeSpielmeldung('Wegpunkt gesetzt.')
+ end
+ rueckgabe({ ok = true })
+end)
+
+-- ---------------------------------------------------------------------
+-- Aufräumen
+-- ---------------------------------------------------------------------
+AddEventHandler('onResourceStop', function(ressource)
+ if ressource ~= GetCurrentResourceName() then return end
+ SetNuiFocus(false, false)
+ LeereEinsatzBlips()
+end)
diff --git a/resources/[aether]/aether-police/fxmanifest.lua b/resources/[aether]/aether-police/fxmanifest.lua
new file mode 100644
index 0000000..d8b274a
--- /dev/null
+++ b/resources/[aether]/aether-police/fxmanifest.lua
@@ -0,0 +1,73 @@
+fx_version 'cerulean'
+game 'gta5'
+lua54 'yes'
+
+name 'aether-police'
+author 'Jerrit Fritzsche'
+description 'Polizei-Managementsystem — modulare Verwaltungssoftware für den Polizeidienst'
+version '0.1.0'
+
+ui_page 'html/index.html'
+
+files {
+ 'html/index.html',
+ 'html/css/app.css',
+ 'html/js/app.js',
+ 'html/js/module/dashboard.js',
+ 'html/js/module/mdt.js',
+ 'html/js/module/einsatz.js',
+ 'html/js/module/anzeige.js',
+ 'html/js/module/gewahrsam.js',
+ 'html/js/module/beweis.js',
+ 'html/js/module/asservat.js',
+ 'html/js/module/bericht.js',
+ 'html/js/module/fahndung.js',
+ 'html/js/module/fahrzeug.js',
+ 'html/js/module/personal.js',
+ 'html/js/module/kommunikation.js',
+ 'html/js/module/statistik.js',
+ 'html/js/module/admin.js',
+}
+
+shared_scripts {
+ '@aether-core/shared/config.lua',
+ '@aether-core/shared/utils.lua',
+ 'shared/config.lua',
+ 'shared/rollen.lua',
+}
+
+client_scripts {
+ 'client/main.lua',
+}
+
+-- Reihenfolge ist wichtig: Kern und Basisdienste vor den Fachmodulen.
+server_scripts {
+ '@oxmysql/lib/MySQL.lua',
+ 'server/kern.lua',
+ 'server/rechte.lua',
+ 'server/protokoll.lua',
+ 'server/dienst.lua',
+ 'server/hinweise.lua',
+ -- --- Fachmodule (hier neue Module ergänzen) ---
+ 'server/module/dashboard.lua',
+ 'server/module/mdt.lua',
+ 'server/module/einsatz.lua',
+ 'server/module/anzeige.lua',
+ 'server/module/gewahrsam.lua',
+ 'server/module/beweis.lua',
+ 'server/module/asservat.lua',
+ 'server/module/bericht.lua',
+ 'server/module/fahndung.lua',
+ 'server/module/fahrzeug.lua',
+ 'server/module/personal.lua',
+ 'server/module/kommunikation.lua',
+ 'server/module/statistik.lua',
+ 'server/module/admin.lua',
+ -- --- Schnittstelle zuletzt ---
+ 'server/main.lua',
+}
+
+dependencies {
+ 'aether-core',
+ 'oxmysql',
+}
diff --git a/resources/[aether]/aether-police/html/css/app.css b/resources/[aether]/aether-police/html/css/app.css
new file mode 100644
index 0000000..c948684
--- /dev/null
+++ b/resources/[aether]/aether-police/html/css/app.css
@@ -0,0 +1,1079 @@
+/* =====================================================================
+ aether-police — Oberfläche
+ Behördensoftware-Optik: ruhig, sachlich, hohe Informationsdichte.
+ Dunkelmodus ist Standard, helles Design über .thema-hell.
+===================================================================== */
+
+/* ---- Farbwelt ---- */
+.thema-dunkel {
+ --hg: #0b0e14;
+ --flaeche: #121722;
+ --flaeche-2: #1a2130;
+ --flaeche-3: #232c3d;
+ --rand: rgba(255,255,255,0.09);
+ --rand-stark: rgba(255,255,255,0.16);
+ --text: #e8edf5;
+ --text-leise: #8b97ad;
+ --akzent: #3b82f6;
+ --akzent-weich: rgba(59,130,246,0.14);
+ --gut: #34d399;
+ --warn: #f59e0b;
+ --kritisch: #ef4444;
+ --info: #8b5cf6;
+}
+
+.thema-hell {
+ --hg: #eef1f6;
+ --flaeche: #ffffff;
+ --flaeche-2: #f5f7fa;
+ --flaeche-3: #e8ecf3;
+ --rand: rgba(15,23,42,0.10);
+ --rand-stark: rgba(15,23,42,0.20);
+ --text: #0f172a;
+ --text-leise: #5a6478;
+ --akzent: #2563eb;
+ --akzent-weich: rgba(37,99,235,0.10);
+ --gut: #059669;
+ --warn: #d97706;
+ --kritisch: #dc2626;
+ --info: #7c3aed;
+}
+
+* { box-sizing: border-box; }
+
+html, body {
+ margin: 0; height: 100%; overflow: hidden;
+ background: transparent;
+ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+ color: var(--text);
+ font-size: 14px;
+}
+
+button, input, select, textarea { font-family: inherit; color: inherit; }
+[hidden] { display: none !important; }
+
+/* =====================================================================
+ Anmeldung
+===================================================================== */
+.anmeldung {
+ position: fixed; inset: 0; z-index: 20;
+ display: grid; place-items: center;
+ background: rgba(6,9,14,0.55); backdrop-filter: blur(6px);
+}
+.anmeldung-karte {
+ width: 380px; padding: 34px 30px; text-align: center;
+ background: var(--flaeche); border: 1px solid var(--rand);
+ border-radius: 18px; box-shadow: 0 40px 80px -30px rgba(0,0,0,0.7);
+}
+.wappen {
+ width: 64px; height: 64px; margin: 0 auto 14px; border-radius: 16px;
+ display: grid; place-items: center; font-size: 30px;
+ background: linear-gradient(150deg, var(--akzent), #1e40af); color: #fff;
+}
+.an-behoerde {
+ font-size: 11px; text-transform: uppercase; letter-spacing: 0.14em;
+ color: var(--text-leise); font-weight: 700;
+}
+.anmeldung-karte h1 { font-size: 22px; margin: 6px 0 20px; font-weight: 800; }
+.an-zeile {
+ display: flex; justify-content: space-between; padding: 9px 0;
+ border-bottom: 1px solid var(--rand); font-size: 13px;
+}
+.an-zeile span { color: var(--text-leise); }
+.an-fuss {
+ margin: 18px 0 0; font-size: 11px; line-height: 1.5; color: var(--text-leise);
+}
+
+/* =====================================================================
+ Tablet-Grundgerüst
+===================================================================== */
+.tablet {
+ position: fixed; inset: 0; z-index: 10;
+ display: grid; grid-template-columns: 232px 1fr;
+ background: var(--hg);
+}
+
+/* ---- Seitenleiste ---- */
+.seitenleiste {
+ display: flex; flex-direction: column;
+ background: var(--flaeche); border-right: 1px solid var(--rand);
+}
+.marke {
+ display: flex; align-items: center; gap: 11px;
+ padding: 18px 18px; border-bottom: 1px solid var(--rand);
+}
+.marke-wappen {
+ width: 36px; height: 36px; border-radius: 10px; flex: none;
+ display: grid; place-items: center; font-size: 18px;
+ background: linear-gradient(150deg, var(--akzent), #1e40af); color: #fff;
+}
+.marke-text b { display: block; font-size: 15px; font-weight: 800; letter-spacing: 0.02em; }
+.marke-text small { display: block; font-size: 10.5px; color: var(--text-leise); }
+
+.navigation { flex: 1; padding: 10px 9px; overflow-y: auto; }
+.navigation button {
+ width: 100%; display: flex; align-items: center; gap: 11px;
+ padding: 10px 12px; margin-bottom: 2px;
+ border: none; background: none; border-radius: 9px;
+ color: var(--text-leise); font-size: 13.5px; font-weight: 600;
+ cursor: pointer; text-align: left; transition: .12s;
+}
+.navigation button:hover { background: var(--flaeche-2); color: var(--text); }
+.navigation button.aktiv { background: var(--akzent-weich); color: var(--akzent); font-weight: 700; }
+.navigation button .nav-symbol { width: 18px; text-align: center; font-size: 15px; }
+.navigation button .nav-zaehler {
+ margin-left: auto; background: var(--kritisch); color: #fff;
+ font-size: 10px; font-weight: 800; padding: 1px 6px; border-radius: 999px;
+}
+
+.seitenleiste-fuss {
+ display: flex; gap: 6px; padding: 12px; border-top: 1px solid var(--rand);
+}
+
+/* ---- Hauptbereich ---- */
+.hauptbereich { display: grid; grid-template-rows: auto 1fr; min-width: 0; }
+
+.kopfleiste {
+ display: flex; align-items: center; gap: 14px;
+ padding: 12px 18px; border-bottom: 1px solid var(--rand);
+ background: var(--flaeche);
+}
+.suche-feld {
+ flex: 1; max-width: 620px; position: relative;
+ display: flex; align-items: center;
+}
+.suche-symbol {
+ position: absolute; left: 12px; color: var(--text-leise); font-size: 16px;
+}
+.suche-feld input {
+ width: 100%; padding: 10px 14px 10px 34px;
+ background: var(--flaeche-2); border: 1px solid var(--rand);
+ border-radius: 10px; font-size: 13px; outline: none;
+}
+.suche-feld input:focus { border-color: var(--akzent); background: var(--hg); }
+
+.kopf-rechts { margin-left: auto; display: flex; align-items: center; gap: 9px; }
+
+/* Dienststatus */
+.status-waehler { position: relative; }
+.status-knopf {
+ display: flex; align-items: center; gap: 8px;
+ padding: 8px 13px; border-radius: 9px; cursor: pointer;
+ background: var(--flaeche-2); border: 1px solid var(--rand);
+ font-size: 12.5px; font-weight: 700;
+}
+.status-punkt {
+ width: 9px; height: 9px; border-radius: 50%; background: var(--gut); flex: none;
+}
+.status-liste {
+ position: absolute; top: calc(100% + 6px); right: 0; z-index: 5;
+ min-width: 180px; padding: 6px;
+ background: var(--flaeche-2); border: 1px solid var(--rand-stark);
+ border-radius: 11px; box-shadow: 0 20px 40px -16px rgba(0,0,0,0.6);
+}
+.status-liste button {
+ width: 100%; display: flex; align-items: center; gap: 9px;
+ padding: 9px 10px; border: none; background: none; border-radius: 7px;
+ font-size: 12.5px; font-weight: 600; cursor: pointer; text-align: left;
+}
+.status-liste button:hover { background: var(--flaeche-3); }
+
+.beamter-chip {
+ display: flex; align-items: center; gap: 11px;
+ padding: 6px 12px 6px 13px; border-radius: 10px;
+ background: var(--flaeche-2); border: 1px solid var(--rand);
+}
+.beamter-text b { display: block; font-size: 12.5px; font-weight: 700; line-height: 1.3; }
+.beamter-text small { display: block; font-size: 10.5px; color: var(--text-leise); }
+.beamter-nummer {
+ font-size: 11px; font-weight: 800; color: var(--akzent);
+ background: var(--akzent-weich); padding: 3px 8px; border-radius: 6px;
+ font-variant-numeric: tabular-nums;
+}
+
+/* ---- Inhaltsbereich ---- */
+.inhalt { overflow-y: auto; padding: 20px 22px; }
+.inhalt::-webkit-scrollbar, .navigation::-webkit-scrollbar,
+.schublade-inhalt::-webkit-scrollbar { width: 8px; }
+.inhalt::-webkit-scrollbar-thumb, .navigation::-webkit-scrollbar-thumb,
+.schublade-inhalt::-webkit-scrollbar-thumb {
+ background: var(--rand-stark); border-radius: 4px;
+}
+
+/* =====================================================================
+ Wiederverwendbare Bausteine
+===================================================================== */
+.seiten-kopf {
+ display: flex; align-items: flex-end; justify-content: space-between;
+ gap: 14px; margin-bottom: 18px;
+}
+.seiten-kopf h2 { margin: 0; font-size: 20px; font-weight: 800; letter-spacing: -0.01em; }
+.seiten-kopf p { margin: 3px 0 0; font-size: 12.5px; color: var(--text-leise); }
+
+.karte {
+ background: var(--flaeche); border: 1px solid var(--rand);
+ border-radius: 14px; padding: 16px;
+}
+.karte-kopf {
+ display: flex; align-items: center; justify-content: space-between;
+ margin-bottom: 12px;
+}
+.karte-titel {
+ font-size: 11px; text-transform: uppercase; letter-spacing: 0.07em;
+ color: var(--text-leise); font-weight: 800;
+}
+
+.raster { display: grid; gap: 14px; }
+.raster.k2 { grid-template-columns: repeat(2, 1fr); }
+.raster.k3 { grid-template-columns: repeat(3, 1fr); }
+.raster.k4 { grid-template-columns: repeat(4, 1fr); }
+.raster.k6 { grid-template-columns: repeat(6, 1fr); }
+@media (max-width: 1400px) { .raster.k6 { grid-template-columns: repeat(3, 1fr); } }
+@media (max-width: 1100px) {
+ .raster.k4, .raster.k3 { grid-template-columns: repeat(2, 1fr); }
+ .tablet { grid-template-columns: 64px 1fr; }
+ .marke-text, .navigation button span:not(.nav-symbol) { display: none; }
+}
+
+/* Kennzahl */
+.kennzahl { background: var(--flaeche); border: 1px solid var(--rand); border-radius: 12px; padding: 14px 16px; }
+.kennzahl .kz-titel {
+ font-size: 10.5px; text-transform: uppercase; letter-spacing: 0.06em;
+ color: var(--text-leise); font-weight: 800;
+}
+.kennzahl .kz-wert {
+ font-size: 26px; font-weight: 800; margin-top: 4px; font-variant-numeric: tabular-nums;
+}
+.kennzahl .kz-zusatz { font-size: 11.5px; color: var(--text-leise); margin-top: 2px; }
+.kennzahl.hoch .kz-wert { color: var(--kritisch); }
+.kennzahl.warn .kz-wert { color: var(--warn); }
+.kennzahl.gut .kz-wert { color: var(--gut); }
+
+/* Listen */
+.liste { display: flex; flex-direction: column; }
+.liste-zeile {
+ display: flex; align-items: center; gap: 12px;
+ padding: 10px 2px; border-bottom: 1px solid var(--rand);
+}
+.liste-zeile:last-child { border-bottom: none; }
+.liste-zeile .lz-haupt { flex: 1; min-width: 0; }
+.liste-zeile .lz-titel { font-size: 13px; font-weight: 700; }
+.liste-zeile .lz-unter { font-size: 11.5px; color: var(--text-leise); margin-top: 1px; }
+.liste-leer {
+ padding: 22px; text-align: center; font-size: 12.5px; color: var(--text-leise);
+}
+
+/* Marken / Etiketten */
+.marker {
+ font-size: 10px; font-weight: 800; padding: 3px 8px; border-radius: 999px;
+ display: inline-block; white-space: nowrap;
+}
+.marker.gut { background: rgba(52,211,153,0.15); color: var(--gut); }
+.marker.warn { background: rgba(245,158,11,0.15); color: var(--warn); }
+.marker.kritisch { background: rgba(239,68,68,0.15); color: var(--kritisch); }
+.marker.info { background: rgba(139,92,246,0.15); color: var(--info); }
+.marker.neutral { background: var(--flaeche-3); color: var(--text-leise); }
+
+/* Prioritätsstreifen */
+.prio { width: 3px; align-self: stretch; border-radius: 2px; flex: none; }
+.prio.p1 { background: var(--kritisch); }
+.prio.p2 { background: var(--warn); }
+.prio.p3 { background: var(--akzent); }
+.prio.p4 { background: var(--text-leise); }
+
+/* Knöpfe */
+.knopf {
+ padding: 10px 16px; border-radius: 9px; border: 1px solid transparent;
+ background: var(--akzent); color: #fff;
+ font-size: 13px; font-weight: 700; cursor: pointer; transition: .12s;
+}
+.knopf:hover { filter: brightness(1.08); }
+.knopf:active { transform: scale(0.98); }
+.knopf:disabled { opacity: .45; cursor: not-allowed; }
+.knopf.leise { background: var(--flaeche-2); color: var(--text); border-color: var(--rand); }
+.knopf.leise:hover { background: var(--flaeche-3); filter: none; }
+.knopf.gefahr { background: var(--kritisch); }
+.knopf.gross { width: 100%; padding: 13px; font-size: 14px; margin-top: 18px; }
+.knopf.klein { padding: 7px 10px; font-size: 12px; }
+.knopf.symbol { padding: 8px 11px; font-size: 15px; position: relative; }
+
+.zaehler {
+ position: absolute; top: 2px; right: 2px;
+ background: var(--kritisch); color: #fff;
+ font-size: 9px; font-weight: 800; min-width: 15px; height: 15px;
+ border-radius: 999px; display: grid; place-items: center; padding: 0 3px;
+}
+
+/* Warnhinweise */
+.warnung {
+ display: flex; align-items: center; gap: 11px;
+ padding: 11px 14px; border-radius: 10px; margin-bottom: 8px;
+ border: 1px solid var(--rand); background: var(--flaeche);
+ font-size: 12.5px; cursor: pointer;
+}
+.warnung .w-symbol { font-size: 16px; }
+.warnung.hoch { border-color: rgba(239,68,68,0.4); background: rgba(239,68,68,0.07); }
+.warnung.normal { border-color: rgba(245,158,11,0.35); background: rgba(245,158,11,0.06); }
+.warnung.niedrig { border-color: var(--rand); }
+
+/* =====================================================================
+ Mitteilungs-Schublade
+===================================================================== */
+.schublade {
+ position: absolute; top: 0; right: 0; bottom: 0; width: 360px; z-index: 15;
+ background: var(--flaeche); border-left: 1px solid var(--rand-stark);
+ display: grid; grid-template-rows: auto 1fr;
+ box-shadow: -20px 0 50px -20px rgba(0,0,0,0.5);
+ animation: schubladeRein .18s ease;
+}
+@keyframes schubladeRein { from { transform: translateX(24px); opacity: 0; } }
+.schublade-kopf {
+ display: flex; align-items: center; justify-content: space-between;
+ padding: 15px 16px; border-bottom: 1px solid var(--rand);
+}
+.schublade-inhalt { overflow-y: auto; padding: 10px 12px; }
+.hinweis-eintrag {
+ padding: 11px 12px; border-radius: 10px; margin-bottom: 7px;
+ background: var(--flaeche-2); border: 1px solid var(--rand); cursor: pointer;
+}
+.hinweis-eintrag.ungelesen { border-left: 3px solid var(--akzent); }
+.hinweis-eintrag .he-kopf {
+ display: flex; align-items: center; justify-content: space-between; gap: 8px;
+}
+.hinweis-eintrag .he-titel { font-size: 12.5px; font-weight: 700; }
+.hinweis-eintrag .he-text { font-size: 11.5px; color: var(--text-leise); margin-top: 3px; line-height: 1.45; }
+.hinweis-eintrag .he-zeit { font-size: 10px; color: var(--text-leise); }
+
+/* =====================================================================
+ Fenster (Dialoge)
+===================================================================== */
+.fenster-ebene { position: absolute; inset: 0; z-index: 18; pointer-events: none; }
+.fenster-ebene > * { pointer-events: auto; }
+.fenster-hg {
+ position: absolute; inset: 0; background: rgba(4,7,12,0.6); backdrop-filter: blur(3px);
+ display: grid; place-items: center; padding: 30px;
+}
+.fenster {
+ width: min(720px, 92%); max-height: 86vh; display: grid; grid-template-rows: auto 1fr auto;
+ background: var(--flaeche); border: 1px solid var(--rand-stark);
+ border-radius: 15px; box-shadow: 0 40px 90px -30px rgba(0,0,0,0.8);
+ animation: fensterRein .16s ease;
+}
+@keyframes fensterRein { from { opacity: 0; transform: translateY(10px) scale(.99); } }
+.fenster-kopf {
+ display: flex; align-items: center; justify-content: space-between;
+ padding: 15px 18px; border-bottom: 1px solid var(--rand);
+}
+.fenster-kopf h3 { margin: 0; font-size: 15.5px; font-weight: 800; }
+.fenster-koerper { padding: 18px; overflow-y: auto; }
+.fenster-fuss {
+ display: flex; gap: 9px; justify-content: flex-end;
+ padding: 13px 18px; border-top: 1px solid var(--rand);
+}
+
+/* Formularelemente */
+.feld { margin-bottom: 14px; }
+.feld label {
+ display: block; font-size: 11px; font-weight: 800; color: var(--text-leise);
+ text-transform: uppercase; letter-spacing: 0.05em; margin-bottom: 6px;
+}
+.feld input, .feld select, .feld textarea {
+ width: 100%; padding: 10px 12px; border-radius: 9px;
+ background: var(--flaeche-2); border: 1px solid var(--rand);
+ font-size: 13px; outline: none;
+}
+.feld input:focus, .feld select:focus, .feld textarea:focus { border-color: var(--akzent); }
+.feld textarea { min-height: 90px; resize: vertical; line-height: 1.5; }
+.feld-hinweis { font-size: 11px; color: var(--text-leise); margin-top: 5px; line-height: 1.45; }
+
+/* =====================================================================
+ Kurzmeldungen
+===================================================================== */
+.meldungen {
+ position: absolute; bottom: 18px; left: 50%; transform: translateX(-50%);
+ z-index: 25; display: flex; flex-direction: column; gap: 8px; align-items: center;
+ pointer-events: none;
+}
+.meldung {
+ padding: 11px 20px; border-radius: 10px; font-size: 13px; font-weight: 600;
+ background: var(--flaeche-3); border: 1px solid var(--rand-stark);
+ box-shadow: 0 16px 34px -14px rgba(0,0,0,0.6);
+ animation: meldungRein .2s ease;
+}
+@keyframes meldungRein { from { opacity: 0; transform: translateY(10px); } }
+.meldung.gut { border-color: var(--gut); }
+.meldung.fehler { border-color: var(--kritisch); }
+
+/* Ladeanzeige */
+.laden {
+ display: flex; flex-direction: column; align-items: center; justify-content: center;
+ gap: 12px; padding: 60px; color: var(--text-leise); font-size: 13px;
+}
+.spinner {
+ width: 26px; height: 26px; border-radius: 50%;
+ border: 2.5px solid var(--rand-stark); border-top-color: var(--akzent);
+ animation: dreh .7s linear infinite;
+}
+@keyframes dreh { to { transform: rotate(360deg); } }
+
+/* Grundsatz-Hinweis (erscheint an Entscheidungspunkten) */
+.grundsatz {
+ display: flex; gap: 10px; padding: 11px 13px; border-radius: 9px;
+ background: var(--akzent-weich); border: 1px solid rgba(59,130,246,0.25);
+ font-size: 11.5px; line-height: 1.5; color: var(--text-leise); margin-top: 12px;
+}
+.grundsatz b { color: var(--text); }
+
+/* =====================================================================
+ MDT
+===================================================================== */
+.mdt-reiter { display: flex; gap: 5px; margin-bottom: 14px; }
+.mdt-reiter button {
+ padding: 9px 16px; border-radius: 9px; cursor: pointer;
+ background: var(--flaeche); border: 1px solid var(--rand);
+ font-size: 13px; font-weight: 700; color: var(--text-leise); transition: .12s;
+}
+.mdt-reiter button:hover { color: var(--text); }
+.mdt-reiter button.aktiv {
+ background: var(--akzent-weich); border-color: var(--akzent); color: var(--akzent);
+}
+
+.mdt-suchleiste { display: flex; gap: 8px; }
+.mdt-suchleiste input[type="search"] {
+ flex: 1; padding: 10px 13px; border-radius: 9px;
+ background: var(--flaeche); border: 1px solid var(--rand);
+ font-size: 13px; outline: none;
+}
+.mdt-suchleiste input:focus { border-color: var(--akzent); }
+.mdt-suchleiste select {
+ padding: 10px 12px; border-radius: 9px;
+ background: var(--flaeche); border: 1px solid var(--rand); font-size: 12.5px;
+}
+
+/* Anklickbare Treffer */
+.liste-zeile.treffer { cursor: pointer; border-radius: 8px; padding-inline: 8px; transition: .1s; }
+.liste-zeile.treffer:hover { background: var(--flaeche-2); }
+.treffer-text { cursor: pointer; }
+.treffer-text:hover { color: var(--akzent); }
+
+/* Aktenkopf */
+.akte-kopf {
+ display: flex; gap: 18px; align-items: flex-start;
+ padding-bottom: 16px; border-bottom: 1px solid var(--rand);
+}
+.akte-bild {
+ width: 108px; height: 132px; flex: none; border-radius: 10px;
+ background: var(--flaeche-2); border: 1px solid var(--rand);
+ display: grid; place-items: center; overflow: hidden;
+}
+.akte-bild img { width: 100%; height: 100%; object-fit: cover; }
+.akte-bild .kein-bild {
+ font-size: 10.5px; color: var(--text-leise); text-align: center; padding: 8px;
+}
+.akte-kopf-text { flex: 1; min-width: 0; }
+.akte-kopf-text h3 { margin: 0 0 12px; font-size: 20px; font-weight: 800; }
+.akte-zeilen {
+ display: grid; grid-template-columns: auto 1fr auto 1fr; gap: 6px 14px;
+ font-size: 12.5px; align-items: baseline;
+}
+.akte-zeilen span { color: var(--text-leise); }
+.akte-zeilen b { font-weight: 700; }
+.akte-kopf-aktionen { display: flex; flex-direction: column; gap: 6px; flex: none; }
+
+.akte-inhalt { font-size: 13px; line-height: 1.65; white-space: pre-wrap; }
+
+/* Kennzeichen-Darstellung */
+.kennzeichen {
+ font-family: "Arial Narrow", Arial, sans-serif; font-weight: 800; font-size: 13px;
+ letter-spacing: 0.05em; padding: 5px 9px; border-radius: 5px;
+ background: #f3efe4; color: #1a2a5a; border: 2px solid #c9c4b4; flex: none;
+}
+.kennzeichen-gross {
+ font-family: "Arial Narrow", Arial, sans-serif; font-weight: 800; font-size: 22px;
+ letter-spacing: 0.06em; background: #f3efe4; color: #1a2a5a; border: 3px solid #c9c4b4;
+ height: 66px; width: 132px;
+}
+.farbtupfer {
+ display: inline-block; width: 11px; height: 11px; border-radius: 3px;
+ border: 1px solid var(--rand-stark); vertical-align: -1px;
+}
+
+/* =====================================================================
+ Einsätze & Dispatch
+===================================================================== */
+.dispatch { display: grid; grid-template-columns: 1fr 340px; gap: 14px; align-items: start; }
+@media (max-width: 1200px) { .dispatch { grid-template-columns: 1fr; } }
+.dispatch-spalte { min-width: 0; }
+
+.einsatz-karte {
+ display: flex; align-items: center; gap: 12px;
+ padding: 11px 12px; margin-bottom: 7px; border-radius: 10px;
+ background: var(--flaeche-2); border: 1px solid var(--rand);
+ cursor: pointer; transition: .12s;
+}
+.einsatz-karte:hover { border-color: var(--akzent); transform: translateX(2px); }
+.einsatz-karte.offen { border-left: 3px solid var(--kritisch); }
+.einsatz-karte .ek-haupt { flex: 1; min-width: 0; }
+.einsatz-karte .ek-titel {
+ font-size: 13.5px; font-weight: 700;
+ display: flex; align-items: center; gap: 8px; flex-wrap: wrap;
+}
+.einsatz-karte .ek-unter {
+ font-size: 11.5px; color: var(--text-leise); margin-top: 3px;
+ display: flex; align-items: center; gap: 7px; flex-wrap: wrap;
+}
+.einsatz-karte .ek-kategorie {
+ font-size: 10px; font-weight: 800; padding: 2px 7px; border-radius: 999px;
+ background: color-mix(in srgb, var(--kf) 18%, transparent); color: var(--kf);
+}
+.einsatz-karte .ek-rechts {
+ display: flex; flex-direction: column; align-items: flex-end; gap: 5px; flex: none;
+}
+.einsatz-karte .ek-einheiten {
+ font-size: 11px; color: var(--text-leise); font-weight: 700;
+}
+
+/* =====================================================================
+ Strafenkatalog & Anzeigen
+===================================================================== */
+.anzeige-raster { display: grid; grid-template-columns: 1fr 1fr; gap: 14px; align-items: start; }
+@media (max-width: 1200px) { .anzeige-raster { grid-template-columns: 1fr; } }
+
+.katalog-suche {
+ padding: 7px 11px; border-radius: 8px; font-size: 12.5px; outline: none;
+ background: var(--flaeche-2); border: 1px solid var(--rand); max-width: 220px;
+}
+.katalog-suche:focus { border-color: var(--akzent); }
+
+.katalog-liste { max-height: 520px; overflow-y: auto; }
+.katalog-gruppe { margin-bottom: 14px; }
+.katalog-gruppe:last-child { margin-bottom: 0; }
+.katalog-titel {
+ font-size: 10.5px; font-weight: 800; text-transform: uppercase;
+ letter-spacing: 0.06em; color: var(--text-leise);
+ padding: 5px 0 7px; border-bottom: 1px solid var(--rand); margin-bottom: 6px;
+}
+
+.delikt {
+ display: flex; align-items: flex-start; gap: 10px;
+ padding: 8px 9px; border-radius: 8px; cursor: pointer; transition: .1s;
+ border: 1px solid transparent;
+}
+.delikt:hover { background: var(--flaeche-2); }
+.delikt.gewaehlt { background: var(--akzent-weich); border-color: var(--akzent); }
+.delikt input { margin-top: 2px; accent-color: var(--akzent); flex: none; }
+.delikt-name { font-size: 12.5px; font-weight: 600; }
+.delikt-unter { font-size: 11px; color: var(--text-leise); margin-top: 2px; }
+
+/* Vorschlag des Katalogs — bewusst als Zitat, nicht als Ergebnis */
+.vorschlag-block {
+ border: 1px dashed var(--rand-stark); border-radius: 11px;
+ padding: 13px 14px; margin: 4px 0 14px; background: var(--flaeche-2);
+}
+.vorschlag-kopf { display: flex; align-items: center; justify-content: space-between; }
+.vorschlag-werte { display: flex; gap: 26px; margin-top: 10px; }
+.vorschlag-werte span {
+ display: block; font-size: 10.5px; color: var(--text-leise);
+ text-transform: uppercase; letter-spacing: 0.05em; font-weight: 800;
+}
+.vorschlag-werte b { font-size: 17px; font-weight: 800; }
+.vorschlag-hinweise {
+ margin-top: 11px; padding-top: 10px; border-top: 1px solid var(--rand);
+ font-size: 11.5px; color: var(--text-leise); line-height: 1.6;
+}
+
+.entscheidung-block {
+ border: 1px solid var(--akzent); border-radius: 11px;
+ padding: 14px; background: var(--akzent-weich);
+}
+
+.abweichung {
+ border: 1px solid var(--warn); border-radius: 9px;
+ background: rgba(245,158,11,0.08); padding: 11px 13px; margin-top: 12px;
+}
+.abweichung-kopf { font-size: 12.5px; font-weight: 800; color: var(--warn); }
+
+.person-waehler { display: flex; gap: 8px; }
+.person-waehler input { flex: 1; }
+
+.anzeige-zeile { align-items: flex-start; }
+
+/* Folgen einer Bestätigung */
+.folgen {
+ border: 1px solid var(--rand); border-radius: 10px;
+ padding: 12px 14px; background: var(--flaeche-2);
+}
+.folgen-titel {
+ font-size: 11px; font-weight: 800; text-transform: uppercase;
+ letter-spacing: 0.05em; color: var(--text-leise); margin-bottom: 10px;
+}
+.folge {
+ display: flex; gap: 11px; align-items: flex-start;
+ font-size: 12.5px; line-height: 1.55; padding: 6px 0;
+}
+.folge-symbol { font-size: 15px; flex: none; }
+
+/* =====================================================================
+ Gewahrsam
+===================================================================== */
+.zellen {
+ display: grid; grid-template-columns: repeat(auto-fill, minmax(150px, 1fr)); gap: 10px;
+}
+.zelle {
+ padding: 12px 13px; border-radius: 10px; text-align: center;
+ border: 1px solid var(--rand); background: var(--flaeche-2);
+}
+.zelle.frei { border-style: dashed; opacity: .65; }
+.zelle.belegt { border-color: var(--warn); background: rgba(245,158,11,0.07); }
+.zelle.abgelaufen { border-color: var(--kritisch); background: rgba(239,68,68,0.09); }
+.zelle-name {
+ font-size: 10.5px; font-weight: 800; text-transform: uppercase;
+ letter-spacing: 0.06em; color: var(--text-leise);
+}
+.zelle-status { font-size: 12.5px; color: var(--text-leise); margin-top: 8px; }
+.zelle-insasse { font-size: 13px; font-weight: 700; margin-top: 7px; }
+.zelle-rest {
+ font-size: 12px; font-weight: 800; margin-top: 3px;
+ font-variant-numeric: tabular-nums; color: var(--warn);
+}
+.zelle.abgelaufen .zelle-rest { color: var(--kritisch); }
+
+.gewahrsam-zeile { align-items: flex-start; }
+.gewahrsam-zeile.abgelaufen { background: rgba(239,68,68,0.05); border-radius: 8px; }
+.gewahrsam-rechts {
+ display: flex; flex-direction: column; align-items: flex-end; gap: 7px; flex: none;
+}
+.rest-anzeige {
+ font-size: 15px; font-weight: 800; font-variant-numeric: tabular-nums;
+ color: var(--warn);
+}
+.rest-anzeige.abgelaufen { color: var(--kritisch); }
+
+/* =====================================================================
+ Beweise & Asservate
+===================================================================== */
+.beweis-symbol {
+ font-size: 20px; width: 32px; text-align: center; flex: none;
+}
+
+/* Verwahrkette */
+.kette { position: relative; padding-left: 4px; }
+.kette-schritt { display: flex; gap: 14px; position: relative; padding-bottom: 16px; }
+.kette-schritt:last-child { padding-bottom: 0; }
+/* Verbindungslinie zwischen den Schritten */
+.kette-schritt:not(:last-child)::before {
+ content: ""; position: absolute; left: 13px; top: 28px; bottom: 0;
+ width: 2px; background: var(--rand-stark);
+}
+.kette-punkt {
+ width: 28px; height: 28px; border-radius: 50%; flex: none;
+ display: grid; place-items: center; font-size: 11px; font-weight: 800;
+ background: var(--akzent-weich); color: var(--akzent);
+ border: 1px solid var(--akzent); position: relative; z-index: 1;
+}
+.kette-inhalt { padding-top: 3px; }
+.kette-aktion { font-size: 13px; font-weight: 700; }
+.kette-meta { font-size: 11.5px; color: var(--text-leise); margin-top: 2px; }
+.kette-notiz {
+ font-size: 12px; margin-top: 5px; padding: 7px 10px; border-radius: 7px;
+ background: var(--flaeche-2); border: 1px solid var(--rand); line-height: 1.5;
+}
+
+/* =====================================================================
+ Berichte
+===================================================================== */
+.unterschriften {
+ display: grid; grid-template-columns: repeat(auto-fill, minmax(190px, 1fr)); gap: 10px;
+}
+.unterschrift {
+ padding: 12px 14px; border-radius: 10px;
+ background: var(--flaeche-2); border: 1px solid var(--rand);
+ /* Angedeutete Unterschriftenlinie */
+ border-bottom: 2px solid var(--akzent);
+}
+.unterschrift .us-name {
+ font-size: 14px; font-weight: 700; font-style: italic;
+ padding-bottom: 6px;
+}
+.unterschrift .us-meta { font-size: 11px; color: var(--text-leise); }
+.unterschrift .us-zeit {
+ font-size: 10.5px; color: var(--text-leise); margin-top: 3px;
+ font-variant-numeric: tabular-nums;
+}
+
+/* =====================================================================
+ Fahndungen
+===================================================================== */
+.fahndungen { display: flex; flex-direction: column; gap: 9px; }
+
+.fahndung-karte {
+ display: flex; align-items: center; gap: 14px;
+ padding: 12px; border-radius: 11px; cursor: pointer; transition: .12s;
+ background: var(--flaeche-2); border: 1px solid var(--rand);
+ border-left: 4px solid var(--text-leise);
+}
+.fahndung-karte:hover { border-color: var(--akzent); transform: translateX(2px); }
+.fahndung-karte.gefahr-bewaffnet { border-left-color: var(--warn); }
+.fahndung-karte.gefahr-gefaehrlich { border-left-color: var(--kritisch); }
+
+.fahndung-karte .fk-bild {
+ width: 56px; height: 68px; flex: none; border-radius: 8px; overflow: hidden;
+ background: var(--flaeche-3); display: grid; place-items: center;
+}
+.fahndung-karte .fk-bild img { width: 100%; height: 100%; object-fit: cover; }
+.fahndung-karte .fk-symbol { font-size: 26px; opacity: .6; }
+
+.fahndung-karte .fk-haupt { flex: 1; min-width: 0; }
+.fahndung-karte .fk-titel { font-size: 14px; font-weight: 700; }
+.fahndung-karte .fk-grund {
+ font-size: 12.5px; color: var(--text); margin-top: 3px; line-height: 1.45;
+ display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden;
+}
+.fahndung-karte .fk-meta { font-size: 11px; color: var(--text-leise); margin-top: 5px; }
+
+.fahndung-karte .fk-rechts {
+ display: flex; flex-direction: column; align-items: flex-end; gap: 5px; flex: none;
+}
+.fahndung-karte .fk-prio { font-size: 10.5px; color: var(--text-leise); font-weight: 700; }
+
+.fahndung-bild {
+ max-width: 100%; max-height: 420px; border-radius: 10px;
+ border: 1px solid var(--rand); display: block;
+}
+
+/* =====================================================================
+ Fuhrpark
+===================================================================== */
+.fz-zeile { align-items: flex-start; }
+
+.fz-werte {
+ display: grid; grid-template-columns: auto 1fr auto 1fr;
+ gap: 6px 9px; align-items: center; margin-top: 7px; max-width: 460px;
+}
+.fz-wert {
+ font-size: 11px; font-weight: 700; color: var(--text-leise);
+ font-variant-numeric: tabular-nums; white-space: nowrap;
+}
+.fz-balken {
+ height: 6px; border-radius: 4px; background: var(--flaeche-3); overflow: hidden;
+}
+.fz-balken > i { display: block; height: 100%; border-radius: 4px; transition: width .3s; }
+
+.fz-anzeige { margin-top: 4px; }
+.fz-anzeige-zeile {
+ display: flex; justify-content: space-between; align-items: baseline;
+ font-size: 12.5px; margin-bottom: 5px;
+}
+.fz-anzeige-zeile span { color: var(--text-leise); }
+.fz-anzeige-zeile b { font-size: 15px; font-variant-numeric: tabular-nums; }
+
+/* =====================================================================
+ Personalverwaltung
+===================================================================== */
+.pv-verteilung { display: flex; flex-direction: column; gap: 7px; margin-top: 4px; }
+.pv-verteilung-zeile {
+ display: grid; grid-template-columns: 150px 1fr 34px;
+ gap: 10px; align-items: center;
+}
+.pv-vt-name { font-size: 12.5px; color: var(--text-leise); }
+.pv-vt-balken {
+ height: 7px; border-radius: 4px; background: var(--flaeche-3); overflow: hidden;
+}
+.pv-vt-balken > i {
+ display: block; height: 100%; border-radius: 4px;
+ background: var(--akzent); transition: width .3s;
+}
+.pv-vt-zahl {
+ font-size: 12.5px; font-weight: 800; text-align: right;
+ font-variant-numeric: tabular-nums;
+}
+
+/* Dienstpunkt und Dienstnummer in der Liste */
+.pv-punkt {
+ width: 8px; height: 8px; border-radius: 50%; flex: none;
+ background: var(--flaeche-3); border: 1px solid var(--rand);
+}
+.pv-punkt.an { background: var(--gut); border-color: var(--gut); }
+.pv-nummer {
+ font-family: ui-monospace, "SF Mono", Menlo, monospace;
+ font-size: 11.5px; font-weight: 700; color: var(--text-leise);
+ min-width: 84px; flex: none;
+}
+.pv-dienstdauer {
+ font-size: 12px; font-weight: 700; color: var(--text-leise);
+ font-variant-numeric: tabular-nums; white-space: nowrap;
+}
+.pv-notiz {
+ margin-top: 12px; font-size: 12.5px; line-height: 1.5;
+ color: var(--text-leise); border-left: 2px solid var(--rand); padding-left: 10px;
+}
+
+/* Rechtematrix */
+.pv-rechte { display: flex; flex-direction: column; gap: 16px; margin-top: 6px; }
+.pv-rechte-gruppe { display: flex; flex-direction: column; gap: 4px; }
+.pv-rechte-titel {
+ font-size: 11px; font-weight: 800; text-transform: uppercase;
+ letter-spacing: 0.05em; color: var(--text-leise); margin-bottom: 3px;
+}
+.pv-recht {
+ display: grid; grid-template-columns: 1fr auto auto;
+ gap: 10px; align-items: center;
+ padding: 8px 10px; border-radius: 8px; background: var(--flaeche-2);
+ border: 1px solid transparent;
+}
+.pv-recht.aktiv { border-color: var(--rand); }
+.pv-recht-text { display: flex; flex-direction: column; gap: 1px; min-width: 0; }
+.pv-recht-name { font-size: 12.5px; font-weight: 600; }
+.pv-recht-id {
+ font-family: ui-monospace, "SF Mono", Menlo, monospace;
+ font-size: 10px; color: var(--text-leise);
+}
+.pv-recht-schalter { display: flex; gap: 3px; flex: none; }
+.pv-schalter {
+ padding: 5px 9px; border-radius: 7px; cursor: pointer;
+ background: var(--flaeche-3); border: 1px solid var(--rand);
+ color: var(--text-leise); font-size: 11px; font-weight: 800; transition: .12s;
+}
+.pv-schalter:hover:not(:disabled) { color: var(--text); border-color: var(--akzent); }
+.pv-schalter.gewaehlt {
+ background: var(--akzent); border-color: var(--akzent); color: #fff;
+}
+.pv-schalter:disabled { opacity: .35; cursor: not-allowed; }
+
+/* Einstellungsdialog */
+.pv-trefferliste { max-height: 210px; overflow-y: auto; margin-bottom: 14px; }
+.pv-trefferliste .liste-zeile.gewaehlt {
+ border-color: var(--akzent); background: var(--flaeche-3);
+}
+
+/* =====================================================================
+ Interne Kommunikation
+===================================================================== */
+.komm-zaehler {
+ display: inline-block; margin-left: 6px; padding: 1px 6px; border-radius: 999px;
+ background: var(--kritisch); color: #fff;
+ font-size: 10px; font-weight: 800; vertical-align: middle;
+}
+
+/* Posteingang */
+.komm-zeile.ungelesen .lz-titel { font-weight: 800; }
+.komm-punkt {
+ width: 7px; height: 7px; border-radius: 50%; flex: none; background: transparent;
+}
+.komm-punkt.neu { background: var(--akzent); }
+.komm-zeit {
+ font-size: 11px; color: var(--text-leise); white-space: nowrap; flex: none;
+ font-variant-numeric: tabular-nums;
+}
+
+.komm-kopf {
+ display: flex; justify-content: space-between; align-items: baseline;
+ gap: 12px; padding-bottom: 10px; border-bottom: 1px solid var(--rand);
+}
+.komm-kopf-unter {
+ display: block; font-size: 11px; color: var(--text-leise); margin-top: 2px;
+}
+.komm-text {
+ margin-top: 12px; font-size: 13px; line-height: 1.6;
+ white-space: normal; word-break: break-word;
+}
+
+/* Empfängerauswahl */
+.komm-empf-arten { display: flex; gap: 5px; margin-bottom: 10px; }
+.komm-empfliste { max-height: 230px; overflow-y: auto; margin-top: 8px; }
+.komm-empfliste .liste-zeile.gewaehlt {
+ border-color: var(--akzent); background: var(--flaeche-3);
+}
+
+/* Aushänge */
+.komm-aushaenge { display: flex; flex-direction: column; gap: 12px; }
+.komm-aushang.angeheftet { border-color: var(--warn); }
+.komm-aushang-marker { display: flex; gap: 5px; align-items: center; }
+.komm-aushang-fuss {
+ display: flex; justify-content: space-between; align-items: flex-end;
+ gap: 12px; margin-top: 14px; padding-top: 11px; border-top: 1px solid var(--rand);
+ flex-wrap: wrap;
+}
+.komm-aushang-fuss .feld-hinweis { margin: 0; }
+.komm-aushang-aktionen {
+ display: flex; gap: 6px; align-items: center; flex-wrap: wrap;
+}
+
+.komm-haken {
+ width: auto !important; margin-right: 7px; vertical-align: -1px;
+}
+.feld label:has(.komm-haken) {
+ text-transform: none; letter-spacing: 0; font-size: 12.5px;
+ color: var(--text); cursor: pointer;
+}
+
+/* =====================================================================
+ Statistik
+===================================================================== */
+.st-leiste {
+ display: flex; justify-content: space-between; align-items: center;
+ gap: 12px; flex-wrap: wrap; margin-bottom: 16px;
+}
+.st-leiste .mdt-reiter { margin: 0; }
+.st-zeitraum { display: flex; gap: 4px; }
+
+.st-unter {
+ display: block; font-size: 10.5px; color: var(--text-leise); margin-top: 3px;
+}
+
+/* Zwei Karten nebeneinander */
+.st-spalten {
+ display: grid; grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
+ gap: 14px;
+}
+
+/* Wertepaare */
+.st-werte {
+ display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+ gap: 4px 18px; margin-top: 4px;
+}
+.st-werte > div {
+ display: flex; justify-content: space-between; align-items: baseline;
+ gap: 10px; padding: 5px 0; border-bottom: 1px solid var(--rand);
+}
+.st-werte span { font-size: 12.5px; color: var(--text-leise); }
+.st-werte b { font-size: 14px; font-variant-numeric: tabular-nums; white-space: nowrap; }
+
+.st-fuss {
+ margin-top: 12px; padding-top: 10px; border-top: 1px solid var(--rand);
+ font-size: 11.5px; line-height: 1.5; color: var(--text-leise);
+}
+.st-fuss b { color: var(--text); }
+
+/* Waagerechte Verteilung */
+.st-verteilung { display: flex; flex-direction: column; gap: 7px; margin-top: 4px; }
+.st-vt-zeile {
+ display: grid; grid-template-columns: 160px 1fr 52px 46px;
+ gap: 10px; align-items: center;
+}
+.st-vt-name {
+ font-size: 12.5px; color: var(--text-leise);
+ overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+}
+.st-vt-balken {
+ height: 7px; border-radius: 4px; background: var(--flaeche-3); overflow: hidden;
+}
+.st-vt-balken > i {
+ display: block; height: 100%; border-radius: 4px;
+ background: var(--akzent); transition: width .3s;
+}
+.st-vt-zahl {
+ font-size: 12.5px; font-weight: 800; text-align: right;
+ font-variant-numeric: tabular-nums;
+}
+.st-vt-anteil {
+ font-size: 11px; color: var(--text-leise); text-align: right;
+ font-variant-numeric: tabular-nums;
+}
+
+/* Tagesverlauf */
+.st-legende {
+ display: flex; gap: 16px; align-items: center; flex-wrap: wrap;
+ font-size: 11.5px; color: var(--text-leise); margin-bottom: 10px;
+}
+.st-legende .feld-hinweis { margin: 0 0 0 auto; }
+.st-punkt {
+ display: inline-block; width: 8px; height: 8px; border-radius: 2px;
+ margin-right: 5px; vertical-align: -1px;
+}
+.st-punkt.einsatz { background: var(--akzent); }
+.st-punkt.anzeige { background: var(--warn); }
+
+.st-verlauf {
+ display: flex; align-items: flex-end; gap: 3px;
+ height: 150px; overflow-x: auto; padding-bottom: 2px;
+}
+.st-tag {
+ display: flex; flex-direction: column; align-items: center; gap: 4px;
+ flex: 1 0 18px; height: 100%;
+}
+.st-saeulen {
+ display: flex; align-items: flex-end; gap: 2px;
+ width: 100%; height: 100%; justify-content: center;
+}
+.st-saeulen > i {
+ display: block; width: 6px; min-height: 2px; border-radius: 2px 2px 0 0;
+ transition: height .3s;
+}
+.st-saeulen > i.einsatz { background: var(--akzent); }
+.st-saeulen > i.anzeige { background: var(--warn); }
+.st-tag-text {
+ font-size: 9.5px; color: var(--text-leise); font-variant-numeric: tabular-nums;
+}
+
+/* Besetzung nach Tageszeit */
+.st-stunden {
+ display: flex; align-items: flex-end; gap: 4px; height: 170px; margin-top: 6px;
+}
+.st-stunde {
+ display: flex; flex-direction: column; align-items: center; gap: 5px;
+ flex: 1; height: 100%;
+}
+.st-stunde-balken {
+ display: flex; align-items: flex-end; width: 100%; height: 100%;
+ background: var(--flaeche-2); border-radius: 5px 5px 0 0; overflow: hidden;
+}
+.st-stunde-balken > i {
+ display: block; width: 100%; min-height: 2px;
+ background: var(--akzent); transition: height .3s;
+}
+.st-stunde-text {
+ font-size: 10px; color: var(--text-leise); font-variant-numeric: tabular-nums;
+}
+
+.st-ungenutzt {
+ display: flex; flex-wrap: wrap; gap: 5px; margin-top: 4px;
+}
+
+/* =====================================================================
+ Administration
+===================================================================== */
+.adm-icon { font-size: 17px; width: 24px; text-align: center; flex: none; }
+
+.adm-modul.aus, .adm-delikt.aus { opacity: .5; }
+.adm-modul.aus .lz-titel { text-decoration: line-through; }
+
+.adm-vorschlag {
+ font-size: 12px; font-weight: 700; color: var(--text-leise);
+ font-variant-numeric: tabular-nums; white-space: nowrap;
+ min-width: 72px; text-align: right; flex: none;
+}
+
+/* Zwei Felder nebeneinander im Formular */
+.adm-formular {
+ display: grid; grid-template-columns: repeat(auto-fit, minmax(160px, 1fr)); gap: 0 14px;
+}
+
+.adm-protokoll { align-items: flex-start; }
+.adm-grund {
+ margin-top: 4px; font-size: 11.5px; font-style: italic; color: var(--text-leise);
+ border-left: 2px solid var(--rand); padding-left: 8px;
+}
+
+/* =====================================================================
+ Zweitschreibweisen der Bausteine
+ Personal, Statistik und Administration nutzen diese Varianten.
+ Gleiche Optik, nur andere Klassennamen — hier zusammengeführt,
+ damit beide Schreibweisen sicher greifen.
+===================================================================== */
+.raster-2 { grid-template-columns: repeat(2, 1fr); }
+.raster-3 { grid-template-columns: repeat(3, 1fr); }
+.raster-4 { grid-template-columns: repeat(4, 1fr); }
+@media (max-width: 1100px) {
+ .raster-3, .raster-4 { grid-template-columns: repeat(2, 1fr); }
+}
+
+/* Kennzahl mit Wert zuerst, Beschriftung darunter */
+.kennzahl .kz-zahl {
+ display: block; font-size: 24px; font-weight: 800;
+ font-variant-numeric: tabular-nums; line-height: 1.15;
+}
+.kennzahl .kz-text {
+ display: block; font-size: 10.5px; text-transform: uppercase;
+ letter-spacing: 0.06em; color: var(--text-leise); font-weight: 800; margin-top: 5px;
+}
diff --git a/resources/[aether]/aether-police/html/index.html b/resources/[aether]/aether-police/html/index.html
new file mode 100644
index 0000000..ca11b0e
--- /dev/null
+++ b/resources/[aether]/aether-police/html/index.html
@@ -0,0 +1,128 @@
+
+
+
+LSPD — Dienstsystem
+
+
+
★
+
Los Santos Police Department
+
—
+
Dienstnummer —
+
Dienstgrad —
+
Abteilung —
+
Dienst antreten
+
Abbrechen
+
+ Das System unterstützt deine Entscheidungen — es trifft niemals selbst welche.
+
+
+
+
+
+
+
+
★
+
+ LSPD
+ Dienstsystem
+
+
+ ◐
+ ⏻
+
+
+
+
+
+
+
+
+
+ ⌕
+
+
+
+
+
+
+
+
+ ✉0
+
+
+
+
+
+
✕
+
+
+
+
+
+
+
+
+
+
+
+ Mitteilungen
+ ✕
+
+
+
+
+
+
+
+
+
+
${sicher(k.text)} `
+ ).join("");
+
+ hg.innerHTML =
+ `
+
+
${sicher(o.titel || "")}
+ ✕
+
+
${o.inhalt || ""}
+ ${knoepfe ? `
${knoepfe}
` : ""}
+
+
ℹ
+
Diese Entscheidung triffst du. Das System hat den Vorgang nur
+ vorbereitet — ausgeführt wird er erst mit deiner Bestätigung.
+
+ ${sicher(m.icon)}
+ ${sicher(m.name)}
+ `
+ ).join("");
+
+ nav.querySelectorAll("[data-modul]").forEach((b) => {
+ b.addEventListener("click", () => oeffneModul(b.dataset.modul));
+ });
+ }
+
+ /**
+ * Öffnet ein Modul und lässt seine Ansicht zeichnen.
+ * @param {string} modulId Modul
+ * @param {object} ziel Optionaler Sprungbefehl, z. B. { person: 42 }.
+ * Die Ansicht liest ihn über App.zustand.modulZiel und räumt ihn auf.
+ */
+ async function oeffneModul(modulId, ziel) {
+ zustand.aktivesModul = modulId;
+ zustand.modulZiel = ziel || null;
+ zeichneNavigation();
+
+ const inhalt = $("inhalt");
+ inhalt.innerHTML = ``;
+
+ const ansicht = ansichten[modulId];
+ if (!ansicht) {
+ inhalt.innerHTML =
+ `Noch nicht verfügbar
+
Für diesen Bereich ist noch keine Ansicht hinterlegt.
Fehler
+
${sicher(fehler.message || "Der Bereich konnte nicht geladen werden.")}
+ `
+ ).join("");
+
+ $("status-liste").querySelectorAll("[data-status]").forEach((b) => {
+ b.addEventListener("click", () => {
+ const neu = b.dataset.status;
+ if (zustand.beamter) zustand.beamter.status = neu;
+ anClient("status", { status: neu });
+ $("status-liste").hidden = true;
+ zeichneStatus();
+ });
+ });
+ }
+
+ /* ---- Mitteilungen ------------------------------------------------ */
+
+ function zeichneHinweise() {
+ const ungelesen = zustand.hinweise.filter((h) => !h.gelesen).length;
+ const zaehler = $("hinweise-zaehler");
+ zaehler.hidden = ungelesen === 0;
+ zaehler.textContent = ungelesen > 99 ? "99+" : ungelesen;
+
+ const symbole = {
+ einsatz: "🚨", fahndung: "🔍", gewahrsam: "🔒",
+ bericht: "📄", akte: "🗂", beweis: "🔬", system: "ℹ",
+ };
+
+ $("hinweise-inhalt").innerHTML = zustand.hinweise.length
+ ? zustand.hinweise.map((h) =>
+ `
+
+ ${symbole[h.kategorie] || "•"} ${sicher(h.titel)}
+ ${zeit(h.erstellt_am)}
+
+ ${h.text ? `
${sicher(h.text)}
` : ""}
+
Keine Mitteilungen.
`;
+
+ $("hinweise-inhalt").querySelectorAll("[data-hinweis]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const id = +el.dataset.hinweis;
+ if (!id) return;
+ const treffer = zustand.hinweise.find((h) => h.id === id);
+ if (treffer) treffer.gelesen = 1;
+ aufruf("dashboard", "hinweisGelesen", { id }).catch(() => {});
+ zeichneHinweise();
+ if (treffer) springeZuHinweis(treffer);
+ });
+ });
+ }
+
+ /**
+ * Öffnet das Modul, zu dem ein Hinweis gehört.
+ * Nur Ziele, die eine Ansicht auch auswertet, werden mitgegeben —
+ * alles andere öffnet schlicht das passende Modul.
+ */
+ function springeZuHinweis(hinweis) {
+ if (!hinweis.zielTyp) return;
+
+ // zielTyp → [Modul, Schlüssel des Sprungziels oder null]
+ const wege = {
+ akte: ["mdt", "akte"],
+ nachricht: ["kommunikation", "nachricht"],
+ aushang: ["kommunikation", "aushang"],
+ einsatz: ["einsatz", null],
+ fahndung: ["fahndung", null],
+ gewahrsam: ["gewahrsam", null],
+ bericht: ["bericht", null],
+ beweis: ["beweis", null],
+ };
+
+ const weg = wege[hinweis.zielTyp];
+ if (!weg) return;
+
+ // Nur öffnen, wenn das Modul für diesen Beamten überhaupt sichtbar ist
+ if (!zustand.module.some((m) => m.id === weg[0])) return;
+
+ const ziel = weg[1] && hinweis.zielId ? { [weg[1]]: +hinweis.zielId } : null;
+ oeffneModul(weg[0], ziel);
+ $("hinweise-schublade").hidden = true;
+ }
+
+ /** Nimmt einen neu eingetroffenen Hinweis auf */
+ function neuerHinweis(hinweis) {
+ zustand.hinweise.unshift(Object.assign({ erstellt_am: new Date().toISOString() }, hinweis));
+ if (zustand.hinweise.length > 50) zustand.hinweise.pop();
+ zeichneHinweise();
+ meldung(hinweis.titel, hinweis.prioritaet === "kritisch" ? "fehler" : "");
+
+ // Offene Ansicht auffrischen, falls sie das betrifft
+ const ansicht = ansichten[zustand.aktivesModul];
+ if (ansicht && ansicht.aktualisieren) ansicht.aktualisieren();
+ }
+
+ /* ---- Aufbau bei Öffnen ------------------------------------------ */
+
+ function zeigeTablet(daten) {
+ zustand.imDienst = true;
+ zustand.beamter = daten.beamter;
+ zustand.module = daten.module || [];
+ zustand.dienststatus = daten.status || [];
+ zustand.abteilungen = daten.abteilungen || [];
+
+ $("anmeldung").hidden = true;
+ $("tablet").hidden = false;
+
+ $("tb-kuerzel").textContent = daten.kuerzel || "POL";
+ $("tb-behoerde").textContent = daten.behoerde || "Dienstsystem";
+ $("tb-name").textContent = daten.beamter.name;
+ $("tb-rolle").textContent = daten.beamter.rolleName +
+ (daten.beamter.leitstelle ? " · Leitstelle" : "");
+ $("tb-nummer").textContent = daten.beamter.dienstnummer;
+
+ zeichneNavigation();
+ zeichneStatus();
+
+ // Erstes Modul öffnen
+ if (zustand.module.length) oeffneModul(zustand.module[0].id);
+ }
+
+ function zeigeAnmeldung(daten) {
+ zustand.imDienst = false;
+ $("tablet").hidden = true;
+ $("anmeldung").hidden = false;
+
+ $("an-behoerde").textContent = daten.behoerde || "";
+ $("an-name").textContent = daten.name || "—";
+ $("an-nummer").textContent = daten.dienstnummer || "—";
+ $("an-rolle").textContent = daten.rolleName || "—";
+ $("an-abteilung").textContent = daten.abteilung || "—";
+ }
+
+ /* ---- Nachrichten vom Client ------------------------------------- */
+
+ window.addEventListener("message", (ereignis) => {
+ const n = ereignis.data || {};
+
+ switch (n.aktion) {
+ case "oeffnen":
+ document.body.style.display = "";
+ zeigeTablet(n);
+ break;
+
+ case "anmeldung":
+ document.body.style.display = "";
+ zeigeAnmeldung(n);
+ break;
+
+ case "antwort": {
+ const eintrag = offeneAufrufe[n.ruf];
+ if (!eintrag) break;
+ delete offeneAufrufe[n.ruf];
+ if (n.fehler) eintrag.ablehnen(new Error(n.fehler));
+ else eintrag.aufloesen(n.ergebnis);
+ break;
+ }
+
+ case "dienstliste":
+ zustand.beamteImDienst = n.beamte || [];
+ {
+ const ansicht = ansichten[zustand.aktivesModul];
+ if (ansicht && ansicht.aktualisieren) ansicht.aktualisieren();
+ }
+ break;
+
+ case "hinweis":
+ neuerHinweis(n.hinweis || {});
+ break;
+
+ case "fehler":
+ meldung(n.text || "Aktion nicht möglich", "fehler");
+ break;
+
+ case "schliessen":
+ document.body.style.display = "none";
+ break;
+ }
+ });
+
+ /* ---- Bedienelemente der Shell ----------------------------------- */
+
+ function verdrahteShell() {
+ $("tablet-schliessen").addEventListener("click", () => anClient("schliessen", {}));
+ $("an-abbrechen").addEventListener("click", () => anClient("schliessen", {}));
+ $("an-antreten").addEventListener("click", () => anClient("dienstAntreten", {}));
+
+ $("dienst-beenden").addEventListener("click", () => {
+ bestaetigen({
+ titel: "Dienst beenden",
+ inhalt: `
+ Deine Dienstzeit wird protokolliert. Laufende Vorgänge bleiben bestehen und
+ können von anderen Beamten weitergeführt werden.
`,
+ bestaetigenText: "Dienst beenden",
+ bestaetigt: (_, zu) => { anClient("dienstBeenden", {}); zu(); },
+ });
+ });
+
+ $("status-knopf").addEventListener("click", () => {
+ $("status-liste").hidden = !$("status-liste").hidden;
+ });
+
+ $("hinweise-knopf").addEventListener("click", () => {
+ const schublade = $("hinweise-schublade");
+ schublade.hidden = !schublade.hidden;
+ if (!schublade.hidden) zeichneHinweise();
+ });
+ $("hinweise-zu").addEventListener("click", () => { $("hinweise-schublade").hidden = true; });
+
+ $("thema-wechsel").addEventListener("click", () => {
+ document.body.classList.toggle("thema-dunkel");
+ document.body.classList.toggle("thema-hell");
+ });
+
+ // Klick ausserhalb schliesst die Statusliste
+ document.addEventListener("click", (e) => {
+ if (!$("status-waehler").contains(e.target)) $("status-liste").hidden = true;
+ });
+
+ // ESC schliesst Fenster, sonst das Tablet
+ document.addEventListener("keydown", (e) => {
+ if (e.key !== "Escape") return;
+ const offeneFenster = $("fenster-ebene").lastElementChild;
+ if (offeneFenster) { offeneFenster.remove(); return; }
+ if (!$("hinweise-schublade").hidden) { $("hinweise-schublade").hidden = true; return; }
+ anClient("schliessen", {});
+ });
+
+ // Globale Suche (wird von den Fachmodulen bedient)
+ $("global-suche").addEventListener("keydown", (e) => {
+ if (e.key === "Enter") {
+ const begriff = e.target.value.trim();
+ if (begriff.length >= 2) globaleSuche(begriff);
+ }
+ });
+ }
+
+ /** Globale Suche über alle Module, die sich dafür anmelden */
+ const suchAnbieter = [];
+ function registriereSuche(funktion) { suchAnbieter.push(funktion); }
+
+ async function globaleSuche(begriff) {
+ if (!suchAnbieter.length) {
+ meldung("Es ist noch kein durchsuchbarer Bereich verfügbar.");
+ return;
+ }
+
+ const treffer = [];
+ for (const anbieter of suchAnbieter) {
+ try {
+ const ergebnis = await anbieter(begriff);
+ if (Array.isArray(ergebnis)) treffer.push(...ergebnis);
+ } catch (e) { /* einzelne Anbieter dürfen scheitern */ }
+ }
+
+ fenster({
+ titel: `Suche: „${begriff}"`,
+ inhalt: treffer.length
+ ? `${treffer.map((t) =>
+ `
+
${sicher(t.bereich)}
+
+
${sicher(t.titel)}
+
${sicher(t.unter || "")}
+
+
`).join("")}
Keine Treffer.
`,
+ });
+ }
+
+ /* ---- Öffentliche Schnittstelle ---------------------------------- */
+ return {
+ /** Registriert eine Modulansicht */
+ registriereAnsicht(modulId, ansicht) { ansichten[modulId] = ansicht; },
+ /** Registriert einen Anbieter für die globale Suche */
+ registriereSuche,
+ zustand, aufruf, meldung, fenster, bestaetigen,
+ sicher, zeit, dauer, euro, $,
+ anClient, oeffneModul,
+ start() {
+ verdrahteShell();
+ if (IST_FIVEM) document.body.style.display = "none";
+ else {
+ // Eigenständige Browser-Ansicht: Anmeldebildschirm zeigen
+ zeigeAnmeldung({
+ behoerde: "Los Santos Police Department", name: "Vorschau",
+ dienstnummer: "LSPD-0000", rolleName: "Officer", abteilung: "streife",
+ });
+ }
+ },
+ };
+})();
+
+App.start();
diff --git a/resources/[aether]/aether-police/html/js/module/admin.js b/resources/[aether]/aether-police/html/js/module/admin.js
new file mode 100644
index 0000000..3685b5c
--- /dev/null
+++ b/resources/[aether]/aether-police/html/js/module/admin.js
@@ -0,0 +1,495 @@
+/* =====================================================================
+ aether-police / Ansicht: Administration
+
+ Module an- und abschalten, Strafenkatalog pflegen, Protokoll lesen.
+ Die Reiter richten sich nach den Rechten des Beamten — wer nur das
+ Protokoll lesen darf, sieht auch nur dieses.
+===================================================================== */
+"use strict";
+
+(() => {
+ const { sicher, zeit, euro, aufruf, meldung, fenster, bestaetigen } = App;
+
+ const z = {
+ bereiche: null, // welche Reiter erlaubt sind
+ reiter: null,
+ daten: null,
+ katalogSuche: "",
+ katalogKategorie: "",
+ katalogStillgelegt: false,
+ protokollModul: "",
+ protokollNummer: "",
+ };
+
+ /* ---- Reiter ---------------------------------------------------------- */
+
+ function reiterleiste() {
+ const moeglich = [
+ { id: "module", text: "Module", erlaubt: z.bereiche.module },
+ { id: "katalog", text: "Strafenkatalog", erlaubt: z.bereiche.katalog },
+ { id: "protokoll", text: "Protokoll", erlaubt: z.bereiche.protokoll },
+ ].filter((e) => e.erlaubt);
+
+ return `
+ ${moeglich.map((e) => `
+
+ ${sicher(e.text)} `).join("")}
+
`;
+ }
+
+ function verdrahteReiter(behaelter) {
+ behaelter.querySelectorAll("[data-reiter]").forEach((el) => {
+ el.addEventListener("click", () => {
+ z.reiter = el.dataset.reiter;
+ rendern(behaelter);
+ });
+ });
+ }
+
+ /* ---- Module ----------------------------------------------------------- */
+
+ function moduleAnsicht(behaelter) {
+ const d = z.daten;
+ const aktiv = d.module.filter((m) => m.aktiv).length;
+
+ behaelter.innerHTML = `
+
+
+
Module
+
Jeder Baustein lässt sich einzeln abschalten. Abgeschaltete Module
+ verschwinden aus der Seitenleiste — ihre Daten bleiben unangetastet.
+
+
+
${aktiv}/${d.module.length}
+ Module aktiv
+
${d.beamteImDienst}
+ Beamte im Dienst
+
+ ${d.module.reduce((s, m) => s + m.aktionen, 0)}
+ registrierte Aktionen
+
+
Registrierte Module
+
+ ${d.module.map(modulZeile).join("")}
+
+
+
+ Konfiguration
+ Steht in config.lua — Änderung erfordert Neustart
+
+
+ ${d.konfiguration.map((k) =>
+ `
${sicher(k.name)} ${sicher(k.wert)}
`).join("")}
+
+
+
${sicher(m.icon)}
+
+
${sicher(m.name)}
+
+ ${sicher(m.beschreibung || "")}
+ ${m.rechtName ? ` · Recht: ${sicher(m.rechtName)}`
+ : m.recht ? ` · Recht: ${sicher(String(m.recht))}` : " · für alle sichtbar"}
+
+
+
${m.aktionen} Aktionen
+ ${m.unverzichtbar
+ ? `
+ unverzichtbar `
+ : `
+ ${m.aktiv ? "Abschalten" : "Einschalten"} `}
+
${sicher(modul.name)} wird
+ ${einschalten ? "wieder in der Seitenleiste erscheinen"
+ : "für alle Beamten aus der Seitenleiste verschwinden"}.
+ ${einschalten ? "" : `Vorhandene Daten bleiben erhalten
+ und sind nach dem Wiedereinschalten unverändert da. Beamte, die das Tablet
+ gerade offen haben, sehen die Änderung beim nächsten Öffnen.
`}
+ Grund (freiwillig)
+
`,
+ bestaetigenText: einschalten ? "Einschalten" : "Abschalten",
+ bestaetigt: async (dialog, zu) => {
+ try {
+ await aufruf("admin", "modulSchalten", {
+ id, aktiv: einschalten,
+ grund: dialog.querySelector("[name=grund]").value.trim(),
+ });
+ zu();
+ meldung(einschalten ? "Modul eingeschaltet." : "Modul abgeschaltet.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+ });
+ }
+
+ /* ---- Strafenkatalog ---------------------------------------------------- */
+
+ function katalogAnsicht(behaelter) {
+ const d = z.daten;
+
+ // Delikte nach Kategorie gruppieren
+ const gruppen = {};
+ d.delikte.forEach((delikt) => {
+ (gruppen[delikt.kategorie] = gruppen[delikt.kategorie] || []).push(delikt);
+ });
+
+ behaelter.innerHTML = `
+
+
+
Strafenkatalog
+
Die Werte hier sind Vorschläge . Sie werden nie automatisch verhängt —
+ ein Beamter kann jederzeit begründet davon abweichen.
+
+
＋ Delikt anlegen
+
+
+ Alle Kategorien
+ ${d.kategorien.map((k) =>
+ `
+ ${sicher(k.kategorie)} `).join("")}
+
+
+ ${z.katalogStillgelegt ? "Auch stillgelegte" : "Nur aktive"}
+
+
+
+ ${Object.keys(gruppen).length
+ ? Object.keys(gruppen).map((kategorie) => `
+
+
+ ${sicher(kategorie)}
+ ${gruppen[kategorie].length} Delikte
+
+
${gruppen[kategorie].map(deliktZeile).join("")}
+
Kein Delikt gefunden.
`}
+ `;
+
+ verdrahteKatalog(behaelter);
+ }
+
+ function deliktZeile(delikt) {
+ return `
+
${sicher(delikt.kennung)}
+
+
${sicher(delikt.bezeichnung)}
+
+ ${sicher(delikt.paragraph || "ohne Paragraf")}
+ ${delikt.hinweis ? " · " + sicher(delikt.hinweis) : ""}
+
+
+
+ ${delikt.haft || 0} Min
+
+ ${euro(delikt.geld || 0)}
+ ${delikt.aktiv ? "" : `
stillgelegt `}
+
Bearbeiten
+
+ ${delikt.aktiv ? "Stilllegen" : "Freigeben"}
+
${sicher(delikt.kennung)} — ${sicher(delikt.bezeichnung)}
+ ${freigeben
+ ? "Das Delikt steht wieder zur Auswahl."
+ : "Das Delikt lässt sich für neue Anzeigen nicht mehr auswählen."}
+ Gelöscht wird nichts — bestehende Anzeigen behalten
+ ihren Eintrag und bleiben nachvollziehbar.
+ Grund (freiwillig)
+
`,
+ bestaetigenText: freigeben ? "Freigeben" : "Stilllegen",
+ bestaetigt: async (dialog, zu) => {
+ try {
+ await aufruf("admin", "katalogSchalten", {
+ id: delikt.id, aktiv: freigeben,
+ grund: dialog.querySelector("[name=grund]").value.trim(),
+ });
+ zu();
+ meldung(freigeben ? "Delikt freigegeben." : "Delikt stillgelegt.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+ });
+ }
+
+ function deliktFenster(behaelter, delikt) {
+ const neu = !delikt;
+ delikt = delikt || { kennung: "", kategorie: "", bezeichnung: "", paragraph: "",
+ haft: 0, geld: 0, hinweis: "", sortierung: 0 };
+
+ fenster({
+ titel: neu ? "Delikt anlegen" : "Delikt bearbeiten",
+ inhalt: `
+
+ Bezeichnung
+
+ Paragraf
+
+
+
+
+ Hinweis für den Beamten
+
+ Sortierung
+
+
+
+
ℹ
+
Diese Werte sind Vorschläge . Das System verhängt sie nie —
+ es rechnet sie nur zusammen und legt sie dem Beamten vor.
+
+
+
Protokoll
+
Jede Entscheidung im System steht hier mit Beamtem, Zeit und Begründung.
+ Einträge lassen sich weder ändern noch entfernen.
+
+
${d.gesamt.toLocaleString("de-DE")} Einträge gesamt
+
+
+ Alle Module
+ ${d.module.map((m) =>
+ `
+ ${sicher(m.modul)} `).join("")}
+
+ Filter zurücksetzen
+
+
+
+ ${d.eintraege.length
+ ? d.eintraege.map(protokollZeile).join("")
+ : `
${d.unbekannteNummer
+ ? "Diese Dienstnummer gibt es nicht."
+ : "Kein Eintrag gefunden."}
`}
+
+
${sicher(e.modul)}
+
+
${sicher(e.aktion)}
+
+ ${sicher(e.name)}${e.dienstnummer ? " (" + sicher(e.dienstnummer) + ")" : ""}
+ ${e.ziel_typ ? ` · ${sicher(e.ziel_typ)} ${sicher(e.ziel_id || "")}` : ""}
+ ${details ? ` · ${details}` : ""}
+
+ ${e.grund ? `
„${sicher(e.grund)}"
` : ""}
+
+
${zeit(e.am || e.erstellt_am)}
+
Administration
+
Für keinen Bereich der Administration hast du eine Berechtigung.
Administration
+
Konnte nicht geladen werden: ${sicher(f.message)}
${reiter.map((r) =>
+ `
+ ${r.symbol} ${r.name} `).join("")}
`;
+ }
+
+ /** Zeigt Minuten als „1 Std 30 Min" */
+ function haftText(minuten) {
+ const m = Math.max(0, Math.floor(minuten || 0));
+ if (m === 0) return "keine Haft";
+ if (m < 60) return m + " Min";
+ return Math.floor(m / 60) + " Std " + (m % 60 ? (m % 60) + " Min" : "");
+ }
+
+ /* =====================================================================
+ ANZEIGE ERFASSEN
+ ===================================================================== */
+
+ function katalogAuswahl() {
+ if (!z.katalog.length) return `Der Katalog ist leer.
`;
+
+ return z.katalog.map((gruppe) => `
+
+
${sicher(gruppe.kategorie)}
+ ${gruppe.delikte.map((d) => `
+
+
+
${sicher(d.bezeichnung)}
+
+ ${d.paragraph ? sicher(d.paragraph) + " · " : ""}
+ ${haftText(d.haft)} · ${euro(d.geld)}
+
+
`).join("")}
+
+
+
Anzeige erfassen
+
Der Katalog schlägt vor — entschieden wird von dir.
+
+
+
+
+ Strafenkatalog
+
+
${katalogAuswahl()}
+
+
+
+
Vorgang
+
+
+
Beschuldigte Person
+
+ Suchen
+
+ ${z.beschuldigter
+ ? `
Ausgewählt: ${sicher(z.beschuldigter.name)}
`
+ : `
Ohne Beschuldigten kann keine Anzeige erfasst werden.
`}
+
+
+ ${v ? `
+
+
+ Vorschlag des Katalogs
+ ${v.delikte.length} Delikt${v.delikte.length === 1 ? "" : "e"}
+
+
+
Haft ${haftText(v.haft)}
+
Geldstrafe ${euro(v.geld)}
+
+ ${v.hinweise.length ? `
+
+ ${v.hinweise.map((h) => `
ℹ ${sicher(h)}
`).join("")}
+
` : ""}
+
+
+
+
Deine Entscheidung
+
+
+
+
⚠ Du weichst vom Vorschlag ab
+
+ Begründung (erforderlich)
+
+
+
+
+
+
ℹ
+
Der Katalog ist ein Nachschlagewerk . Beide Werte lassen sich frei
+ anpassen — gespeichert werden Vorschlag und Entscheidung getrennt, damit
+ nachvollziehbar bleibt, wer was festgelegt hat.
+
+
+
Als Entwurf erfassen
+
+ Es wird noch nichts eingezogen und niemand kommt in Haft.
+
+
`
+ : `
Wähle links mindestens ein Delikt aus.
`}
+
+
${treffer.map((p) =>
+ `
+
+
${sicher(p.firstname + " " + p.lastname)}
+
geb. ${sicher(String(p.dob || "").slice(0, 10))}
+
+
`).join("")}
Keine Treffer.
`,
+ nachOeffnen: (el) => {
+ el.querySelectorAll("[data-wahl]").forEach((zeile) =>
+ zeile.addEventListener("click", () => {
+ z.beschuldigter = { id: +zeile.dataset.wahl, name: zeile.dataset.name };
+ el.remove();
+ erfassenAnsicht(behaelter);
+ }));
+ },
+ });
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ /* =====================================================================
+ VORGÄNGE
+ ===================================================================== */
+
+ function vorgaengeAnsicht(behaelter) {
+ const statusArt = { entwurf: "warn", bestaetigt: "info", verworfen: "neutral" };
+ const statusText = { entwurf: "Entwurf", bestaetigt: "Bestätigt", verworfen: "Verworfen" };
+
+ behaelter.innerHTML = `
+
+
Vorgänge Erfasste Anzeigen und ihr Bearbeitungsstand
+
+ Alle
+ Nur Entwürfe
+ Nur bestätigte
+ Nur verworfene
+
+
+ ${z.anzeigen.length ? `
${z.anzeigen.map((a) => `
+
+
+
+ ${sicher((a.b_vorname || "") + " " + (a.b_nachname || ""))}
+ ${a.abweichung ? 'abweichend ' : ""}
+
+
+ ${sicher((a.delikte || []).map((d) => d.name).join(", ") || "—")}
+
+
+ ${haftText(a.haft_final)} · ${euro(a.geld_final)}
+ ${a.abweichung ? ` (Vorschlag: ${haftText(a.haft_empfohlen)} · ${euro(a.geld_empfohlen)}) ` : ""}
+ · erfasst von ${sicher((a.e_vorname || "") + " " + (a.e_nachname || ""))} · ${zeit(a.erstellt_am)}
+
+ ${a.begruendung ? `
„${sicher(a.begruendung)}"
` : ""}
+
+
+ ${sicher(statusText[a.status] || a.status)}
+ ${a.status === "entwurf" && z.rechte.bestaetigen
+ ? `Bestätigen ` : ""}
+ ${a.status === "entwurf"
+ ? `Verwerfen ` : ""}
+
+
`).join("")}
`
+ : `
Keine Vorgänge.
`}
+
Grund
+
`,
+ bestaetigenText: "Verwerfen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("anzeige", "verwerfen", {
+ id: +b.dataset.verwerfen,
+ grund: el.querySelector("#av-grund").value.trim(),
+ });
+ zu(); meldung("Entwurf verworfen."); rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }));
+ }
+
+ /** Bestätigungsdialog — benennt genau, was ausgeführt wird */
+ function bestaetigenDialog(behaelter, anzeigeId) {
+ const a = z.anzeigen.find((x) => x.id === anzeigeId);
+ if (!a) return;
+
+ bestaetigen({
+ titel: "Anzeige bestätigen",
+ inhalt: `
+
+ ${sicher((a.b_vorname || "") + " " + (a.b_nachname || ""))}
+
+
+
Mit deiner Bestätigung geschieht Folgendes:
+
+
💶
+
Die Geldstrafe von ${euro(a.geld_final)} wird eingezogen und
+ der Staatskasse zugeführt.
+
+
+
🔒
+
${a.haft_final > 0
+ ? `Die festgelegte Haftdauer von ${haftText(a.haft_final)} wird
+ vermerkt — eine Einweisung in Gewahrsam erfolgt dadurch nicht .
+ Das ist ein eigener Schritt.`
+ : "Es ist keine Haft vorgesehen."}
+
+
+
📄
+
Der Vorgang wird mit deinem Namen als bestätigend festgehalten.
+
+
+
⚠ Abweichung vom Katalogvorschlag
+
+ Vorschlag war ${haftText(a.haft_empfohlen)} · ${euro(a.geld_empfohlen)}.
+ ${a.begruendung ? `Begründung: „${sicher(a.begruendung)}"` : "Keine Begründung hinterlegt."}
+
+
+
Strafenkatalog pflegen
+
Die Werte hier sind Empfehlungen — sie binden niemanden.
+
＋ Eintrag
+
+ ${z.katalog.map((gruppe) => `
+
+
${sicher(gruppe.kategorie)}
+
${gruppe.delikte.map((d) => `
+
+
${sicher(d.kennung)}
+
+
${sicher(d.bezeichnung)}
+
${d.paragraph ? sicher(d.paragraph) + " · " : ""}
+ ${haftText(d.haft)} · ${euro(d.geld)}
+ ${d.hinweis ? " · " + sicher(d.hinweis) : ""}
+
+
Ändern
+
Deaktivieren
+
`).join("")}
+
`).join("")}
+
+ Der Eintrag verschwindet aus der Auswahl, bleibt aber in bestehenden Anzeigen
+ nachvollziehbar. Gelöscht wird nichts.
`,
+ bestaetigenText: "Deaktivieren",
+ bestaetigt: async (_, zu) => {
+ try {
+ await aufruf("anzeige", "katalogDeaktivieren", { kennung: b.dataset.katWeg });
+ zu(); meldung("Eintrag deaktiviert."); rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }));
+ }
+
+ function katalogDialog(behaelter, eintrag) {
+ const e = eintrag || {};
+ fenster({
+ titel: eintrag ? "Eintrag ändern" : "Neuer Katalogeintrag",
+ inhalt: `
+
+ Bezeichnung
+
+ Gesetzliche Grundlage
+
+
+ Hinweis für Beamte
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Speichern", klick: async (el, zu) => {
+ try {
+ await aufruf("anzeige", "katalogSpeichern", {
+ kennung: el.querySelector("#kd-kennung").value.trim(),
+ kategorie: el.querySelector("#kd-kategorie").value.trim(),
+ bezeichnung: el.querySelector("#kd-bezeichnung").value.trim(),
+ paragraph: el.querySelector("#kd-paragraph").value.trim(),
+ haft: +el.querySelector("#kd-haft").value,
+ geld: +el.querySelector("#kd-geld").value,
+ hinweis: el.querySelector("#kd-hinweis").value.trim(),
+ });
+ zu(); meldung("Gespeichert.", "gut"); rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }},
+ ],
+ });
+ }
+
+ /* ---- Laden -------------------------------------------------------- */
+
+ async function rendern(behaelter) {
+ try {
+ const k = await aufruf("anzeige", "katalog", {});
+ z.katalog = k.katalog;
+ z.rechte = k.rechte;
+
+ if (z.reiter === "vorgaenge") {
+ const v = await aufruf("anzeige", "liste", { status: z.filterStatus });
+ z.anzeigen = v.anzeigen;
+ z.rechte = Object.assign({}, z.rechte, v.rechte);
+ vorgaengeAnsicht(behaelter);
+ } else if (z.reiter === "katalog") {
+ katalogAnsicht(behaelter);
+ } else {
+ erfassenAnsicht(behaelter);
+ }
+
+ behaelter.querySelectorAll("[data-reiter]").forEach((b) =>
+ b.addEventListener("click", () => { z.reiter = b.dataset.reiter; rendern(behaelter); }));
+
+ } catch (f) {
+ behaelter.innerHTML = `Anzeigen
+
Konnte nicht geladen werden: ${sicher(f.message)}
+
+
Asservatenkammer
+
Jeder Schritt wird mit Namen festgehalten — die Verwahrkette bleibt lückenlos.
+
+ ${d.rechte.einlagern ? `
＋ Einlagern ` : ""}
+
+
Eingelagert
+
${d.bestand.eingelagert || 0}
+
Ausgegeben
+
${d.bestand.ausgegeben || 0}
+
Zurückgegeben
+
${d.bestand.zurueckgegeben || 0}
+
Vernichtet
+
${d.bestand.vernichtet || 0}
+
+
+ Alle Kategorien
+ ${(d.kategorien || []).map((k) =>
+ `${sicher(k.name)} `).join("")}
+
+
+ Alle Status
+ ${["eingelagert", "ausgegeben", "zurueckgegeben", "vernichtet"].map((s) =>
+ `${statusText[s]} `).join("")}
+
+
+
+
+ ${d.asservate.length ? `
${d.asservate.map((a) => `
+
+
${katSymbol[a.kategorie] || "📦"}
+
+
${sicher(a.bezeichnung)}
+ ${a.menge ? `${sicher(a.menge)} ` : ""}
+
+ ${sicher(a.kennung)} · ${sicher(katName(a.kategorie))} · ${sicher(a.lagerort)}
+ ${a.aktenzeichen ? " · " + sicher(a.aktenzeichen) : ""}
+
+
+ verantwortlich: ${sicher(a.dienstnummer || "")}
+ ${sicher((a.firstname || "") + " " + (a.lastname || ""))} · ${zeit(a.eingelagert_am)}
+
+
+
${sicher(statusText[a.status] || a.status)}
+
`).join("")}
`
+ : `
Keine Asservate gefunden.
`}
+
+
+
${katSymbol[a.kategorie] || "📦"} ${sicher(a.bezeichnung)}
+
${sicher(a.kennung)} · ${sicher(katName(a.kategorie))}
+
+
+ ‹ Zurück
+ ${a.status === "eingelagert" && d.rechte.ausgeben
+ ? `Ausgeben ` : ""}
+ ${a.status === "ausgegeben" && d.rechte.ausgeben
+ ? `Zurücknehmen ` : ""}
+ ${a.status === "eingelagert"
+ ? `Umlagern ` : ""}
+ ${a.status !== "vernichtet" && d.rechte.vernichten
+ ? `Vernichten ` : ""}
+
+
+
+
+ Objekt
+ ${sicher(statusText[a.status] || a.status)}
+
+
+ Kennung ${sicher(a.kennung)}
+ Kategorie ${sicher(katName(a.kategorie))}
+ Menge ${sicher(a.menge || "—")}
+ Lagerort ${sicher(a.lagerort)}
+ Verantwortlich ${sicher(a.dienstnummer || "")}
+ ${sicher((a.firstname || "") + " " + (a.lastname || ""))}
+ Eingelagert ${zeit(a.eingelagert_am)}
+
+
+
+
+
Zuordnung
+
+ ${a.aktenzeichen ? `
+
Akte
+
${sicher(a.akte_titel || "")}
+
${sicher(a.aktenzeichen)}
` : ""}
+ ${a.beweis_kennung ? `
+
Beweis
+
${sicher(a.beweis_bezeichnung || "")}
+
${sicher(a.beweis_kennung)}
` : ""}
+ ${!a.aktenzeichen && !a.beweis_kennung
+ ? `
Keine Zuordnung hinterlegt.
` : ""}
+
+
+
+
+
+ Verwahrkette
+ ${d.historie.length} Schritte
+
+
${d.historie.map((h, i) => `
+
+
${i + 1}
+
+
${sicher(h.aktion)}
+
+ ${sicher(h.dienstnummer || "")}
+ ${sicher((h.firstname || "") + " " + (h.lastname || ""))} · ${zeit(h.am)}
+
+ ${h.notiz ? `
${sicher(h.notiz)}
` : ""}
+
+
`).join("")}
+
+
+ ${sicher(a.kennung)} — ${sicher(a.bezeichnung)}
+ Empfänger
+
+ Grund
+
`,
+ bestaetigenText: "Ausgeben",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("asservat", "ausgeben", {
+ id: a.id,
+ empfaenger: el.querySelector("#aa-empf").value.trim(),
+ grund: el.querySelector("#aa-grund").value.trim(),
+ });
+ zu(); meldung("Ausgegeben.", "gut"); oeffne(behaelter, a.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+
+ const zurueckgeben = $("as-zurueckgeben");
+ if (zurueckgeben) zurueckgeben.addEventListener("click", () => {
+ fenster({
+ titel: "Zurücknehmen",
+ inhalt: `
+ Lagerort
+
+ Vermerk
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Zurücknehmen", klick: async (el, zu) => {
+ try {
+ await aufruf("asservat", "zurueckgeben", {
+ id: a.id,
+ lagerort: el.querySelector("#az-ort").value.trim(),
+ notiz: el.querySelector("#az-notiz").value.trim(),
+ });
+ zu(); meldung("Zurückgenommen.", "gut"); oeffne(behaelter, a.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }},
+ ],
+ });
+ });
+
+ const umlagern = $("as-umlagern");
+ if (umlagern) umlagern.addEventListener("click", () => {
+ fenster({
+ titel: "Umlagern",
+ inhalt: `Neuer Lagerort
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Umlagern", klick: async (el, zu) => {
+ try {
+ await aufruf("asservat", "umlagern", {
+ id: a.id, lagerort: el.querySelector("#au-ort").value.trim(),
+ });
+ zu(); meldung("Umgelagert.", "gut"); oeffne(behaelter, a.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }},
+ ],
+ });
+ });
+
+ const vernichten = $("as-vernichten");
+ if (vernichten) vernichten.addEventListener("click", () => {
+ bestaetigen({
+ titel: "Asservat vernichten",
+ gefahr: true,
+ inhalt: `
+
+
Endgültige Maßnahme
+
+
🔥
+
${sicher(a.kennung)} — ${sicher(a.bezeichnung)} wird als vernichtet
+ gekennzeichnet.
+
+
+
📄
+
Der Datensatz bleibt bestehen — vernichtet wird der Gegenstand,
+ nicht seine Dokumentation. Alle Beamten werden benachrichtigt.
+
+
Zweiter Beamter als Zeuge
+
+ Begründung (ausführlich)
+
`,
+ bestaetigenText: "Vernichtung bestätigen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("asservat", "vernichten", {
+ id: a.id,
+ zeuge: el.querySelector("#av-zeuge").value.trim(),
+ grund: el.querySelector("#av-grund").value.trim(),
+ });
+ zu(); meldung("Vernichtung dokumentiert."); oeffne(behaelter, a.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+ }
+
+ /* ---- Einlagern ---------------------------------------------------- */
+
+ function einlagernDialog(behaelter) {
+ fenster({
+ titel: "Asservat einlagern",
+ inhalt: `
+
+
Kategorie
+
+ ${(z.daten.kategorien || []).map((k) =>
+ `${sicher(k.name)} `).join("")}
+
+
Menge / Umfang
+
+
Bezeichnung
+
+ Lagerort
+
+
+ Vermerk
+
+
+
ℹ
+
Du wirst als verantwortlich eingetragen. Jede weitere Bewegung
+ des Objekts wird in der Verwahrkette festgehalten.
+
Asservate
+
Konnte nicht geladen werden: ${sicher(f.message)}
+
+
Berichte
+
Entwurf → Eingereicht → Freigegeben. Jede Stufe verlangt eine Entscheidung.
+
+ ${d.rechte.erstellen ? `
＋ Bericht anlegen ` : ""}
+
+
+
Meine offenen Entwürfe
+
${d.eigeneOffen}
+
warten auf Ausarbeitung
+
+
+
Zur Prüfung eingereicht
+
${d.zurPruefung}
+
${d.rechte.freigeben ? "warten auf deine Freigabe" : "in Bearbeitung"}
+
+
+
+ Alle Stufen
+ Entwürfe
+ Eingereicht
+ Freigegeben
+
+
+ ${z.nurEigene ? "Alle anzeigen" : "Nur meine"}
+
+
+
+
+ ${d.berichte.length ? `
${d.berichte.map((b) => `
+
+
+
+
${sicher(b.titel)}
+ ${b.eigener ? 'eigener ' : ""}
+
+ ${sicher(b.nummer)}
+ ${b.einsatz_nummer ? " · Einsatz " + sicher(b.einsatz_nummer) : ""}
+ · ${sicher(b.dienstnummer || "")} ${sicher((b.firstname || "") + " " + (b.lastname || ""))}
+ · ${zeit(b.erstellt_am)}
+
+
+
+ ${sicher(statusText[b.status] || b.status)}
+ ${b.unterschriften.length
+ ? `✍ ${b.unterschriften.length} ` : ""}
+
+
`).join("")}
`
+ : `
Keine Berichte gefunden.
`}
+
+
+
${sicher(b.titel)}
+
${sicher(b.nummer)}
+ ${b.einsatz_nummer ? " · Einsatz " + sicher(b.einsatz_nummer) : ""}
+ ${b.aktenzeichen ? " · Akte " + sicher(b.aktenzeichen) : ""}
+
+
+ ‹ Zurück
+ ${bearbeitbar ? `✎ Bearbeiten ` : ""}
+ ${!d.habeUnterschrieben && b.status !== "freigegeben"
+ ? `✍ Unterschreiben ` : ""}
+ ${b.status === "entwurf" && bearbeitbar
+ ? `Einreichen ` : ""}
+ ${b.status === "eingereicht" && d.rechte.freigeben
+ ? `Nachbessern
+ Freigeben ` : ""}
+
+
+ 🔒
+ Dieser Bericht ist freigegeben und damit inhaltlich gesperrt —
+ auch für den Verfasser.
+
` : ""}
+
+
+
+
+ Sachverhalt
+ ${sicher(statusText[b.status] || b.status)}
+
+
+ Verfasser ${sicher(b.dienstnummer || "")}
+ ${sicher((b.firstname || "") + " " + (b.lastname || ""))}
+ Angelegt ${zeit(b.erstellt_am)}
+
+
${b.beschreibung
+ ? sicher(b.beschreibung).replace(/\n/g, "Noch keine Beschreibung erfasst. "}
+
+
Getroffene Maßnahmen
+
${b.massnahmen
+ ? sicher(b.massnahmen).replace(/\n/g, "Keine Maßnahmen dokumentiert. "}
+
+
+
+
+ Beteiligte
+ ${bearbeitbar ? `＋ ` : ""}
+
+ ${b.beteiligte.length ? `
${b.beteiligte.map((p, i) => `
+
+
+ ${p.typ === "beamter" ? (p.dienstnummer || "Beamter") : "Person"}
+
+
${sicher(p.name)}
+ ${p.rolle ? `
${sicher(p.rolle)}
` : ""}
+
+ ${bearbeitbar && p.charakterId !== b.erstellt_von
+ ? `
✕ ` : ""}
+
`).join("")}
`
+ : `
Keine Beteiligten erfasst.
`}
+
+
+
+
+ Anlagen & Beweise
+ ${bearbeitbar ? `＋ ` : ""}
+
+ ${b.anlagen.length ? `
${b.anlagen.map((a, i) => `
+
+
+ ${a.typ === "beweis" ? sicher(a.kennung) : "Anlage"}
+
+
${sicher(a.titel)}
+ ${a.adresse ? `
${sicher(a.adresse)}
` : ""}
+
+ ${a.adresse
+ ? `
Öffnen ` : ""}
+ ${bearbeitbar ? `
✕ ` : ""}
+
`).join("")}
`
+ : `
Keine Anlagen.
`}
+
+
+
+
+ Unterschriften
+ ${b.unterschriften.length}
+
+ ${b.unterschriften.length ? `
${b.unterschriften.map((u) => `
+
+
${sicher(u.name)}
+
${sicher(u.dienstnummer || "")} · ${sicher(u.rolle || "")}
+
${zeit(u.am)}${u.freigabe ? " · Freigabe" : ""}
+
`).join("")}
`
+ : `
Noch nicht unterschrieben.
`}
+
+
ℹ
+
Eine Unterschrift ist verbindlich und wird nicht zurückgenommen.
+ Sie bestätigt, dass der Inhalt aus deiner Sicht zutrifft.
+
+
+
Titel
+
+ Sachverhalt
+
+ Getroffene Maßnahmen
+
+ ${unterschrieben ? `
+
+
⚠ Der Bericht wurde bereits unterschrieben
+
+ Grund der Änderung (erforderlich)
+
+
+
+
✍
+
Du bestätigst, dass der Inhalt von ${sicher(b.nummer)} aus deiner
+ Sicht zutrifft. Die Unterschrift ist verbindlich und kann nicht
+ zurückgenommen werden.
+
+
+ ${sicher(b.nummer)} geht zur Prüfung an die Führung. Bis zur Freigabe
+ kannst du ihn weiterhin ändern — jede Änderung nach dem Unterschreiben wird
+ allerdings vermerkt.
`,
+ bestaetigenText: "Einreichen",
+ bestaetigt: async (_, zu) => {
+ try {
+ await aufruf("bericht", "einreichen", { id: b.id });
+ zu(); meldung("Eingereicht.", "gut"); oeffne(behaelter, b.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+
+ const freigeben = $("br-freigeben");
+ if (freigeben) freigeben.addEventListener("click", () => {
+ bestaetigen({
+ titel: "Bericht freigeben",
+ inhalt: `
+
+
Mit der Freigabe geschieht Folgendes:
+
+
🔒
+
Der Bericht wird inhaltlich gesperrt — auch der Verfasser kann
+ ihn danach nicht mehr ändern.
+
+
+
✍
+
Du unterschreibst den Bericht damit zugleich als freigebender Beamter.
+
+
Vermerk
+
`,
+ bestaetigenText: "Freigeben",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("bericht", "freigeben", {
+ id: b.id, vermerk: el.querySelector("#bf-vermerk").value.trim(),
+ });
+ zu(); meldung("Freigegeben.", "gut"); oeffne(behaelter, b.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+
+ const zurueckweisen = $("br-zurueckweisen");
+ if (zurueckweisen) zurueckweisen.addEventListener("click", () => {
+ fenster({
+ titel: "Zur Nachbesserung zurückgeben",
+ inhalt: `Was soll nachgebessert werden?
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Zurückweisen", art: "gefahr", klick: async (el, zu) => {
+ try {
+ await aufruf("bericht", "zurueckweisen", {
+ id: b.id, grund: el.querySelector("#bz-grund").value.trim(),
+ });
+ zu(); meldung("Zurückgewiesen."); oeffne(behaelter, b.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }},
+ ],
+ });
+ });
+ }
+
+ /* ---- Dialoge ------------------------------------------------------ */
+
+ function anlegenDialog(behaelter) {
+ aufruf("bericht", "bezuege", {}).then((bez) => {
+ fenster({
+ titel: "Bericht anlegen",
+ inhalt: `
+ Titel
+
+ Bezug zu einem Einsatz
+
+ — ohne Einsatzbezug —
+ ${(bez.einsaetze || []).map((e) =>
+ `${sicher(e.nummer)} · ${sicher(e.titel)} `).join("")}
+
+ Sachverhalt
+
+ Getroffene Maßnahmen
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Anlegen", klick: async (el, zu) => {
+ try {
+ const ergebnis = await aufruf("bericht", "erstellen", {
+ titel: el.querySelector("#bn-titel").value.trim(),
+ einsatz: +el.querySelector("#bn-einsatz").value || null,
+ beschreibung: el.querySelector("#bn-text").value,
+ massnahmen: el.querySelector("#bn-mass").value,
+ });
+ zu(); meldung("Bericht " + ergebnis.nummer + " angelegt.", "gut");
+ oeffne(behaelter, ergebnis.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }},
+ ],
+ });
+ }).catch((f) => meldung(f.message, "fehler"));
+ }
+
+ function beteiligtDialog(behaelter, berichtId) {
+ fenster({
+ titel: "Beteiligten hinzufügen",
+ inhalt: `
+ Art
+
+ Person (Zivilist)
+ Beamter
+
+
+
Suchen
+
+ Suchen
+
+
Oder unten einen Namen frei eintragen.
+
+ Name (frei)
+
+ Beteiligung
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Hinzufügen", klick: async (el, zu) => {
+ try {
+ await aufruf("bericht", "beteiligtHinzu", {
+ id: berichtId,
+ typ: el.querySelector("#bb-typ").value,
+ name: el.querySelector("#bb-name").value.trim(),
+ rolle: el.querySelector("#bb-rolle").value.trim(),
+ charakterId: el.dataset.gewaehlt ? +el.dataset.gewaehlt : null,
+ });
+ zu(); oeffne(behaelter, berichtId);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }},
+ ],
+ nachOeffnen: (el) => {
+ const suchen = async () => {
+ const begriff = el.querySelector("#bb-suche").value.trim();
+ if (begriff.length < 2) { meldung("Bitte mindestens zwei Zeichen.", "fehler"); return; }
+ try {
+ const d = await aufruf("mdt", "personSuchen", { begriff });
+ const ziel = el.querySelector("#bb-treffer");
+ ziel.innerHTML = (d.treffer || []).length
+ ? `${d.treffer.slice(0, 6).map((p) =>
+ `
+
${sicher(p.firstname + " " + p.lastname)}
+
geb. ${sicher(String(p.dob || "").slice(0, 10))}
+
`).join("")}
Keine Treffer.
`;
+
+ ziel.querySelectorAll("[data-wahl]").forEach((zeile) =>
+ zeile.addEventListener("click", () => {
+ el.dataset.gewaehlt = zeile.dataset.wahl;
+ el.querySelector("#bb-name").value = zeile.dataset.name;
+ ziel.innerHTML = `Ausgewählt: ${sicher(zeile.dataset.name)}
`;
+ }));
+ } catch (f) { meldung(f.message, "fehler"); }
+ };
+ el.querySelector("#bb-suchen").addEventListener("click", suchen);
+ el.querySelector("#bb-suche").addEventListener("keydown", (e) => {
+ if (e.key === "Enter") { e.preventDefault(); suchen(); }
+ });
+ },
+ });
+ }
+
+ function anlageDialog(behaelter, berichtId) {
+ fenster({
+ titel: "Anlage hinzufügen",
+ inhalt: `
+ Art
+
+ Datei / Bild
+ Vorhandenes Beweismittel
+
+
+
+
+
+
+
Beweismittel suchen
+
+ Suchen
+
+
+
+
${d.beweise.map((b) =>
+ `
+
${sicher(b.kennung)}
+
${sicher(b.bezeichnung)}
+
${sicher(b.fundort || "")}
+
`).join("")}
Keine Treffer.
`;
+
+ ziel.querySelectorAll("[data-wahl]").forEach((zeile) =>
+ zeile.addEventListener("click", () => {
+ el.dataset.beweis = zeile.dataset.wahl;
+ ziel.innerHTML = `Ausgewählt.
`;
+ }));
+ } catch (f) { meldung(f.message, "fehler"); }
+ };
+ el.querySelector("#ba-suchen").addEventListener("click", suchen);
+ },
+ });
+ }
+
+ /* ---- Laden -------------------------------------------------------- */
+
+ async function oeffne(behaelter, berichtId) {
+ try {
+ const d = await aufruf("bericht", "oeffnen", { id: berichtId });
+ z.offen = berichtId;
+ einzelAnsicht(behaelter, d);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("bericht", "liste", {
+ status: z.filterStatus, nurEigene: z.nurEigene, begriff: z.suche,
+ });
+ if (z.offen) await oeffne(behaelter, z.offen);
+ else uebersicht(behaelter);
+ } catch (f) {
+ behaelter.innerHTML = `Berichte
+
Konnte nicht geladen werden: ${sicher(f.message)}
+
+
Beweismittel
+
Jeder Beweis wird von einem Beamten erfasst — es gibt keine automatische Spurenerkennung.
+
+ ${d.rechte.erfassen ? `
＋ Beweis erfassen ` : ""}
+
+
+ Alle Arten
+ ${(d.arten || []).map((a) =>
+ `${sicher(a.name)} `).join("")}
+
+
+
+
+ ${d.beweise.length ? `
${d.beweise.map((b) => `
+
+
${artSymbol[b.art] || "•"}
+
+
${sicher(b.bezeichnung)}
+
+ ${sicher(b.kennung)} · ${sicher(artName(b.art))}
+ ${b.fundort ? " · Fundort: " + sicher(b.fundort) : ""}
+ ${b.aktenzeichen ? " · " + sicher(b.aktenzeichen) : ""}
+
+
+ erfasst von ${sicher(b.dienstnummer || "")}
+ ${sicher((b.firstname || "") + " " + (b.lastname || ""))} · ${zeit(b.erfasst_am)}
+
+
+ ${b.datei ? '
Anlage ' : ""}
+
`).join("")}
`
+ : `
Keine Beweismittel gefunden.
`}
+
+
+
${artSymbol[b.art] || "•"} ${sicher(b.bezeichnung)}
+
${sicher(b.kennung)} · ${sicher(artName(b.art))}
+
+
+ ‹ Zurück
+ ✎ Ändern
+ ${d.rechte.loeschen ? `Entfernen ` : ""}
+
+
+
+
Beweismittel
+
+ Kennung ${sicher(b.kennung)}
+ Art ${sicher(artName(b.art))}
+ Fundort ${sicher(b.fundort || "—")}
+ Aufgefunden ${zeit(b.gefunden_am)}
+ Erfasst von ${sicher(b.dienstnummer || "")}
+ ${sicher((b.firstname || "") + " " + (b.lastname || ""))}
+ Erfasst am ${zeit(b.erfasst_am)}
+
+ ${b.beschreibung
+ ? `
${sicher(b.beschreibung).replace(/\n/g, "
`
+ : ""}
+ ${b.datei ? `
` : ""}
+
+
+
+
+ Verknüpfte Akten
+ ＋ Akte
+
+ ${d.akten.length ? `
${d.akten.map((a) => `
+
+
${sicher(a.typ)}
+
+
${sicher(a.titel)}
+
${sicher(a.aktenzeichen)}
+
+
${sicher(a.status)}
+
`).join("")}
`
+ : `
Noch keiner Akte zugeordnet.
`}
+
+
+
+
Zugehörige Asservate
+ ${d.asservate.length ? `
${d.asservate.map((a) => `
+
+
${sicher(a.kennung)}
+
+
${sicher(a.bezeichnung)}
+
${sicher(a.lagerort)}
+
+
${sicher(a.status)}
+
`).join("")}
`
+ : `
Keine Asservate hinterlegt.
`}
+
+
+
+
Vorgangshistorie
+ ${d.historie.length ? `
${d.historie.map((h) => `
+
+
+
${sicher(h.aktion)}
+
${sicher(h.dienstnummer || "")}
+ ${sicher((h.firstname || "") + " " + (h.lastname || ""))} · ${zeit(h.am)}
+ ${h.grund ? " · " + sicher(h.grund) : ""}
+
+
`).join("")}
`
+ : `
Keine Einträge.
`}
+
+
Bezeichnung
+
+ Fundort
+
+ Beschreibung
+
+ Anlage (Adresse)
+
+ Grund der Änderung (erforderlich)
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Speichern", klick: async (el, zu) => {
+ try {
+ await aufruf("beweis", "bearbeiten", {
+ id: b.id,
+ bezeichnung: el.querySelector("#be-bez").value.trim(),
+ fundort: el.querySelector("#be-ort").value.trim(),
+ beschreibung: el.querySelector("#be-text").value,
+ datei: el.querySelector("#be-datei").value.trim(),
+ grund: el.querySelector("#be-grund").value.trim(),
+ });
+ zu(); meldung("Gespeichert.", "gut"); oeffne(behaelter, b.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }},
+ ],
+ });
+ });
+
+ const entfernen = $("bw-entfernen");
+ if (entfernen) entfernen.addEventListener("click", () => {
+ bestaetigen({
+ titel: "Beweismittel entfernen",
+ gefahr: true,
+ inhalt: `
+
+
+
⚠
+
Der Beweis ${sicher(b.kennung)} wird aus dem Bestand entfernt.
+ Der Vorgang bleibt im Protokoll sichtbar und alle Beamten werden benachrichtigt.
+
+
+ Begründung (ausführlich, erforderlich)
+
+
`,
+ bestaetigenText: "Entfernen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("beweis", "entfernen", {
+ id: b.id, grund: el.querySelector("#bl-grund").value.trim(),
+ });
+ zu(); meldung("Beweis entfernt."); z.offen = null; rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+
+ $("bw-akte").addEventListener("click", () => akteVerknuepfenDialog(behaelter, b.id));
+ }
+
+ /* ---- Dialoge ------------------------------------------------------ */
+
+ function erfassenDialog(behaelter) {
+ const arten = (z.daten.arten || []);
+
+ fenster({
+ titel: "Beweis erfassen",
+ inhalt: `
+
+
Art
+
+ ${arten.map((a) => `${sicher(a.name)} `).join("")}
+
+
Fundort
+
+
Bezeichnung
+
+ Beschreibung
+
+ Anlage (Bild-/Videoadresse)
+
+
+
ℹ
+
Der Fundort ist Pflicht — er gehört zur Beweiskette. Das System
+ erkennt keine Spuren; alles hier ist deine Dokumentation.
+
+
Akte suchen
+
+ Suchen
+
+
`,
+ nachOeffnen: (el) => {
+ const suchen = async () => {
+ const begriff = el.querySelector("#bv-suche").value.trim();
+ if (begriff.length < 2) { meldung("Bitte mindestens zwei Zeichen.", "fehler"); return; }
+ try {
+ const d = await aufruf("beweis", "aktenSuche", { begriff });
+ const ziel = el.querySelector("#bv-treffer");
+ ziel.innerHTML = (d.akten || []).length
+ ? `${d.akten.map((a) =>
+ `
+
${sicher(a.typ)}
+
${sicher(a.titel)}
+
${sicher(a.aktenzeichen)}
+
`).join("")}
Keine Treffer.
`;
+
+ ziel.querySelectorAll("[data-wahl]").forEach((zeile) =>
+ zeile.addEventListener("click", async () => {
+ try {
+ await aufruf("beweis", "akteVerknuepfen", {
+ beweisId, akteId: +zeile.dataset.wahl,
+ });
+ el.remove(); meldung("Verknüpft.", "gut"); oeffne(behaelter, beweisId);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }));
+ } catch (f) { meldung(f.message, "fehler"); }
+ };
+ el.querySelector("#bv-suchen").addEventListener("click", suchen);
+ el.querySelector("#bv-suche").addEventListener("keydown", (e) => {
+ if (e.key === "Enter") { e.preventDefault(); suchen(); }
+ });
+ },
+ });
+ }
+
+ /* ---- Laden -------------------------------------------------------- */
+
+ async function oeffne(behaelter, beweisId) {
+ try {
+ const d = await aufruf("beweis", "oeffnen", { id: beweisId });
+ z.offen = beweisId;
+ einzelAnsicht(behaelter, d);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("beweis", "liste", { art: z.filterArt, begriff: z.suche });
+ if (z.offen) await oeffne(behaelter, z.offen);
+ else uebersicht(behaelter);
+ } catch (f) {
+ behaelter.innerHTML = `Beweise
+
Konnte nicht geladen werden: ${sicher(f.message)}
+
${sicher(titel)}
+
${sicher(wert)}
+ ${zusatz ? `
${sicher(zusatz)}
` : ""}
+
+ ${symbol[w.prioritaet] || "•"}
+ ${sicher(w.text)}
+
`
+ ).join("");
+ }
+
+ function beamtenListe(beamte) {
+ if (!beamte.length) return `Niemand im Dienst.
`;
+
+ const statusFarbe = {
+ verfuegbar: "gut", einsatz: "warn", pause: "neutral", nicht: "kritisch",
+ };
+
+ return `${beamte.map((b) =>
+ `
+
${sicher(b.dienstnummer)}
+
+
${sicher(b.name)}${b.leitstelle ? ' Leitstelle ' : ""}
+
${sicher(b.rolleName)} · ${sicher(b.abteilung)}
+
+
${dauer((Date.now() / 1000) - b.seit)}
+
`).join("")}
Keine offenen Einsätze.
`;
+
+ return `${einsaetze.map((e) =>
+ `
+
+
+
${sicher(e.titel)}
+
${sicher(e.nummer)} · ${sicher(e.ort || "Ort unbekannt")} · ${zeit(e.erstellt_am)}
+
+
${sicher(e.status)}
+ ${e.pos_x ? `
Route ` : ""}
+
`).join("")}
Niemand in Gewahrsam.
`;
+
+ return `${eintraege.map((g) => {
+ const rest = Number(g.rest) || 0;
+ const abgelaufen = rest <= 0;
+ return `
+
+
+
${sicher(g.firstname + " " + g.lastname)}
+
${sicher(g.grund || "—")}${g.zelle ? " · Zelle " + sicher(g.zelle) : ""}
+
+
+ ${abgelaufen ? "Frist abgelaufen" : rest + " Min"}
+
+
`;
+ }).join("")}
Keine aktiven Fahndungen.
`;
+
+ const gefahrKlasse = { gefaehrlich: "kritisch", bewaffnet: "warn", normal: "neutral" };
+
+ return `${fahndungen.map((f) =>
+ `
+
+
+
${sicher(f.bezeichnung)}
+
${sicher(f.grund)}
+
+
${sicher(f.gefahr)}
+
`).join("")}
Keine Mitteilungen.
`;
+
+ return `${mitteilungen.map((m) =>
+ `
+
+
${sicher(m.betreff || "Mitteilung")}
+
${sicher((m.firstname || "") + " " + (m.lastname || ""))} · ${zeit(m.gesendet)}
+
+
`).join("")}
+
+
Übersicht
+
Lage der Dienststelle — Stand ${new Date().toLocaleTimeString("de-DE", { hour: "2-digit", minute: "2-digit" })}
+
+
↻ Aktualisieren
+
+ ${kennzahl("Im Dienst", k.imDienst, `${k.verfuegbar} verfügbar`, k.imDienst > 0 ? "gut" : "")}
+ ${kennzahl("Offene Einsätze", k.einsaetzeOffen, null, k.einsaetzeOffen > 0 ? "warn" : "")}
+ ${kennzahl("Anzeigen (Entwurf)", k.anzeigenOffen, "warten auf Bestätigung")}
+ ${kennzahl("Fahndungen", k.fahndungen)}
+ ${kennzahl("In Gewahrsam", k.gefangene,
+ k.haftAbgelaufen > 0 ? `${k.haftAbgelaufen} Frist abgelaufen` : null,
+ k.haftAbgelaufen > 0 ? "hoch" : "")}
+ ${kennzahl("Dienstfahrzeuge", `${k.fahrzeugeEinsatz}/${k.fahrzeugeGesamt}`, "im Einsatz")}
+
+
+
+
+
+ Offene Einsätze
+ ${d.einsaetze.length}
+
+ ${einsatzListe(d.einsaetze)}
+
+
+
+
+ Beamte im Dienst
+ ${d.beamte.length}
+
+ ${beamtenListe(d.beamte)}
+
+
+
+
+ Gewahrsam
+ ${d.gewahrsam.length}
+
+ ${gewahrsamListe(d.gewahrsam)}
+
+
ℹ
+
Fristen dienen nur der Erinnerung . Eine Entlassung erfolgt
+ ausschließlich manuell durch einen Beamten.
+
+
+
+
+
+ Aktive Fahndungen
+ ${d.fahndungen.length}
+
+ ${fahndungsListe(d.fahndungen)}
+
+
+
+
+ Meine offenen Berichte
+ ${d.berichte.length}
+
+ ${d.berichte.length
+ ? `
${d.berichte.map((b) =>
+ `
+
+
${sicher(b.titel)}
+
${sicher(b.nummer)} · ${zeit(b.erstellt_am)}
+
+
Entwurf
+
`).join("")}
`
+ : `
Keine offenen Berichte.
`}
+
+
+
+
Neueste Mitteilungen
+ ${mitteilungsListe(d.mitteilungen)}
+
+
Übersicht
+
Die Daten konnten nicht geladen werden: ${sicher(fehler.message)}
+
+
+
+ ${sicher(e.titel)}
+ ${e.ichDabei > 0 ? 'Du bist dabei ' : ""}
+
+
+
+ ${sicher(kategorieName(e.kategorie))}
+
+ ${sicher(e.nummer)} · ${sicher(e.ort || "Ort unbekannt")} · ${zeit(e.erstellt_am)}
+ ${e.quelle !== "manuell" ? " · " + sicher(quelleText[e.quelle] || e.quelle) : ""}
+
+
+
+ ${sicher(statusText[e.status] || e.status)}
+ ${e.einheiten || 0} 🚓
+
+
Niemand im Dienst.
`;
+
+ const farbe = { verfuegbar: "gut", einsatz: "warn", pause: "neutral", nicht: "kritisch" };
+ const text = { verfuegbar: "Verfügbar", einsatz: "Im Einsatz", pause: "Pause", nicht: "Nicht verfügbar" };
+
+ return `${beamte.map((b) =>
+ `
+
${sicher(b.dienstnummer)}
+
+
${sicher(b.name)}
+ ${b.leitstelle ? 'Leitstelle ' : ""}
+
${sicher(text[b.status] || b.status)} · ${sicher(b.abteilung)}
+
+
`).join("")}
+
+
Einsätze & Dispatch
+
${d.istLeitstelle
+ ? "Du führst die Leitstelle — du entscheidest über die Zuweisung."
+ : "Einsätze werden nicht automatisch verteilt. Tritt bei, wenn du übernimmst."}
+
+
+
+ ${z.nurOffene ? "Auch abgeschlossene" : "Nur laufende"}
+
+ ＋ Einsatz anlegen
+
+
+
+
+
+ Offen — keine Einheit zugeordnet
+ ${offene.length}
+
+ ${offene.length ? offene.map(einsatzKarte).join("")
+ : `
Keine offenen Einsätze.
`}
+
+
+
+
+ In Bearbeitung
+ ${laufende.length}
+
+ ${laufende.length ? laufende.map(einsatzKarte).join("")
+ : `
Keine laufenden Einsätze.
`}
+
+
+ ${!z.nurOffene ? `
+
+
+ Abgeschlossen
+ ${erledigt.length}
+
+ ${erledigt.length ? erledigt.map(einsatzKarte).join("")
+ : `
Nichts abgeschlossen.
`}
+
` : ""}
+
+
+
+
+
+ Einheiten im Dienst
+ ${d.beamteImDienst.length}
+
+ ${einheitenListe(d.beamteImDienst)}
+
+
ℹ
+
Eine Zuweisung ist eine Aufforderung , kein Befehl an das System.
+ Die Einheit entscheidet selbst, ob sie den Einsatz übernimmt.
+
+
+
+
+
+
${sicher(e.titel)}
+
${sicher(e.nummer)} · ${sicher(kategorieName(e.kategorie))} ·
+ ${sicher(quelleText[e.quelle] || e.quelle)} · ${zeit(e.erstellt_am)}
+
+
‹ Zurück
+
+
+
+
+ Lage
+ ${sicher(statusText[e.status] || e.status)}
+
+
+ Priorität ${sicher(e.prioritaet)} ${e.prioritaet === 1 ? "(höchste)" : ""}
+ Ort ${sicher(e.ort || "unbekannt")}
+ Gemeldet von ${e.erstellt_von
+ ? sicher((e.ersteller_vorname || "") + " " + (e.ersteller_nachname || ""))
+ : sicher(quelleText[e.quelle] || "extern")}
+
+ ${e.beschreibung ? `
${sicher(e.beschreibung).replace(/\n/g, "
` : ""}
+
+
+ ${e.pos_x ? `📍 Route setzen ` : ""}
+ ${aktiv && !e.ichDabei ? `Einsatz übernehmen ` : ""}
+ ${aktiv && e.ichDabei ? `Einsatz verlassen ` : ""}
+ ${aktiv && e.ichDabei ? `Status: Vor Ort ` : ""}
+ ${aktiv && d.rechte.schliessen ? `Abschließen ` : ""}
+
+
+
+
+
+ Einsatzverlauf
+ ${aktiv ? `＋ Notiz ` : ""}
+
+ ${(e.notizen || []).length ? `
${e.notizen.map((n) =>
+ `
+
${zeit(n.am).slice(-5)}
+
+
${sicher(n.text)}
+
${sicher(n.dienstnummer || "")}
+ ${sicher((n.firstname || "") + " " + (n.lastname || ""))}
+
+
`).join("")}
`
+ : `
Noch keine Einträge.
`}
+
+
+
+
+
+
+ Beteiligte Einheiten
+ ${beteiligt.length}
+
+ ${beteiligt.length ? `
${beteiligt.map((b) =>
+ `
+
${sicher(b.dienstnummer || "—")}
+
+
${sicher((b.firstname || "") + " " + (b.lastname || ""))}
+
seit ${zeit(b.beigetreten)}
+
+
`).join("")}
`
+ : `
Keine Einheit vor Ort.
`}
+
+
+ ${aktiv && d.rechte.zuweisen ? `
+
+
Einheit anfordern
+
${d.beamteImDienst.map((b) =>
+ `
+
${sicher(b.dienstnummer)}
+
+
${sicher(b.name)}
+
${sicher(b.status)}
+
+
Anfordern
+
`).join("")}
+
+
ℹ
+
Die Einheit erhält eine Anfrage mit Wegpunkt. Ob sie übernimmt,
+ entscheidet sie selbst.
+
+
` : ""}
+
+
Eintrag
+
+
Der Verlauf hilft später beim Bericht.
+ ${sicher(e.nummer)} — ${sicher(e.titel)}
+ Abschlussvermerk
+
+ ${d.rechte.bericht ? `
+
+ Berichtsentwurf vorbereiten — Titel, Beteiligte und der Einsatzverlauf
+ werden übernommen. Der Bericht bleibt ein Entwurf , bis du ihn ausarbeitest.
+ ` : ""}`,
+ bestaetigenText: "Einsatz abschließen",
+ bestaetigt: async (el, zu) => {
+ const kasten = el.querySelector("#es-bericht");
+ try {
+ const ergebnis = await aufruf("einsatz", "abschliessen", {
+ id: e.id,
+ grund: el.querySelector("#es-grund").value.trim(),
+ berichtAnlegen: kasten ? kasten.checked : false,
+ });
+ zu();
+ meldung(ergebnis.berichtNummer
+ ? "Einsatz abgeschlossen · Entwurf " + ergebnis.berichtNummer + " angelegt."
+ : "Einsatz abgeschlossen.", "gut");
+ z.offenerEinsatz = null;
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+ }
+
+ async function oeffneEinsatz(behaelter, einsatzId) {
+ try {
+ const d = await aufruf("einsatz", "oeffnen", { id: einsatzId });
+ z.offenerEinsatz = einsatzId;
+ // Kategorien für die Anzeige mitführen
+ if (!z.daten) z.daten = { kategorien: [] };
+ d.kategorien = z.daten.kategorien;
+ einsatzAnsicht(behaelter, d);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ /* ---- Anlegen ------------------------------------------------------ */
+
+ function einsatzAnlegen(behaelter) {
+ const kategorien = (z.daten && z.daten.kategorien) || [];
+
+ fenster({
+ titel: "Einsatz anlegen",
+ inhalt: `
+ Titel
+
+ Kategorie
+
+ ${kategorien.map((k) => `${sicher(k.name)} `).join("")}
+
+ Priorität
+
+ 1 — höchste (sofort)
+ 2 — hoch
+ 3 — normal
+ 4 — niedrig
+
+ Ort
+
+ Beschreibung
+
+
+ Meine aktuelle Position als Einsatzort übernehmen
+ `,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Einsatz anlegen", klick: async (el, zu) => {
+ try {
+ const ergebnis = await aufruf("einsatz", "erstellen", {
+ titel: el.querySelector("#ne-titel").value.trim(),
+ kategorie: el.querySelector("#ne-kategorie").value,
+ prioritaet: +el.querySelector("#ne-prio").value,
+ ort: el.querySelector("#ne-ort").value.trim(),
+ beschreibung: el.querySelector("#ne-text").value,
+ eigenePosition: el.querySelector("#ne-hier").checked,
+ });
+ zu();
+ meldung("Einsatz " + ergebnis.nummer + " angelegt.", "gut");
+ oeffneEinsatz(behaelter, ergebnis.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }},
+ ],
+ });
+ }
+
+ /* ---- Laden -------------------------------------------------------- */
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("einsatz", "liste", { nurOffene: z.nurOffene });
+
+ // Markierungen im Spiel setzen
+ anClient("einsatzBlips", { einsaetze: z.daten.einsaetze });
+
+ if (z.offenerEinsatz) await oeffneEinsatz(behaelter, z.offenerEinsatz);
+ else uebersicht(behaelter);
+ } catch (f) {
+ behaelter.innerHTML =
+ `Einsätze
+
Konnte nicht geladen werden: ${sicher(f.message)}
+ ${sicher(d.von)} bittet dich um Übernahme:${sicher(d.nummer)} — ${sicher(d.titel)}
`,
+ bestaetigenText: "Übernehmen",
+ bestaetigt: async (_, zu) => {
+ try {
+ await aufruf("einsatz", "beitreten", { id: d.id });
+ zu(); meldung("Einsatz übernommen.", "gut");
+ if (App.zustand.aktivesModul === "einsatz") rendern($("inhalt"));
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ // Im Hintergrund hat sich etwas geändert
+ if (n.aktion === "einsatzAenderung" && App.zustand.aktivesModul === "einsatz") {
+ rendern($("inhalt"));
+ }
+ });
+
+ /* ---- Registrierung ------------------------------------------------ */
+
+ App.registriereAnsicht("einsatz", {
+ rendern,
+ aktualisieren: () => {
+ if (App.zustand.aktivesModul === "einsatz") rendern($("inhalt"));
+ },
+ });
+})();
diff --git a/resources/[aether]/aether-police/html/js/module/fahndung.js b/resources/[aether]/aether-police/html/js/module/fahndung.js
new file mode 100644
index 0000000..aad294e
--- /dev/null
+++ b/resources/[aether]/aether-police/html/js/module/fahndung.js
@@ -0,0 +1,458 @@
+/* =====================================================================
+ aether-police / Ansicht: Fahndungen
+
+ Fahndungen werden von Beamten ausgeschrieben und von Beamten
+ aufgehoben. Nichts davon geschieht von selbst.
+===================================================================== */
+"use strict";
+
+(() => {
+ const { sicher, zeit, aufruf, meldung, fenster, bestaetigen, $, anClient } = App;
+
+ const z = {
+ daten: null,
+ offen: null,
+ filterTyp: "",
+ filterGefahr: "",
+ archiv: false,
+ suche: "",
+ };
+
+ const gefahrArt = { normal: "neutral", bewaffnet: "warn", gefaehrlich: "kritisch" };
+ const gefahrText = { normal: "Normal", bewaffnet: "Bewaffnet", gefaehrlich: "Gefährlich" };
+ const prioText = { 1: "Sofort", 2: "Hoch", 3: "Normal", 4: "Niedrig" };
+
+ /* ---- Übersicht ---------------------------------------------------- */
+
+ function fahndungKarte(f) {
+ return `
+
+
+ ${f.bild ? `
`
+ : `
${f.typ === "person" ? "👤" : "🚗"} `}
+
+
+
${sicher(f.bezeichnung)}
+
${sicher(f.grund)}
+
+ ${sicher(f.dienstnummer || "")} ${sicher((f.firstname || "") + " " + (f.lastname || ""))}
+ · ${zeit(f.erstellt_am)}
+ ${!f.aktiv && f.aufgehoben_am
+ ? ` · aufgehoben ${zeit(f.aufgehoben_am)} durch
+ ${sicher((f.a_vorname || "") + " " + (f.a_nachname || ""))}` : ""}
+
+
+
+ ${sicher(gefahrText[f.gefahr] || f.gefahr)}
+ Prio ${sicher(prioText[f.prioritaet] || f.prioritaet)}
+
+
+
+
Fahndungen
+
Werden von Beamten ausgeschrieben — und nur von Beamten wieder aufgehoben.
+
+ ${d.rechte.erstellen ? `
＋ Fahndung ausschreiben ` : ""}
+
+
Normal
+
${d.bestand.normal || 0}
+
Bewaffnet
+
${d.bestand.bewaffnet || 0}
+
Gefährlich
+
${d.bestand.gefaehrlich || 0}
+
+
+ Alle Arten
+ Personen
+ Fahrzeuge
+
+
+ Alle Stufen
+ Normal
+ Bewaffnet
+ Gefährlich
+
+
+ ${z.archiv ? "Aktive zeigen" : "Archiv"}
+
+
+
+
+ ${d.fahndungen.length
+ ? `
${d.fahndungen.map(fahndungKarte).join("")}
`
+ : `
${z.archiv ? "Keine aufgehobenen Fahndungen." : "Keine aktiven Fahndungen."}
`}
+
+
+
${f.typ === "person" ? "👤" : "🚗"} ${sicher(f.bezeichnung)}
+
Fahndung #${f.id} · ${sicher(gefahrText[f.gefahr] || f.gefahr)}
+ · Priorität ${sicher(prioText[f.prioritaet] || f.prioritaet)}
+
+
+ ‹ Zurück
+ ${aktiv && d.rechte.bearbeiten
+ ? `✎ Bearbeiten ` : ""}
+ ${aktiv && d.rechte.aufheben
+ ? `Fahndung aufheben ` : ""}
+
+
+ ✓
+ Diese Fahndung wurde am ${zeit(f.aufgehoben_am)} von
+ ${sicher((f.a_vorname || "") + " " + (f.a_nachname || ""))} aufgehoben.
+
`
+ : f.gefahr !== "normal" ? `
+
+ ⚠
+ Gefahrenstufe ${sicher(gefahrText[f.gefahr])}.
+ ${f.gefahr === "gefaehrlich"
+ ? "Zugriff nur mit ausreichender Verstärkung."
+ : "Es ist mit Bewaffnung zu rechnen."}
` : ""}
+
+
+
+
Fahndungsgrund
+
${sicher(f.grund).replace(/\n/g, "
+
+ ${f.hinweise ? `
+
Hinweise für die Streife
+
${sicher(f.hinweise).replace(/\n/g, "
+ ` : ""}
+
+
+ Ausgeschrieben ${sicher(f.dienstnummer || "")}
+ ${sicher((f.firstname || "") + " " + (f.lastname || ""))}
+ Am ${zeit(f.erstellt_am)}
+
+
+
+
+
+ ${f.typ === "person" ? "Gesuchte Person" : "Gesuchtes Fahrzeug"}
+ ${ziel && f.typ === "person"
+ ? `Akte öffnen ` : ""}
+ ${ziel && f.typ === "fahrzeug"
+ ? `Halterdaten ` : ""}
+
+
+ ${!ziel ? `
Das Ziel ist nicht mehr im System auffindbar.
`
+ : f.typ === "person" ? `
+
+
+ ${ziel.lichtbild ? `
`
+ : `
Kein Lichtbild `}
+
+
+ Name ${sicher(ziel.firstname + " " + ziel.lastname)}
+ Geboren ${sicher(String(ziel.dob || "").slice(0, 10))}
+ Warnhinweis ${sicher(ziel.warnhinweis || "—")}
+
+
`
+ : `
+ Kennzeichen ${sicher(ziel.plate)}
+ Modell ${sicher(ziel.name || ziel.model)}
+ Farbe ${ziel.farbe
+ ? `
+ Halter ${sicher((ziel.firstname || "unbekannt") + " " + (ziel.lastname || ""))}
+ Status ${sicher(ziel.state === "impound" ? "sichergestellt"
+ : ziel.state === "out" ? "unterwegs" : "eingeparkt")}
+
`}
+
+
+ ${f.bild ? `
+
+
Fahndungsbild
+
+
` : ""}
+
+
+
Vorgangshistorie
+ ${d.historie.length ? `
${d.historie.map((h) => `
+
+
+
${sicher(h.aktion)}
+
${sicher(h.dienstnummer || "")}
+ ${sicher((h.firstname || "") + " " + (h.lastname || ""))} · ${zeit(h.am)}
+ ${h.grund ? " · " + sicher(h.grund) : ""}
+
+
`).join("")}
`
+ : `
Keine Einträge.
`}
+
+
+ ${sicher(f.bezeichnung)}
+
+
+
📄
+
Die Fahndung wandert ins Archiv und bleibt dort nachvollziehbar.
+ Es wird festgehalten, dass du sie aufgehoben hast.
+
+
+ Grund der Aufhebung
+
`,
+ bestaetigenText: "Fahndung aufheben",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("fahndung", "aufheben", {
+ id: f.id, grund: el.querySelector("#fh-grund").value.trim(),
+ });
+ zu(); meldung("Fahndung aufgehoben.", "gut"); z.offen = null; rendern(behaelter);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ },
+ });
+ });
+ }
+
+ /* ---- Dialoge ------------------------------------------------------ */
+
+ function ausschreibenDialog(behaelter) {
+ let gewaehlt = null;
+
+ fenster({
+ titel: "Fahndung ausschreiben",
+ inhalt: `
+ Art der Fahndung
+
+ Person
+ Fahrzeug
+
+
+
+
Ziel suchen
+
+ Suchen
+
+
Noch kein Ziel ausgewählt.
+
+
Gefahrenstufe
+
+ Normal
+ Bewaffnet
+ Gefährlich
+
+
Priorität
+
+ 1 — Sofort
+ 2 — Hoch
+ 3 — Normal
+ 4 — Niedrig
+
+
Fahndungsgrund
+
+ Hinweise für die Streife
+
+ Fahndungsbild (Adresse)
+
+
+
+
ℹ
+
Die Gefahrenstufe bestimmt, wie dringlich alle Beamten benachrichtigt werden.
+ Bei gefährlich geht ein kritischer Hinweis an alle im Dienst.
+
${d.treffer.slice(0, 6).map((t) =>
+ `
+
${sicher(t.titel)}
+
${sicher(t.unter)}
+
`).join("")}
Keine Treffer.
`;
+
+ anzeige.querySelectorAll("[data-wahl]").forEach((zeile) =>
+ zeile.addEventListener("click", () => {
+ gewaehlt = zeile.dataset.wahl;
+ anzeige.innerHTML = `Ausgewählt: ${sicher(zeile.dataset.titel)} `;
+ }));
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ };
+
+ el.querySelector("#fn-suchen").addEventListener("click", suchen);
+ el.querySelector("#fn-suche").addEventListener("keydown", (e) => {
+ if (e.key === "Enter") { e.preventDefault(); suchen(); }
+ });
+ // Bei Wechsel der Art die Auswahl verwerfen
+ el.querySelector("#fn-typ").addEventListener("change", () => {
+ gewaehlt = null;
+ el.querySelector("#fn-gewaehlt").textContent = "Noch kein Ziel ausgewählt.";
+ });
+ },
+ });
+ }
+
+ function bearbeitenDialog(behaelter, f) {
+ fenster({
+ titel: "Fahndung bearbeiten",
+ inhalt: `
+
+
Gefahrenstufe
+
+ ${["normal", "bewaffnet", "gefaehrlich"].map((g) =>
+ `${gefahrText[g]} `).join("")}
+
+
Priorität
+
+ ${[1, 2, 3, 4].map((p) =>
+ `${p} — ${prioText[p]} `).join("")}
+
+
Fahndungsgrund
+
+ Hinweise
+
+ Fahndungsbild (Adresse)
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Speichern", klick: async (el, zu) => {
+ try {
+ await aufruf("fahndung", "bearbeiten", {
+ id: f.id,
+ gefahr: el.querySelector("#fb-gefahr").value,
+ prioritaet: +el.querySelector("#fb-prio").value,
+ grund: el.querySelector("#fb-grund").value.trim(),
+ hinweise: el.querySelector("#fb-hinweise").value.trim(),
+ bild: el.querySelector("#fb-bild").value.trim(),
+ });
+ zu(); meldung("Gespeichert.", "gut"); oeffne(behaelter, f.id);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ }},
+ ],
+ });
+ }
+
+ /* ---- Laden -------------------------------------------------------- */
+
+ async function oeffne(behaelter, fahndungId) {
+ try {
+ const d = await aufruf("fahndung", "oeffnen", { id: fahndungId });
+ z.offen = fahndungId;
+ einzelAnsicht(behaelter, d);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("fahndung", "liste", {
+ typ: z.filterTyp, gefahr: z.filterGefahr, archiv: z.archiv, begriff: z.suche,
+ });
+ if (z.offen) await oeffne(behaelter, z.offen);
+ else uebersicht(behaelter);
+ } catch (f) {
+ behaelter.innerHTML = `Fahndungen
+
Konnte nicht geladen werden: ${sicher(f.message)}
+
`;
+ }
+
+ function statusName(id) {
+ return (z.daten.statusliste && z.daten.statusliste[id]) || id;
+ }
+ function wartungName(id) {
+ return (z.daten.wartungsliste && z.daten.wartungsliste[id]) || id;
+ }
+ function abteilungName(id) {
+ const treffer = (z.daten.abteilungen || []).find((a) => a.id === id);
+ return treffer ? treffer.name : id;
+ }
+
+ /* ---- Übersicht ---------------------------------------------------- */
+
+ function uebersicht(behaelter) {
+ const d = z.daten;
+
+ behaelter.innerHTML = `
+
+
+
Fuhrpark
+
Standort, Tank und Zustand werden gemeldet — Zuweisung und Status setzt ein Beamter.
+
+ ${d.rechte.wartung ? `
＋ Fahrzeug aufnehmen ` : ""}
+
+
Verfügbar
+
${d.bestand.verfuegbar || 0}
+
Im Einsatz
+
${d.bestand.im_einsatz || 0}
+
Werkstatt
+
${d.bestand.werkstatt || 0}
+
Wartung offen
+
${d.wartungFaellig}
+
+
+ Alle Abteilungen
+ ${(d.abteilungen || []).map((a) =>
+ `${sicher(a.name)} `).join("")}
+
+
+ Alle Status
+ ${Object.keys(d.statusliste || {}).map((s) =>
+ `${sicher(d.statusliste[s])} `).join("")}
+
+
+
+
+ ${d.fahrzeuge.length ? `
${d.fahrzeuge.map((f) => `
+
+
${sicher(f.kennzeichen)}
+
+
${sicher(f.bezeichnung)}
+ ${f.wartung !== "ok"
+ ? `${sicher(wartungName(f.wartung))} ` : ""}
+
+
+ ${sicher(f.modell)} · ${sicher(abteilungName(f.abteilung))}
+ ${f.z_nummer ? " · zugewiesen: " + sicher(f.z_nummer) : ""}
+
+
+ ⛽ ${Math.round(f.tank)} % ${balken(f.tank, "Tank")}
+ 🔧 ${Math.round(f.zustand / 10)} % ${balken(f.zustand / 10, "Zustand")}
+
+
+
+ ${sicher(statusName(f.status))}
+ ${f.pos_x ? `Standort ` : ""}
+
+
`).join("")}
`
+ : `
Kein Fahrzeug im Fuhrpark.
`}
+
+
+
${sicher(f.bezeichnung)}
+
${sicher(f.kennzeichen)} · ${sicher(f.modell)} · ${sicher(abteilungName(f.abteilung))}
+
+
+ ‹ Zurück
+ ${f.pos_x ? `📍 Standort ` : ""}
+ ${d.rechte.zuweisen ? `Status ` : ""}
+ ${d.rechte.wartung ? `Wartung ` : ""}
+ ${d.rechte.zuweisen ? `Zuweisen ` : ""}
+
+
+ 🔧
+ ${sicher(wartungName(f.wartung))} — das Fahrzeug sollte vor dem
+ nächsten Einsatz geprüft werden.
` : ""}
+
+
+
+
+ Zustand
+ ${sicher(statusName(f.status))}
+
+
+
+
+ ⛽ Tankstand
+ ${Math.round(f.tank)} %
+
+ ${balken(f.tank, "Tank")}
+
+ 🔧 Karosserie
+ ${Math.round(f.zustand / 10)} %
+
+ ${balken(f.zustand / 10, "Zustand")}
+
+
+
+ Wartung ${sicher(wartungName(f.wartung))}
+ Zugewiesen an ${f.z_nummer
+ ? sicher(f.z_nummer + " " + (f.z_vorname || "") + " " + (f.z_nachname || ""))
+ : "— frei —"}
+ Letzter Fahrer ${f.l_nummer
+ ? sicher(f.l_nummer + " " + (f.l_vorname || "") + " " + (f.l_nachname || ""))
+ : "— nicht erfasst —"}
+ Standort ${f.pos_x
+ ? `${Math.round(f.pos_x)}, ${Math.round(f.pos_y)}`
+ : "— nicht gemeldet —"}
+
+
+
+
ℹ
+
Tank, Zustand, Standort und letzter Fahrer werden vom Fahrzeug
+ gemeldet . Status, Zuweisung und Wartung setzt ausschließlich ein Beamter.
+
+
+
+
+
+ Verwaltung
+ ${d.rechte.wartung && !f.zugewiesen_an
+ ? `Ausmustern ` : ""}
+
+ ${f.zugewiesen_an ? `
+
+
+
${sicher(f.z_nummer || "")}
+
+
${sicher((f.z_vorname || "") + " " + (f.z_nachname || ""))}
+
Fahrzeug ist dieser Person zugewiesen
+
+ ${d.rechte.zuweisen
+ ? `
Freigeben ` : ""}
+
+
`
+ : `
Das Fahrzeug ist keiner Person zugewiesen.
`}
+
+
+
+
Vorgangshistorie
+ ${d.historie.length ? `
${d.historie.map((h) => `
+
+
+
${sicher(h.aktion)}
+
${sicher(h.dienstnummer || "")}
+ ${sicher((h.firstname || "") + " " + (h.lastname || ""))} · ${zeit(h.am)}
+ ${h.grund ? " · " + sicher(h.grund) : ""}
+
+
`).join("")}
`
+ : `
Keine Einträge.
`}
+
+
+ ${sicher(f.bezeichnung)} (${sicher(f.kennzeichen)})
+ ${beamte.length ? `${beamte.map((b) =>
+ `
+
${sicher(b.dienstnummer)}
+
${sicher(b.name)}
+
${sicher(b.rolleName)} · ${sicher(b.abteilung)}
+
`).join("")}
Niemand im Dienst.
`}
+ Vermerk
+
`,
+ nachOeffnen: (el) => {
+ el.querySelectorAll("[data-wahl]").forEach((zeile) =>
+ zeile.addEventListener("click", async () => {
+ try {
+ await aufruf("fahrzeug", "zuweisen", {
+ id: f.id, charakterId: +zeile.dataset.wahl,
+ grund: el.querySelector("#fzz-grund").value.trim(),
+ });
+ el.remove(); meldung("Zugewiesen.", "gut"); oeffne(behaelter, f.id);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ }));
+ },
+ });
+ });
+
+ const freigeben = $("fz-freigeben");
+ if (freigeben) freigeben.addEventListener("click", async () => {
+ try {
+ await aufruf("fahrzeug", "zuweisen", { id: f.id, freigeben: true });
+ meldung("Zuweisung aufgehoben."); oeffne(behaelter, f.id);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ });
+
+ const statusSetzen = $("fz-status-setzen");
+ if (statusSetzen) statusSetzen.addEventListener("click", () => {
+ fenster({
+ titel: "Status setzen",
+ inhalt: `
+ Neuer Status
+
+ ${Object.keys(d.statusliste).map((s) =>
+ `${sicher(d.statusliste[s])} `).join("")}
+
+ Vermerk
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Speichern", klick: async (el, zu) => {
+ try {
+ await aufruf("fahrzeug", "status", {
+ id: f.id, status: el.querySelector("#fzs-status").value,
+ grund: el.querySelector("#fzs-grund").value.trim(),
+ });
+ zu(); meldung("Status gesetzt.", "gut"); oeffne(behaelter, f.id);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ }},
+ ],
+ });
+ });
+
+ const wartung = $("fz-wartung");
+ if (wartung) wartung.addEventListener("click", () => {
+ fenster({
+ titel: "Wartungsstatus",
+ inhalt: `
+ Zustand der Wartung
+
+ ${Object.keys(d.wartungsliste).map((w) =>
+ `${sicher(d.wartungsliste[w])} `).join("")}
+
+ Vermerk
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Speichern", klick: async (el, zu) => {
+ try {
+ await aufruf("fahrzeug", "wartung", {
+ id: f.id, wartung: el.querySelector("#fzw-wartung").value,
+ vermerk: el.querySelector("#fzw-vermerk").value.trim(),
+ });
+ zu(); meldung("Wartungsstatus gesetzt.", "gut"); oeffne(behaelter, f.id);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ }},
+ ],
+ });
+ });
+
+ const entfernen = $("fz-entfernen");
+ if (entfernen) entfernen.addEventListener("click", () => {
+ bestaetigen({
+ titel: "Fahrzeug ausmustern",
+ gefahr: true,
+ inhalt: `
+
+ ${sicher(f.bezeichnung)} (${sicher(f.kennzeichen)}) wird aus dem Fuhrpark
+ entfernt. Der Vorgang bleibt im Protokoll sichtbar.
+ Grund
+
`,
+ bestaetigenText: "Ausmustern",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("fahrzeug", "entfernen", {
+ id: f.id, grund: el.querySelector("#fze-grund").value.trim(),
+ });
+ zu(); meldung("Ausgemustert."); z.offen = null; rendern(behaelter);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ },
+ });
+ });
+ }
+
+ /* ---- Anlegen ------------------------------------------------------ */
+
+ function anlegenDialog(behaelter) {
+ fenster({
+ titel: "Fahrzeug aufnehmen",
+ inhalt: `
+
+ Bezeichnung
+
+ Abteilung
+
+ ${(z.daten.abteilungen || []).map((a) =>
+ `${sicher(a.name)} `).join("")}
+
+
+ Das Kennzeichen muss mit dem im Spiel übereinstimmen — nur dann können
+ Tank, Zustand und Standort gemeldet werden.
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Aufnehmen", klick: async (el, zu) => {
+ try {
+ const ergebnis = await aufruf("fahrzeug", "anlegen", {
+ kennzeichen: el.querySelector("#fn-kz").value.trim(),
+ modell: el.querySelector("#fn-modell").value.trim(),
+ bezeichnung: el.querySelector("#fn-bez").value.trim(),
+ abteilung: el.querySelector("#fn-abteilung").value,
+ });
+ zu(); meldung("Fahrzeug aufgenommen.", "gut");
+ oeffne(behaelter, ergebnis.id);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ }},
+ ],
+ });
+ }
+
+ /* ---- Laden -------------------------------------------------------- */
+
+ async function oeffne(behaelter, fahrzeugId) {
+ try {
+ const d = await aufruf("fahrzeug", "oeffnen", { id: fahrzeugId });
+ z.offen = fahrzeugId;
+ einzelAnsicht(behaelter, d);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("fahrzeug", "liste", {
+ abteilung: z.filterAbteilung, status: z.filterStatus,
+ wartung: z.filterWartung, begriff: z.suche,
+ });
+ if (z.offen) await oeffne(behaelter, z.offen);
+ else uebersicht(behaelter);
+ } catch (f) {
+ behaelter.innerHTML = `Fuhrpark
+
Konnte nicht geladen werden: ${sicher(f.message)}
+ 🔒 Aktueller Bestand
+ 📋 Verlauf
+
`;
+ }
+
+ function zellenUebersicht(zellen) {
+ return `${zellen.map((zelle) => `
+
+
${sicher(zelle.name)}
+ ${zelle.frei
+ ? `
frei
`
+ : `
${sicher(zelle.insasse.name)}
+
+ ${restText(zelle.insasse.rest)}
+
`}
+
`).join("")}
Niemand in Gewahrsam.
`;
+
+ return `${offene.map((g) => `
+
+
+
+
+ ${sicher(g.firstname + " " + g.lastname)}
+ ${g.zelle ? `${sicher(g.zelle)} ` : ""}
+ ${g.online ? "" : 'offline '}
+
+
${sicher(g.grund)}
+
+ ${g.haft_minuten} Min festgelegt · eingewiesen von
+ ${sicher(g.e_dienstnummer || "")} ${sicher((g.e_vorname || "") + " " + (g.e_nachname || ""))}
+ · ${zeit(g.beginn)}
+
+
+
+
+ ${restText(g.rest_sekunden)}
+
+
+ ${z.daten.rechte.entlassen
+ ? `Frist ` : ""}
+ ${z.daten.rechte.einweisen
+ ? `Zelle ` : ""}
+ ${z.daten.rechte.entlassen
+ ? `Entlassen ` : ""}
+
+
+
`).join("")}
+
+
Gewahrsam
+
Fristen laufen mit — entlassen wird ausschließlich durch einen Beamten.
+
+ ${d.rechte.einweisen
+ ? `
＋ In Gewahrsam nehmen ` : ""}
+
+ ⏰
+ ${abgelaufen} Haftzeit${abgelaufen === 1 ? "" : "en"} abgelaufen.
+ Die Person${abgelaufen === 1 ? " bleibt" : "en bleiben"} im Gewahrsam, bis ein Beamter
+ über die Entlassung entscheidet.
` : ""}
+
+
+
+
+ Zellenbelegung
+ ${d.zellen.filter((c) => !c.frei).length} / ${d.zellen.length}
+
+ ${zellenUebersicht(d.zellen)}
+
+
+
+
+ Aktueller Bestand
+ ${d.offene.length}
+
+ ${bestandListe(d.offene)}
+
+
ℹ
+
Das System erinnert an ablaufende Fristen — es entlässt niemanden.
+ Auch eine längst abgelaufene Haftzeit bleibt offen stehen, bis jemand entscheidet.
+
+
+
+
Person
+
+ Suchen
+
+
Noch niemand ausgewählt.
+
+
+ Haftdauer (Minuten)
+
+
+ Zelle
+
+ — ohne feste Zelle —
+ ${freieZellen.map((c) => `${sicher(c.name)} `).join("")}
+
+
+
+ Grund
+
+
+
+
ℹ
+
Die Haftdauer legst du fest. Ein Katalogvorschlag aus einer Anzeige
+ ist nur eine Empfehlung und wird hier nicht automatisch übernommen.
+ ${z.daten.verbringen
+ ? "nicht automatisch verbracht — das geschieht im Rollenspiel."}
+
${treffer.slice(0, 6).map((p) =>
+ `
+
${sicher(p.firstname + " " + p.lastname)}
+
geb. ${sicher(String(p.dob || "").slice(0, 10))}
+
`).join("")}
${sicher(gewaehlt.name)} `;
+ }));
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ };
+
+ el.querySelector("#gw-suchen").addEventListener("click", suchen);
+ el.querySelector("#gw-person").addEventListener("keydown", (e) => {
+ if (e.key === "Enter") { e.preventDefault(); suchen(); }
+ });
+ },
+ });
+ return f;
+ }
+
+ /* ---- Entlassen ---------------------------------------------------- */
+
+ function entlassenDialog(behaelter, gewahrsamId) {
+ const g = z.daten.offene.find((x) => x.id === gewahrsamId);
+ if (!g) return;
+
+ const vorzeitig = g.rest_sekunden > 0;
+ const restMinuten = Math.ceil(g.rest_sekunden / 60);
+
+ bestaetigen({
+ titel: vorzeitig ? "Vorzeitig entlassen" : "Entlassen",
+ gefahr: vorzeitig,
+ inhalt: `
+
+ ${sicher(g.firstname + " " + g.lastname)}
+
+ ${vorzeitig ? `
+
+
⚠ Die Frist läuft noch ${restMinuten} Minuten
+
+ Eine vorzeitige Entlassung ist möglich — sie verlangt aber eine Begründung
+ und wird als solche protokolliert.
+
+
+
+
⏰
+
Die festgelegte Haftzeit ist abgelaufen. Das System hat lediglich
+ daran erinnert — die Entlassung führst du aus.
+
+
+ Vermerk${vorzeitig ? " (erforderlich)" : ""}
+
`,
+ bestaetigenText: "Entlassung ausführen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("gewahrsam", "entlassen", {
+ id: gewahrsamId,
+ grund: el.querySelector("#ge-grund").value.trim(),
+ });
+ zu(); meldung("Entlassung durchgeführt.", "gut"); rendern(behaelter);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Frist anpassen ----------------------------------------------- */
+
+ function fristDialog(behaelter, gewahrsamId) {
+ fenster({
+ titel: "Haftzeit anpassen",
+ inhalt: `
+
+
Änderung in Minuten
+
+
Beispiel: -10 verkürzt um zehn Minuten,
+ 15 verlängert um fünfzehn.
+
+ Grund (erforderlich)
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Frist ändern", klick: async (el, zu) => {
+ try {
+ await aufruf("gewahrsam", "fristAendern", {
+ id: gewahrsamId,
+ minuten: +el.querySelector("#gf-minuten").value,
+ grund: el.querySelector("#gf-grund").value.trim(),
+ });
+ zu(); meldung("Frist angepasst.", "gut"); rendern(behaelter);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ }},
+ ],
+ });
+ }
+
+ /* ---- Zelle wechseln ----------------------------------------------- */
+
+ function zelleDialog(behaelter, gewahrsamId) {
+ const frei = z.daten.zellen.filter((c) => c.frei);
+ if (!frei.length) { meldung("Keine freie Zelle verfügbar.", "fehler"); return; }
+
+ fenster({
+ titel: "Zelle wechseln",
+ inhalt: `Neue Zelle
+
+ ${frei.map((c) => `${sicher(c.name)} `).join("")}
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Verlegen", klick: async (el, zu) => {
+ try {
+ await aufruf("gewahrsam", "zelleWechseln", {
+ id: gewahrsamId, zelle: el.querySelector("#gz-zelle").value,
+ });
+ zu(); meldung("Verlegt.", "gut"); rendern(behaelter);
+ } catch (fehler) { meldung(fehler.message, "fehler"); }
+ }},
+ ],
+ });
+ }
+
+ /* ---- Verlauf ------------------------------------------------------ */
+
+ function verlaufAnsicht(behaelter) {
+ const v = z.daten.verlauf;
+
+ behaelter.innerHTML = `
+
+
Gewahrsam — Verlauf
+
Abgeschlossene Vorgänge, nachvollziehbar mit entscheidendem Beamten
+
+ ${v.length ? `
${v.map((g) => `
+
+
+
${sicher(g.firstname + " " + g.lastname)}
+
${sicher(g.grund)}
+
+ ${g.haft_minuten} Min · ${zeit(g.beginn)} bis ${zeit(g.entlassen_am)}
+ · entlassen durch ${sicher((g.e_vorname || "") + " " + (g.e_nachname || ""))}
+ ${g.entlass_grund ? ` · „${sicher(g.entlass_grund)}"` : ""}
+
+
+
`).join("")}
`
+ : `
Keine abgeschlossenen Vorgänge.
`}
+
Gewahrsam
+
Konnte nicht geladen werden: ${sicher(fehler.message)}
+ ${eintraege.map((e) => `
+
+ ${sicher(e.text)}
+ ${e.zaehler ? `${e.zaehler} ` : ""}
+ `).join("")}
+
`;
+ }
+
+ /* ---- Posteingang --------------------------------------------------- */
+
+ function postliste(behaelter) {
+ const d = z.daten;
+ const gesendet = z.reiter === "gesendet";
+
+ behaelter.innerHTML = `
+
+
+
Kommunikation
+
Nachrichten und Aushänge der Behörde. Zugestellt wird automatisch —
+ gelesen, beantwortet und zur Kenntnis genommen wird von Hand.
+
+ ${d.rechte.senden
+ ? `
✉ Nachricht verfassen ` : ""}
+
+ ${(d.nachrichten || []).length
+ ? d.nachrichten.map((n) => postzeile(n, gesendet)).join("")
+ : `
${gesendet
+ ? "Du hast noch nichts gesendet."
+ : "Keine Nachrichten."}
`}
+
Rundmeldung `
+ : n.empf_typ === "abteilung"
+ ? `Abteilung ` : "";
+
+ return `
+
+
+
${sicher(n.betreff || "(kein Betreff)")}
+
+ ${gesendet ? "an " + sicher(n.empfaengerName)
+ : "von " + sicher(n.absenderName)
+ + (n.dienstnummer ? " · " + sicher(n.dienstnummer) : "")}
+ — ${sicher(n.vorschau)}
+
+
+ ${typMarker}
+
${zeit(n.gesendet)}
+
+
+ ${sicher(n.absenderName)}
+
+ ${sicher(n.dienstnummer || "")} ${n.rolleName ? "· " + sicher(n.rolleName) : ""}
+
+
+
${zeit(n.gesendet)}
+
Gerichtet an: ${sicher(n.empfaengerName)}
` : ""}
+ ${sicher(n.text).replace(/\n/g, "
`,
+ knoepfe: n.antwortAn
+ ? [{ text: "Antworten", klick: (_, zu) => {
+ zu();
+ verfassen(behaelter, {
+ empfTyp: "person", empfaenger: n.antwortAn,
+ empfaengerName: n.absenderName,
+ betreff: n.betreff && n.betreff.startsWith("Re:")
+ ? n.betreff : "Re: " + (n.betreff || ""),
+ });
+ } },
+ { text: "Schließen", art: "leise", klick: (_, zu) => zu() }]
+ : [{ text: "Schließen", art: "leise", klick: (_, zu) => zu() }],
+ });
+
+ // Der Lesestatus hat sich geändert — Liste auffrischen
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ /* ---- Nachricht verfassen -------------------------------------------- */
+
+ async function verfassen(behaelter, vorgabe) {
+ vorgabe = vorgabe || {};
+
+ let empfaengerDaten;
+ try {
+ empfaengerDaten = await aufruf("kommunikation", "empfaenger", {});
+ } catch (f) { return meldung(f.message, "fehler"); }
+
+ let gewaehlt = vorgabe.empfaenger
+ ? { typ: vorgabe.empfTyp, id: vorgabe.empfaenger, name: vorgabe.empfaengerName }
+ : null;
+
+ fenster({
+ titel: "Nachricht verfassen",
+ inhalt: `
+ Empfänger
+
+ Beamter
+ Abteilung
+ ${empfaengerDaten.rundmeldung
+ ? `Alle Einheiten ` : ""}
+
+
+
Betreff
+
+ Nachricht
+
`,
+ knoepfe: [
+ { text: "Abbrechen", art: "leise", klick: (_, zu) => zu() },
+ { text: "Senden", klick: async (el, zu) => {
+ if (!gewaehlt) return meldung("Bitte einen Empfänger wählen.", "fehler");
+ try {
+ await aufruf("kommunikation", "senden", {
+ empfTyp: gewaehlt.typ,
+ empfaenger: gewaehlt.id,
+ betreff: el.querySelector("[name=betreff]").value.trim(),
+ text: el.querySelector("[name=text]").value.trim(),
+ });
+ zu();
+ meldung("Nachricht gesendet.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ } },
+ ],
+ nachOeffnen: (hg) => {
+ const bereich = hg.querySelector("[data-empfbereich]");
+
+ /** Zeichnet den Empfängerbereich passend zur gewählten Art */
+ function zeichne(art) {
+ hg.querySelectorAll("[data-art]").forEach((b) =>
+ b.classList.toggle("gewaehlt", b.dataset.art === art));
+
+ if (art === "rundmeldung") {
+ gewaehlt = { typ: "rundmeldung", id: "alle", name: "Alle Einheiten" };
+ bereich.innerHTML = `
+
📣
+
Diese Nachricht erreicht jeden Beamten der Behörde.
+
+ — Abteilung wählen —
+ ${empfaengerDaten.abteilungen.map((a) =>
+ `${sicher(a.name)} `).join("")}
+ `;
+ bereich.querySelector("[name=abt]").addEventListener("change", (e) => {
+ gewaehlt = e.target.value
+ ? { typ: "abteilung", id: e.target.value, name: e.target.value } : null;
+ });
+ return;
+ }
+
+ // Einzelner Beamter: Liste mit Suchfeld
+ bereich.innerHTML = `
+
`;
+
+ const liste = bereich.querySelector("[data-liste]");
+ const suchfeld = bereich.querySelector("[name=suche]");
+
+ function zeichneListe(begriff) {
+ const gefiltert = empfaengerDaten.beamte.filter((b) => {
+ if (!begriff) return true;
+ const text = (b.firstname + " " + b.lastname + " " + b.dienstnummer).toLowerCase();
+ return text.includes(begriff.toLowerCase());
+ }).slice(0, 40);
+
+ liste.innerHTML = gefiltert.length
+ ? gefiltert.map((b) => `
+
+
+
${sicher(b.dienstnummer)}
+
+
${sicher(b.firstname)} ${sicher(b.lastname)}
+
${sicher(b.rolleName)}
+
+
Kein Beamter gefunden.
`;
+
+ liste.querySelectorAll("[data-beamter]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const b = empfaengerDaten.beamte.find((x) => x.character === +el.dataset.beamter);
+ gewaehlt = { typ: "person", id: b.character,
+ name: b.firstname + " " + b.lastname };
+ liste.querySelectorAll("[data-beamter]")
+ .forEach((zeile) => zeile.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ });
+ });
+ }
+
+ zeichneListe(gewaehlt && gewaehlt.name ? gewaehlt.name : "");
+ suchfeld.addEventListener("input", () => zeichneListe(suchfeld.value.trim()));
+ }
+
+ hg.querySelectorAll("[data-art]").forEach((b) =>
+ b.addEventListener("click", () => zeichne(b.dataset.art)));
+
+ zeichne(gewaehlt ? gewaehlt.typ : "person");
+ },
+ });
+ }
+
+ /* ---- Aushänge -------------------------------------------------------- */
+
+ function aushangListe(behaelter) {
+ const d = z.aushangDaten;
+
+ behaelter.innerHTML = `
+
+
+
${d.archiv ? "Archivierte Aushänge" : "Aushänge"}
+
Dienstanweisungen und Mitteilungen der Leitung. Eine Kenntnisnahme
+ bestätigst ausschließlich du selbst.
+
+ ${d.rechte.schreiben && !d.archiv
+ ? `
＋ Aushang verfassen ` : ""}
+
+ ${(d.aushaenge || []).length
+ ? d.aushaenge.map((a) => aushangKarte(a, d)).join("")
+ : `
${d.archiv
+ ? "Das Archiv ist leer." : "Zurzeit hängt nichts aus."}
`}
+
+
+
+ ${kategorieSymbol[a.kategorie] || ""} ${sicher(a.titel)}
+
+
+ ${a.angeheftet ? `angeheftet ` : ""}
+ ${sicher(a.kategorieName)}
+ ${a.abteilungName
+ ? `${sicher(a.abteilungName)} ` : ""}
+
+
+
+
${sicher(a.text).replace(/\n/g, "
+
+
+
+ ${sicher(a.autor)}${a.dienstnummer ? " (" + sicher(a.dienstnummer) + ")" : ""}
+ · ${zeit(a.erstellt_am)}
+ ${a.frist ? ` · Kenntnisnahme bis ${zeit(a.frist)}` : ""}
+
+
+ ${a.kenntnispflicht ? (a.bestaetigt
+ ? `✓ zur Kenntnis genommen `
+ : (a.aktiv === 1
+ ? `
+ Kenntnis bestätigen ` : "")) : ""}
+ ${a.kenntnispflicht && d.rechte.schreiben
+ ? `
+ ${a.kenntnisse}/${a.betroffen} bestätigt${offen > 0 ? " · " + offen + " offen" : ""}
+ ` : ""}
+ ${d.rechte.schreiben && a.aktiv === 1
+ ? `
+ ${a.angeheftet ? "Loslösen" : "Anheften"} ` : ""}
+ ${d.rechte.archivieren && a.aktiv === 1
+ ? `Archivieren ` : ""}
+
+
+
Du erklärst damit, den Aushang gelesen und verstanden zu haben.
+ Die Bestätigung wird mit deinem Namen und der Uhrzeit vermerkt.
`,
+ bestaetigenText: "Zur Kenntnis genommen",
+ bestaetigt: async (_, zu) => {
+ try {
+ await aufruf("kommunikation", "kenntnisnahme", { id });
+ zu();
+ meldung("Kenntnisnahme vermerkt.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ async function kenntnisStand(id) {
+ try {
+ const d = await aufruf("kommunikation", "kenntnisStand", { id });
+
+ fenster({
+ titel: "Stand der Kenntnisnahmen",
+ inhalt: `
+ ${sicher(d.titel)}
+ ${d.gesamt - d.offen} von ${d.gesamt} Beamten haben bestätigt.
+ ${d.frist ? "Frist: " + zeit(d.frist) + "." : ""}
+ Das System erinnert nur — es bestätigt für niemanden.
+
+ ${d.beamte.map((b) => `
+
+
${sicher(b.dienstnummer)}
+
+ ${b.bestaetigt_am
+ ? `
${zeit(b.bestaetigt_am)} `
+ : `
offen `}
+
`).join("")}
+
Titel
+
+ Art
+
+ ${Object.keys(d.kategorien).map((k) =>
+ `${sicher(d.kategorien[k])} `).join("")}
+
+ Gilt für
+
+ Gesamte Behörde
+ ${d.abteilungen.map((a) =>
+ `${sicher(a.name)} `).join("")}
+
+ Inhalt
+
+
+
+
+
+
Beamte bestätigen selbst. Das System erinnert nur
+ an offene Bestätigungen und setzt nie eine.
+
+ Frist für die Kenntnisnahme (Minuten)
+
`,
+ bestaetigenText: "Veröffentlichen",
+ bestaetigt: async (el, zu) => {
+ const kenntnispflicht = el.querySelector("[name=kenntnispflicht]").checked;
+ const frist = +el.querySelector("[name=frist]").value;
+ try {
+ await aufruf("kommunikation", "aushangErstellen", {
+ titel: el.querySelector("[name=titel]").value.trim(),
+ text: el.querySelector("[name=text]").value.trim(),
+ kategorie: el.querySelector("[name=kategorie]").value,
+ abteilung: el.querySelector("[name=abteilung]").value,
+ angeheftet: el.querySelector("[name=angeheftet]").checked,
+ kenntnispflicht,
+ fristMinuten: kenntnispflicht && frist > 0 ? frist : null,
+ });
+ zu();
+ meldung("Aushang veröffentlicht.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ nachOeffnen: (hg) => {
+ // Das Fristfeld ist nur sinnvoll, wenn eine Kenntnisnahme verlangt wird
+ const haken = hg.querySelector("[name=kenntnispflicht]");
+ const fristfeld = hg.querySelector("[data-fristfeld]");
+ haken.addEventListener("change", () => {
+ fristfeld.style.display = haken.checked ? "" : "none";
+ });
+ },
+ });
+ }
+
+ function aushangArchivieren(behaelter, id) {
+ bestaetigen({
+ titel: "Aushang archivieren",
+ gefahr: true,
+ inhalt: `Der Aushang verschwindet vom Brett und wandert ins Archiv.
+ Bereits bestätigte Kenntnisnahmen bleiben erhalten.
+ Grund (freiwillig)
+
`,
+ bestaetigenText: "Archivieren",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("kommunikation", "aushangArchivieren", {
+ id, grund: el.querySelector("[name=grund]").value.trim(),
+ });
+ zu();
+ meldung("Aushang archiviert.", "gut");
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Laden ------------------------------------------------------------- */
+
+ async function rendern(behaelter) {
+ try {
+ // Die Zähler der Reiterleiste kommen immer aus der Übersicht
+ z.daten = await aufruf("kommunikation", "uebersicht", {
+ ordner: z.reiter === "gesendet" ? "gesendet" : "eingang",
+ });
+
+ // Sprungziel aus einem Hinweis, z. B. „Neuer Aushang"
+ const ziel = App.zustand.modulZiel;
+ if (ziel && ziel.aushang) {
+ App.zustand.modulZiel = null;
+ z.reiter = "aushang";
+ } else if (ziel && ziel.nachricht) {
+ App.zustand.modulZiel = null;
+ z.reiter = "eingang";
+ postliste(behaelter);
+ return nachrichtOeffnen(behaelter, ziel.nachricht);
+ }
+
+ if (z.reiter === "aushang" || z.reiter === "archiv") {
+ z.aushangDaten = await aufruf("kommunikation", "aushaenge", {
+ archiv: z.reiter === "archiv",
+ });
+ aushangListe(behaelter);
+ } else {
+ postliste(behaelter);
+ }
+ } catch (f) {
+ behaelter.innerHTML = `Kommunikation
+
Konnte nicht geladen werden: ${sicher(f.message)}
Gefahr: ${gefahrText[s]} `;
+ }
+
+ function reiterLeiste() {
+ const reiter = [
+ { id: "personen", name: "Personen", symbol: "👤" },
+ { id: "fahrzeuge", name: "Fahrzeuge", symbol: "🚗" },
+ { id: "akten", name: "Akten", symbol: "🗂" },
+ ];
+ return `${reiter.map((r) =>
+ `
+ ${r.symbol} ${r.name}
+ `).join("")}
`;
+ }
+
+ /* =====================================================================
+ PERSONEN
+ ===================================================================== */
+
+ function personenTrefferListe() {
+ if (!z.treffer.length) {
+ return `${z.suche ? "Keine Treffer." : "Suchbegriff eingeben — Name, Geburtsdatum oder Telefonnummer."}
`;
+ }
+
+ return `${z.treffer.map((p) =>
+ `
+
+
+ ${sicher(p.firstname + " " + p.lastname)}
+ ${p.fahndung > 0 ? 'Fahndung ' : ""}
+ ${gefahrMarke(p.gefahrenstufe)}
+
+
+ geb. ${sicher(String(p.dob || "").slice(0, 10))}
+ ${p.telefon ? " · ☎ " + sicher(p.telefon) : ""}
+ ${p.job ? " · " + sicher(p.job) : ""}
+
+
+
Akte öffnen
+
`).join("")}
+
${p.lichtbild
+ ? `
`
+ : `
Kein Lichtbild `}
+
+
${sicher(p.firstname + " " + p.lastname)}
+
+ Geboren ${sicher(String(p.dob || "").slice(0, 10))}
+ Geschlecht ${sicher(p.gender || "—")}
+ Herkunft ${sicher(p.nationality || "—")}
+ Beruf ${sicher(p.job || "—")}
+ Telefon ${sicher(d.telefon || "—")}
+ Fingerabdruck ${sicher(p.fingerabdruck || "nicht erfasst")}
+ DNA ${sicher(p.dna || "nicht erfasst")}
+
+
+
+ ＋ Notiz
+ ⚠ Warnhinweis
+ 🔬 ED-Daten
+ 🗂 Akte anlegen
+
+
+ ⚠
+ Warnhinweis: ${sicher(p.warnhinweis)} — Gefahrenstufe ${gefahrText[Number(p.gefahrenstufe) || 0]}
` : ""}
+
+ ${d.fahndung ? `
+
+ 🔍
+ Zur Fahndung ausgeschrieben: ${sicher(d.fahndung.grund)}
+ (${sicher(d.fahndung.gefahr)})
` : ""}
+
+ ${d.gewahrsam ? `
+
+ 🔒
+ In Gewahrsam — ${sicher(d.gewahrsam.grund || "ohne Grundangabe")};
+ Frist ${Number(d.gewahrsam.rest) <= 0 ? "abgelaufen" : "noch " + d.gewahrsam.rest + " Minuten"}.
+ Eine Entlassung entscheidet ein Beamter.
` : ""}
+
+
+
+
Dokumente & Lizenzen
+ ${d.lizenzen.length ? `
${d.lizenzen.map((l) =>
+ `
+
+
${sicher(lizenzName[l.typ] || l.typ)}
+
+ ${l.nummer ? sicher(l.nummer) : "—"}
+ ${l.klassen ? " · Klassen " + sicher(l.klassen.join(", ")) : ""}
+ ${l.gueltigBis ? " · gültig bis " + sicher(l.gueltigBis) : ""}
+
+
+
+ ${l.entzogen ? "entzogen" : l.gueltig ? "gültig" : "abgelaufen"}
+
+
`).join("")}
`
+ : `
Keine Dokumente hinterlegt.
`}
+
+
+
+
Bekannte Fahrzeuge
+ ${d.fahrzeuge.length ? `
${d.fahrzeuge.map((f) =>
+ `
+
+
${sicher(f.name || f.model)}
+ ${f.fahndung > 0 ? 'Fahndung ' : ""}
+
${sicher(f.plate)} · ${sicher(f.state === "impound" ? "sichergestellt" : f.state === "out" ? "unterwegs" : "eingeparkt")}
+
+
`).join("")}
`
+ : `
Keine Fahrzeuge zugeordnet.
`}
+
+
+
+
+ Vorgänge & Anzeigen
+ ${d.anzeigen.length}
+
+ ${d.anzeigen.length ? `
${d.anzeigen.map((a) =>
+ `
+
+
${sicher((a.delikte || []).map((x) => x.name).join(", ") || "Anzeige")}
+
${zeit(a.erstellt_am)}
+ ${a.status === "bestaetigt" ? ` · ${a.haft_final} Min · ${App.euro(a.geld_final)}` : ""}
+
+
+ ${sicher(a.status)}
+
+
`).join("")}
`
+ : `
Keine Vorgänge erfasst.
`}
+
+
+
+
Verknüpfte Akten
+ ${d.akten.length ? `
${d.akten.map((a) =>
+ `
+
+
${sicher(a.titel)}
+
${sicher(a.aktenzeichen)} · ${sicher(a.typ)}
+ ${a.rolle ? " · " + sicher(a.rolle) : ""}
+
+
${sicher(a.status)}
+
`).join("")}
`
+ : `
Keine Akten verknüpft.
`}
+
+
+
+
Bekannte Kontakte
+ ${d.kontakte.length ? `
${d.kontakte.map((k) =>
+ `
+
+
${sicher(k.name)}
+
☎ ${sicher(k.number)}
+
+ ${k.charakterId ? '
bekannt ' : ""}
+
`).join("")}
`
+ : `
Keine Kontakte bekannt.
`}
+
+
+
+
+ Notizen
+ ${d.notizen.length}
+
+ ${d.notizen.length ? `
${d.notizen.map((n) =>
+ `
+
+
${sicher(n.text)}
+
${sicher((n.firstname || "") + " " + (n.lastname || ""))} · ${zeit(n.am)}
+
+
✕
+
`).join("")}
`
+ : `
Keine Notizen.
`}
+
+
+
Vermerk
+
+
Notizen sind für alle Beamten sichtbar und werden protokolliert.
+
+ Hinweis (leer = entfernen)
+
+
+ Gefahrenstufe
+
+ ${[0, 1, 2, 3].map((s) =>
+ `${s} — ${gefahrText[s]} `
+ ).join("")}
+
+
+
+ Begründung
+
`,
+ bestaetigenText: "Warnhinweis setzen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("mdt", "personWarnhinweis", {
+ charakterId,
+ hinweis: el.querySelector("#wh-text").value.trim(),
+ stufe: +el.querySelector("#wh-stufe").value,
+ grund: el.querySelector("#wh-grund").value.trim(),
+ });
+ zu(); meldung("Warnhinweis aktualisiert.", "gut");
+ oeffnePerson(behaelter, charakterId);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+
+ // Erkennungsdienstliche Daten
+ const edKnopf = $("p-ed");
+ if (edKnopf) edKnopf.addEventListener("click", () => {
+ const p = z.offenePerson.person;
+ fenster({
+ titel: "Erkennungsdienstliche Daten",
+ inhalt: `
+ Fingerabdruck-Kennung
+
+ DNA-Kennung
+
+ Lichtbild (Bild-Adresse)
+
+
Die Aufnahme selbst erfolgt im Rollenspiel — hier wird nur dokumentiert.
+
${z.suche ? "Keine Treffer." : "Kennzeichen, Modell oder Halter eingeben."}
`;
+ }
+
+ return `${z.treffer.map((f) =>
+ `
+
${sicher(f.plate)}
+
+
${sicher(f.name || f.model)}
+ ${f.fahndung > 0 ? 'Fahndung ' : ""}
+ ${f.state === "impound" ? 'sichergestellt ' : ""}
+
+
Halter: ${sicher((f.firstname || "unbekannt") + " " + (f.lastname || ""))}
+
+
Details
+
`).join("")}
+
${sicher(f.plate)}
+
+
${sicher(f.name || f.model)}
+
+ Modell ${sicher(f.model)}
+ Klasse ${sicher(f.klasse || "—")}
+ Farbe ${f.farbe ? `
+ Status ${sicher(zustandText[f.state] || f.state)}
+ Standort ${sicher(f.garage || "—")}
+ Kilometerstand ${sicher(f.mileage || 0)} km
+
+
+
+ ${f.owner ? `👤 Halterakte ` : ""}
+ 🗂 Akte anlegen
+
+
+ 🔍
+ Fahrzeug zur Fahndung ausgeschrieben: ${sicher(d.fahndung.grund)}
` : ""}
+
+
+
+
Halter
+ ${f.owner ? `
+
+
+
${sicher((f.firstname || "") + " " + (f.lastname || ""))}
+
geb. ${sicher(String(f.dob || "").slice(0, 10))}
+
+
Akte öffnen
+
`
+ : `
Kein Halter eingetragen.
`}
+
+
+
+
Verknüpfte Akten
+ ${d.akten.length ? `
${d.akten.map((a) =>
+ `
+
+
${sicher(a.titel)}
+
${sicher(a.aktenzeichen)} · ${sicher(a.typ)}
+
+
`).join("")}
`
+ : `
Keine Akten verknüpft.
`}
+
+
+
+
Historie
+ ${d.historie.length ? `
${d.historie.map((h) =>
+ `
+
+
${sicher(h.aktion)}
+
${sicher((h.firstname || "") + " " + (h.lastname || ""))}
+ ${h.dienstnummer ? " · " + sicher(h.dienstnummer) : ""} · ${zeit(h.am)}
+ ${h.grund ? " · " + sicher(h.grund) : ""}
+
+
`).join("")}
`
+ : `
Keine dokumentierten Vorgänge.
`}
+
+
Keine Akten gefunden.
`;
+
+ const statusArt = { offen: "warn", pruefung: "info", geschlossen: "neutral" };
+
+ return `${akten.map((a) =>
+ `
+
${sicher(a.typ)}
+
+
${sicher(a.titel)}
+
${sicher(a.aktenzeichen)} ·
+ ${sicher((a.firstname || "") + " " + (a.lastname || ""))} · ${zeit(a.erstellt_am)}
+ ${a.version > 1 ? ` · Version ${a.version}` : ""}
+
+
${sicher(a.status)}
+
`).join("")}
+
+
${sicher(a.titel)}
+
+ Aktenzeichen ${sicher(a.aktenzeichen)}
+ Art ${sicher(a.typ)}
+ Angelegt von ${sicher((a.firstname || "") + " " + (a.lastname || ""))}
+ Angelegt am ${zeit(a.erstellt_am)}
+ Version ${sicher(a.version)}
+
+
+
+ ${sicher(a.status)}
+ ${d.darfBearbeiten ? `✎ Bearbeiten ` : ""}
+ ${d.darfBearbeiten ? `🔗 Verknüpfen ` : ""}
+ ${d.darfSchliessen && a.status !== "geschlossen"
+ ? `Akte schließen ` : ""}
+
+
+
+
Sachverhalt
+
${a.inhalt ? sicher(a.inhalt).replace(/\n/g, "Kein Inhalt hinterlegt. "}
+
+
+
+
+ Verknüpfungen
+ ${d.verknuepfungen.length}
+
+ ${d.verknuepfungen.length ? `
${d.verknuepfungen.map((v) =>
+ `
+
${sicher(v.typ)}
+
+
+ ${sicher(v.bezeichnung || v.ziel_id)}
+
+ ${v.rolle ? `
${sicher(v.rolle)}
` : ""}
+
+ ${d.darfBearbeiten ? `
✕ ` : ""}
+
`).join("")}
`
+ : `
Nichts verknüpft.
`}
+
+
+
+
Änderungshistorie
+ ${d.versionen.length ? `
${d.versionen.map((v) =>
+ `
+
v${sicher(v.version)}
+
+
${sicher(v.grund || "ohne Angabe")}
+
${sicher((v.firstname || "") + " " + (v.lastname || ""))} · ${zeit(v.geaendert_am)}
+
+
`).join("")}
`
+ : `
Keine Änderungen.
`}
+
+
Titel
+
+ Sachverhalt
+
+ Grund der Änderung
+
+
Jede Änderung erzeugt eine neue Version. Die alte bleibt nachvollziehbar.
+
Art
+
+ Person (Charakter-ID)
+ Fahrzeug (Kennzeichen)
+ Beweis (Kennung)
+ Einsatz (Nummer)
+
+ Kennung
+
+ Beteiligung
+
+ — keine Angabe —
+ ${rollen.map((r) => `${sicher(r.name)} `).join("")}
+
`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Verknüpfen", klick: async (el, zu) => {
+ try {
+ await aufruf("mdt", "akteVerknuepfen", {
+ akteId: a.id,
+ typ: el.querySelector("#vk-typ").value,
+ zielId: el.querySelector("#vk-ziel").value.trim(),
+ rolle: el.querySelector("#vk-rolle").value || null,
+ });
+ zu(); meldung("Verknüpfung angelegt.", "gut");
+ oeffneAkte(behaelter, a.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }},
+ ],
+ });
+ });
+
+ behaelter.querySelectorAll("[data-vk-weg]").forEach((b) =>
+ b.addEventListener("click", async () => {
+ try {
+ await aufruf("mdt", "akteVerknuepfungLoesen", { id: +b.dataset.vkWeg });
+ oeffneAkte(behaelter, a.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }));
+
+ const schliessen = $("a-schliessen");
+ if (schliessen) schliessen.addEventListener("click", () => {
+ bestaetigen({
+ titel: "Akte schließen",
+ gefahr: true,
+ inhalt: `
+ Die Akte ${sicher(a.aktenzeichen)} wird als abgeschlossen gekennzeichnet.
+ Es wird festgehalten, dass du diese Entscheidung getroffen hast.
+ Grund
`,
+ bestaetigenText: "Akte schließen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("mdt", "akteStatus", {
+ id: a.id, status: "geschlossen",
+ grund: el.querySelector("#as-grund").value.trim(),
+ });
+ zu(); meldung("Akte geschlossen.", "gut");
+ oeffneAkte(behaelter, a.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ });
+
+ behaelter.querySelectorAll("[data-person]").forEach((el) =>
+ el.addEventListener("click", () => oeffnePerson(behaelter, +el.dataset.person)));
+ behaelter.querySelectorAll("[data-fahrzeug]").forEach((el) =>
+ el.addEventListener("click", () => oeffneFahrzeug(behaelter, el.dataset.fahrzeug)));
+ }
+
+ /** Dialog zum Anlegen einer Akte, optional gleich verknüpft */
+ function akteAnlegenDialog(behaelter, verknuepfung) {
+ const arten = (z.stammdaten && z.stammdaten.aktenarten) || [];
+ const rollen = (z.stammdaten && z.stammdaten.rollen) || [];
+
+ fenster({
+ titel: "Akte anlegen",
+ inhalt: `
+ Aktenart
+
+ ${arten.map((a) => `${sicher(a.name)} `).join("")}
+
+ Titel
+
+ Sachverhalt
+
+ ${verknuepfung ? `
+ Beteiligung der verknüpften ${verknuepfung.typ === "person" ? "Person" : "Sache"}
+
+ — keine Angabe —
+ ${rollen.map((r) => `${sicher(r.name)} `).join("")}
+
` : ""}`,
+ knoepfe: [
+ { text: "Abbrechen", klick: (_, zu) => zu() },
+ { text: "Akte anlegen", klick: async (el, zu) => {
+ try {
+ const ergebnis = await aufruf("mdt", "akteErstellen", {
+ typ: el.querySelector("#an-typ").value,
+ titel: el.querySelector("#an-titel").value.trim(),
+ inhalt: el.querySelector("#an-inhalt").value,
+ verknuepfeTyp: verknuepfung && verknuepfung.typ,
+ verknuepfeId: verknuepfung && verknuepfung.id,
+ verknuepfeRolle: verknuepfung ? (el.querySelector("#an-rolle") || {}).value : null,
+ });
+ zu();
+ meldung("Akte " + ergebnis.aktenzeichen + " angelegt.", "gut");
+ oeffneAkte(behaelter, ergebnis.id);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }},
+ ],
+ });
+ }
+
+ /* =====================================================================
+ Gerüst
+ ===================================================================== */
+
+ /**
+ * Zeichnet den MDT-Rahmen mit Inhalt.
+ * @param {boolean} detail Wenn true, wird ein Zurück-Knopf gezeigt.
+ */
+ function zeichne(behaelter, inhalt, nachher, detail) {
+ const suchfeld = {
+ personen: "Name, Geburtsdatum oder Telefonnummer …",
+ fahrzeuge: "Kennzeichen, Modell oder Halter …",
+ akten: "Aktenzeichen oder Titel …",
+ }[z.reiter];
+
+ behaelter.innerHTML = `
+
+
MDT Personen, Fahrzeuge und Akten
+ ${z.reiter === "akten"
+ ? `
＋ Neue Akte ` : ""}
+
‹ Zurück zur Suche `
+ : `
+ Suchen
+ ${z.reiter === "akten" ? `
+
+ Alle Arten
+ ${((z.stammdaten && z.stammdaten.aktenarten) || []).map((a) =>
+ `${sicher(a.name)} `).join("")}
+
+
+ Alle Status
+ Offen
+ In Prüfung
+ Geschlossen
+ ` : ""}
+
`}
+
+ ${inhalt}
+ `;
+
+ // Reiter wechseln
+ behaelter.querySelectorAll("[data-reiter]").forEach((b) =>
+ b.addEventListener("click", () => {
+ z.reiter = b.dataset.reiter;
+ z.suche = ""; z.treffer = [];
+ rendern(behaelter);
+ }));
+
+ const zurueck = $("mdt-zurueck");
+ if (zurueck) zurueck.addEventListener("click", () => rendern(behaelter));
+
+ const neueAkte = $("mdt-akte-neu");
+ if (neueAkte) neueAkte.addEventListener("click", () => akteAnlegenDialog(behaelter, null));
+
+ // Suche
+ const suchfeldEl = $("mdt-suche");
+ if (suchfeldEl) {
+ const suchen = () => { z.suche = suchfeldEl.value.trim(); ausfuehrenSuche(behaelter); };
+ suchfeldEl.addEventListener("keydown", (e) => { if (e.key === "Enter") suchen(); });
+ $("mdt-suchen").addEventListener("click", suchen);
+ }
+
+ ["mdt-filter-typ", "mdt-filter-status"].forEach((id) => {
+ const el = $(id);
+ if (el) el.addEventListener("change", () => {
+ z.akteFilter.typ = ($("mdt-filter-typ") || {}).value || "";
+ z.akteFilter.status = ($("mdt-filter-status") || {}).value || "";
+ ausfuehrenSuche(behaelter);
+ });
+ });
+
+ if (nachher) nachher();
+ }
+
+ /** Führt die Suche des aktiven Reiters aus */
+ async function ausfuehrenSuche(behaelter) {
+ try {
+ if (z.reiter === "personen") {
+ if (!z.suche) { z.treffer = []; zeichne(behaelter, personenTrefferListe(), () => verdrahteTreffer(behaelter)); return; }
+ const d = await aufruf("mdt", "personSuchen", { begriff: z.suche });
+ z.treffer = d.treffer;
+ zeichne(behaelter, personenTrefferListe(), () => verdrahteTreffer(behaelter));
+
+ } else if (z.reiter === "fahrzeuge") {
+ if (!z.suche) { z.treffer = []; zeichne(behaelter, fahrzeugTrefferListe(), () => verdrahteTreffer(behaelter)); return; }
+ const d = await aufruf("mdt", "fahrzeugSuchen", { begriff: z.suche });
+ z.treffer = d.treffer;
+ zeichne(behaelter, fahrzeugTrefferListe(), () => verdrahteTreffer(behaelter));
+
+ } else {
+ const d = await aufruf("mdt", "aktenListe", {
+ begriff: z.suche, typ: z.akteFilter.typ, status: z.akteFilter.status,
+ });
+ zeichne(behaelter, aktenListe(d.akten), () => verdrahteTreffer(behaelter));
+ }
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ function verdrahteTreffer(behaelter) {
+ behaelter.querySelectorAll("[data-person]").forEach((el) =>
+ el.addEventListener("click", () => oeffnePerson(behaelter, +el.dataset.person)));
+ behaelter.querySelectorAll("[data-fahrzeug]").forEach((el) =>
+ el.addEventListener("click", () => oeffneFahrzeug(behaelter, el.dataset.fahrzeug)));
+ behaelter.querySelectorAll("[data-akte]").forEach((el) =>
+ el.addEventListener("click", () => oeffneAkte(behaelter, +el.dataset.akte)));
+ }
+
+ async function rendern(behaelter) {
+ // Stammdaten einmalig holen (Aktenarten, Beteiligtenrollen)
+ if (!z.stammdaten) {
+ try { z.stammdaten = await aufruf("mdt", "stammdaten", {}); } catch (f) { z.stammdaten = {}; }
+ }
+
+ /* Sprungziel eines anderen Moduls auswerten, z. B. aus einer Fahndung.
+ Es gilt nur einmal und wird danach verworfen. */
+ const ziel = App.zustand.modulZiel;
+ if (ziel) {
+ App.zustand.modulZiel = null;
+ if (ziel.person) { await oeffnePerson(behaelter, +ziel.person); return; }
+ if (ziel.fahrzeug) { await oeffneFahrzeug(behaelter, ziel.fahrzeug); return; }
+ if (ziel.akte) { await oeffneAkte(behaelter, +ziel.akte); return; }
+ }
+
+ await ausfuehrenSuche(behaelter);
+ }
+
+ /* ---- Registrierung ----------------------------------------------- */
+
+ App.registriereAnsicht("mdt", { rendern });
+
+ /* Globale Suche bedienen */
+ App.registriereSuche(async (begriff) => {
+ const treffer = [];
+ try {
+ const personen = await aufruf("mdt", "personSuchen", { begriff });
+ (personen.treffer || []).slice(0, 5).forEach((p) => treffer.push({
+ bereich: "Person", titel: p.firstname + " " + p.lastname,
+ unter: "geb. " + String(p.dob || "").slice(0, 10),
+ }));
+ } catch (e) { /* Bereich überspringen */ }
+
+ try {
+ const fahrzeuge = await aufruf("mdt", "fahrzeugSuchen", { begriff });
+ (fahrzeuge.treffer || []).slice(0, 5).forEach((f) => treffer.push({
+ bereich: "Fahrzeug", titel: f.plate + " · " + (f.name || f.model),
+ unter: "Halter: " + ((f.firstname || "unbekannt") + " " + (f.lastname || "")),
+ }));
+ } catch (e) { /* Bereich überspringen */ }
+
+ try {
+ const akten = await aufruf("mdt", "aktenListe", { begriff });
+ (akten.akten || []).slice(0, 5).forEach((a) => treffer.push({
+ bereich: "Akte", titel: a.titel, unter: a.aktenzeichen + " · " + a.typ,
+ }));
+ } catch (e) { /* Bereich überspringen */ }
+
+ return treffer;
+ });
+})();
diff --git a/resources/[aether]/aether-police/html/js/module/personal.js b/resources/[aether]/aether-police/html/js/module/personal.js
new file mode 100644
index 0000000..c5b1c5f
--- /dev/null
+++ b/resources/[aether]/aether-police/html/js/module/personal.js
@@ -0,0 +1,633 @@
+/* =====================================================================
+ aether-police / Ansicht: Personalverwaltung
+
+ Dienstgrade und Rechte werden hier vergeben — jede Änderung ist eine
+ bewusste Entscheidung eines Vorgesetzten. Das System befördert,
+ degradiert oder entlässt niemanden von selbst; es zeigt nur an, was
+ gilt, und woher ein Recht kommt.
+===================================================================== */
+"use strict";
+
+(() => {
+ const { sicher, zeit, dauer, aufruf, meldung, fenster, bestaetigen } = App;
+
+ const z = {
+ daten: null,
+ offen: null, // Charakter-ID der geöffneten Personalakte
+ suche: "",
+ filterRolle: "",
+ filterAbteilung: "",
+ ehemalige: false,
+ };
+
+ // Woher stammt ein Recht — Beschriftung und Farbe des Markers
+ const herkunftText = {
+ rolle: { text: "aus Rolle", art: "gut" },
+ zusaetzlich: { text: "zusätzlich", art: "warn" },
+ entzogen: { text: "entzogen", art: "kritisch" },
+ keins: { text: "kein Recht", art: "neutral" },
+ };
+
+ /* ---- Bausteine --------------------------------------------------- */
+
+ /** Name einer Abteilung anhand ihrer Kennung */
+ function abteilungName(id) {
+ const treffer = ((z.daten && z.daten.abteilungen) || []).find((a) => a.id === id);
+ return treffer ? treffer.name : id;
+ }
+
+ /**
+ * Auswahlfeld der Dienstgrade.
+ * @param {string} gewaehlt vorausgewählte Rolle
+ * @param {number|undefined} maxStufe nur Rollen unterhalb dieser Stufe anbieten
+ */
+ function rollenFeld(gewaehlt, maxStufe) {
+ const optionen = ((z.daten && z.daten.rollen) || [])
+ // Schranke: nur Rollen unterhalb des eigenen Rangs sind wählbar
+ .filter((r) => maxStufe === undefined || r.stufe < maxStufe)
+ .map((r) => `
+ ${sicher(r.name)}
+ `).join("");
+ return `${optionen} `;
+ }
+
+ /** Auswahlfeld der Abteilungen */
+ function abteilungsFeld(gewaehlt) {
+ const optionen = ((z.daten && z.daten.abteilungen) || [])
+ .map((a) => `
+ ${sicher(a.name)}
+ `).join("");
+ return `${optionen} `;
+ }
+
+ /* ---- Übersicht ---------------------------------------------------- */
+
+ function uebersicht(behaelter) {
+ const d = z.daten;
+ const liste = d.personal || [];
+
+ // Kennzahlen ausschließlich aus den gelieferten Daten
+ const gesamt = (d.verteilung || []).reduce((summe, v) => summe + v.anzahl, 0);
+ const imDienst = liste.filter((p) => p.imDienst).length;
+ const abweichend = liste.filter((p) => p.abweichungen > 0).length;
+
+ // Verteilung nach Rollen, in der Rangfolge der Rollenliste
+ const verteilungZeilen = (d.rollen || []).map((r) => {
+ const eintrag = (d.verteilung || []).find((v) => v.rolle === r.id);
+ const anzahl = eintrag ? eintrag.anzahl : 0;
+ const anteil = gesamt > 0 ? Math.round((anzahl / gesamt) * 100) : 0;
+ return `
+
${sicher(r.name)}
+
+
${anzahl}
+
+ ${sicher(r.name)} `).join("");
+ const abteilungsOptionen = (d.abteilungen || []).map((a) =>
+ `
+ ${sicher(a.name)} `).join("");
+
+ behaelter.innerHTML = `
+
+
+
Personal
+
Dienstgrade und Rechte vergibt ein Vorgesetzter — das System schlägt nichts vor
+ und befördert niemanden automatisch.
+
+ ${d.rechte.einstellen
+ ? `
＋ Beamten einstellen ` : ""}
+
+
${gesamt}
+ im Bestand
+
${imDienst}
+ gerade im Dienst
+
${liste.length}
+ in dieser Ansicht
+
${abweichend}
+ mit Einzelrechten
+
+
Verteilung nach Dienstgrad
+
${verteilungZeilen || `
Kein Personal erfasst.
`}
+
+
+ Alle Dienstgrade ${rollenOptionen}
+
+
+ Alle Abteilungen ${abteilungsOptionen}
+
+
+ ${z.ehemalige ? "Ehemalige" : "Aktive"}
+
+
+
+
+ ${liste.length ? liste.map(zeile).join("")
+ : `
Kein Personal gefunden.
`}
+
+ ${punkt}
+
${sicher(p.dienstnummer)}
+
+
${sicher(p.firstname)} ${sicher(p.lastname)}
+
${sicher(p.rolleName)} · ${sicher(abteilungName(p.abteilung))}
+ · ${dauer(p.dienstzeit || 0)} Dienstzeit
+
+ ${p.abweichungen > 0
+ ? `
+ ${p.abweichungen} Einzelrecht${p.abweichungen === 1 ? "" : "e"} ` : ""}
+ ${p.aktiv ? "" : `
entlassen `}
+
+
+ ${sicher(r.name)}
+ ${sicher(r.id)}
+
+
${h.text}
+
+ ${["rolle", "zusaetzlich", "entzogen"].map((modus) => {
+ const gewaehlt =
+ (modus === "rolle" && (r.herkunft === "rolle" || r.herkunft === "keins")) ||
+ modus === r.herkunft;
+ const beschriftung =
+ modus === "rolle" ? "Rolle" : modus === "zusaetzlich" ? "＋" : "－";
+ const titel =
+ modus === "rolle" ? "Es gilt das Rollenpaket"
+ : modus === "zusaetzlich" ? "Zusätzlich gewähren"
+ : "Einzeln entziehen";
+ return `
+ ${beschriftung} `;
+ }).join("")}
+
+
+
${sicher(gruppe.gruppe)}
+ ${zeilen}
+
+
${sicher(abteilungName(s.abteilung))}
+
+
${zeit(s.beginn)}
+
${s.ende ? "bis " + zeit(s.ende) : "läuft noch"}
+
+
${dauer(s.sekunden || 0)}
+
+
+
${sicher(p.name)}
+
${sicher(p.dienstnummer)} · ${sicher(p.rolleName)}
+ · ${sicher(abteilungName(p.abteilung))}
+ ${p.aktiv ? "" : " · entlassen "}
+
+
← Übersicht
+
+
🔒
+
${sicher(d.sperrgrund || "Dieser Datensatz ist für dich schreibgeschützt.")}
+ Du siehst ihn nur.
+
+
${dauer(d.gesamtzeit || 0)}
+ Dienstzeit gesamt
+
${zeit(p.eingestellt)}
+ eingestellt am
+
${sicher(p.geburt)}
+ geboren
+
+
Maßnahmen
+
+ ${d.meineRechte.rolle ? `
+ Dienstgrad ändern
+ Abteilung ändern
+ Notiz bearbeiten ` : ""}
+ ${d.meineRechte.einstellen && p.aktiv
+ ? `Entlassen ` : ""}
+
+ ${p.notiz ? `
${sicher(p.notiz)}
` : ""}
+
+
+ Rechte
+ „Rolle" folgt dem Dienstgrad — ＋ und －
+ weichen bewusst davon ab.
+
+
${rechteBloecke}
+
+
Letzte Dienste
+
${dienste || `
Noch kein Dienst erfasst.
`}
+
${sicher(person.name)} · ${sicher(recht)}
+ ${beschreibung}
+ Vermerk (freiwillig)
+
`,
+ bestaetigenText: "Recht setzen",
+ gefahr: modus === "entzogen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("personal", "rechtSetzen", {
+ charakterId: person.charakterId, recht, modus,
+ vermerk: el.querySelector("[name=vermerk]").value.trim(),
+ });
+ zu();
+ meldung("Recht geändert.", "gut");
+ oeffne(behaelter, person.charakterId);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Dienstgrad, Abteilung, Notiz ---------------------------------- */
+
+ function rollenFenster(behaelter, d) {
+ const p = d.personal;
+
+ bestaetigen({
+ titel: "Dienstgrad ändern",
+ inhalt: `
+ Aktuell: ${sicher(p.rolleName)}
+ Neuer Dienstgrad
+ ${rollenFeld(p.rolle, d.meineStufe)}
+
Rollen auf oder über deinem eigenen Rang
+ stehen nicht zur Wahl.
Vermerk (Pflicht)
+
`,
+ bestaetigenText: "Dienstgrad setzen",
+ bestaetigt: async (el, zu) => {
+ const vermerk = el.querySelector("[name=vermerk]").value.trim();
+ if (vermerk.length < 3) return meldung("Bitte einen Vermerk angeben.", "fehler");
+ try {
+ await aufruf("personal", "rolleAendern", {
+ charakterId: p.charakterId,
+ rolle: el.querySelector("[name=rolle]").value,
+ vermerk,
+ });
+ zu();
+ meldung("Dienstgrad geändert.", "gut");
+ oeffne(behaelter, p.charakterId);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ function abteilungsFenster(behaelter, d) {
+ const p = d.personal;
+
+ bestaetigen({
+ titel: "Abteilung ändern",
+ inhalt: `Abteilung
+ ${abteilungsFeld(p.abteilung)}
`,
+ bestaetigenText: "Versetzen",
+ bestaetigt: async (el, zu) => {
+ try {
+ await aufruf("personal", "abteilungAendern", {
+ charakterId: p.charakterId,
+ abteilung: el.querySelector("[name=abteilung]").value,
+ });
+ zu();
+ meldung("Abteilung geändert.", "gut");
+ oeffne(behaelter, p.charakterId);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ function notizFenster(behaelter, d) {
+ const p = d.personal;
+
+ fenster({
+ titel: "Personalnotiz",
+ inhalt: `Notiz (max. 255 Zeichen)
+
`,
+ knoepfe: [
+ { text: "Abbrechen", art: "leise", klick: (_, zu) => zu() },
+ { text: "Speichern", klick: async (el, zu) => {
+ try {
+ await aufruf("personal", "notiz", {
+ charakterId: p.charakterId,
+ notiz: el.querySelector("[name=notiz]").value.trim(),
+ });
+ zu();
+ meldung("Notiz gespeichert.", "gut");
+ oeffne(behaelter, p.charakterId);
+ } catch (f) { meldung(f.message, "fehler"); }
+ } },
+ ],
+ });
+ }
+
+ function entlassungsFenster(behaelter, d) {
+ const p = d.personal;
+
+ bestaetigen({
+ titel: "Beamten entlassen",
+ gefahr: true,
+ inhalt: `
+ ${sicher(p.name)} (${sicher(p.dienstnummer)}) verliert sofort allen Zugriff
+ und wird aus einem laufenden Dienst abgemeldet.
+ Der Personaldatensatz bleibt erhalten und kann später
+ wieder aktiviert werden — gelöscht wird nichts.
+ Begründung (Pflicht)
+
`,
+ bestaetigenText: "Entlassen",
+ bestaetigt: async (el, zu) => {
+ const grund = el.querySelector("[name=grund]").value.trim();
+ if (grund.length < 5) return meldung("Bitte eine Begründung angeben.", "fehler");
+ try {
+ await aufruf("personal", "entlassen", { charakterId: p.charakterId, grund });
+ zu();
+ meldung("Beamter entlassen.", "gut");
+ z.offen = null;
+ rendern(behaelter);
+ } catch (f) { meldung(f.message, "fehler"); }
+ },
+ });
+ }
+
+ /* ---- Einstellung ---------------------------------------------------- */
+
+ async function einstellungsFenster(behaelter) {
+ let gewaehlt = null; // ausgewählte Person aus der Suche
+
+ let vorschlag = "";
+ try {
+ const antwort = await aufruf("personal", "nummerVorschlag", {});
+ vorschlag = antwort.dienstnummer;
+ } catch (f) { /* Vorschlag ist optional */ }
+
+ const dialog = bestaetigen({
+ titel: "Beamten einstellen",
+ inhalt: `
+ Person suchen
+
+
+
Mindestens zwei Zeichen eingeben.
+
Mindestens zwei Zeichen eingeben.
`;
+ return;
+ }
+ try {
+ const antwort = await aufruf("personal", "personSuche", { begriff });
+ const treffer = antwort.treffer || [];
+ trefferliste.innerHTML = treffer.length
+ ? treffer.map((t) => `
+
+
+
${sicher(t.firstname)} ${sicher(t.lastname)}
+
geb. ${sicher(String(t.dob).slice(0, 10))}
+
+ ${t.dienstnummer && t.aktiv
+ ? `
bereits im Dienst `
+ : t.dienstnummer
+ ? `
ehemals ${sicher(t.dienstnummer)} `
+ : ""}
+
Keine Person gefunden.
`;
+
+ trefferliste.querySelectorAll("[data-person]").forEach((el) => {
+ el.addEventListener("click", () => {
+ const person = treffer.find((t) => t.id === +el.dataset.person);
+ if (person && person.dienstnummer && person.aktiv) {
+ return meldung("Diese Person ist bereits im Personalbestand.", "fehler");
+ }
+ gewaehlt = person;
+ trefferliste.querySelectorAll("[data-person]")
+ .forEach((zeile) => zeile.classList.remove("gewaehlt"));
+ el.classList.add("gewaehlt");
+ formular.style.display = "";
+ });
+ });
+ } catch (f) { meldung(f.message, "fehler"); }
+ }, 260);
+ });
+ },
+ });
+
+ return dialog;
+ }
+
+ /* ---- Laden ---------------------------------------------------------- */
+
+ async function oeffne(behaelter, charakterId) {
+ try {
+ const d = await aufruf("personal", "oeffnen", { charakterId });
+ z.offen = charakterId;
+ akte(behaelter, d);
+ } catch (f) { meldung(f.message, "fehler"); }
+ }
+
+ async function rendern(behaelter) {
+ try {
+ z.daten = await aufruf("personal", "liste", {
+ begriff: z.suche, rolle: z.filterRolle,
+ abteilung: z.filterAbteilung, ehemalige: z.ehemalige,
+ });
+
+ // Sprungziel aus einem anderen Modul, z. B. „Personalakte öffnen"
+ const ziel = App.zustand.modulZiel;
+ if (ziel && ziel.person) {
+ App.zustand.modulZiel = null;
+ return oeffne(behaelter, ziel.person);
+ }
+
+ if (z.offen) await oeffne(behaelter, z.offen);
+ else uebersicht(behaelter);
+ } catch (f) {
+ behaelter.innerHTML = `Personal
+
Konnte nicht geladen werden: ${sicher(f.message)}
+ ${wert}
+ ${sicher(text)}
+ ${unter ? `${sicher(unter)} ` : ""}
+
`;
+ }
+
+ /** Waagerechtes Balkendiagramm aus einer Verteilung */
+ function verteilung(daten, leer) {
+ if (!daten || !daten.eintraege.length) {
+ return `${sicher(leer || "Keine Daten im Zeitraum.")}
`;
+ }
+
+ return `
+ ${daten.eintraege.map((e) => `
+
+
${sicher(e.name)}
+
+
${zahl(e.anzahl)}
+
${e.anteil} %
+
`).join("")}
+
Im Zeitraum wurde nichts erfasst.
`;
+ }
+
+ // Höchstwert bestimmt die Skalierung beider Reihen
+ let hoechst = 1;
+ zeilen.forEach((t) => {
+ hoechst = Math.max(hoechst, +t.einsaetze || 0, +t.anzeigen || 0);
+ });
+
+ return `
+
+ Höchstwert: ${hoechst}
+
+
+ ${zeilen.map((t) => {
+ const einsaetze = +t.einsaetze || 0;
+ const anzeigen = +t.anzeigen || 0;
+ const tag = String(t.tag).slice(0, 10);
+ return `
+
+
+
${sicher(tag.slice(8))}
+
`;
+ }).join("")}
+
+
+ ${eintraege.map((e) => `
+
+ ${sicher(e.text)} `).join("")}
+
+
+ ${zeitraeume.map((t) => `
+
+ ${t} Tage `).join("")}
+
+
+
+
Statistik
+
Auswertung der letzten ${d.tage} Tage. Alle Zahlen beschreiben Vorgänge
+ der Behörde — es gibt hier keine Bewertung einzelner Beamter.
+
+
+ ${kachel(zahl(e.gesamt), "Einsätze", e.offen + " offen")}
+ ${kachel(zahl(a.gesamt), "Anzeigen", a.bestaetigt + " bestätigt")}
+ ${kachel(zahl(g.einweisungen), "Einweisungen", g.laufend + " laufend")}
+ ${kachel(zahl(p.dienstStunden), "Dienststunden", p.bestand + " Beamte im Bestand")}
+
+
+
+
Verlauf
+ ${verlauf(d.verlauf)}
+
+
+
Einsätze nach Kategorie
+ ${verteilung(e.nachKategorie)}
+
+ Ein Einsatz bleibt im Schnitt
+ ${zahl(e.laufzeitMinuten)} Minuten offen.
+
+
+
+
+
Einsätze nach Priorität
+ ${verteilung(e.nachPrioritaet)}
+
+
+
+
Anzeigen
+
+
Bestätigt ${zahl(a.bestaetigt)}
+
Noch Entwurf ${zahl(a.entwurf)}
+
Ø festgelegte Haft ${zahl(a.haftDurchschnitt)} Min
+
Ø festgelegte Geldstrafe ${euro(a.geldDurchschnitt)}
+
+
+ In ${zahl(a.abweichungen)} von ${zahl(a.bestaetigt)} bestätigten Anzeigen
+ wich die Entscheidung vom Katalogvorschlag ab. Das ist eine Aussage über den
+ Katalog — nicht über die Beamten.
+
+
+
+
+
Gewahrsam
+
+
Einweisungen ${zahl(g.einweisungen)}
+
Laufend ${zahl(g.laufend)}
+
Ø festgelegte Dauer ${zahl(g.haftDurchschnitt)} Min
+
Vorzeitig entlassen ${zahl(g.vorzeitig)}
+
+
+ Zwischen Fristablauf und tatsächlicher Entlassung lagen im Schnitt
+ ${zahl(g.verzugMinuten)} Minuten . Das System entlässt niemanden von
+ selbst — der Wert zeigt, wie schnell jemand erreichbar war.
+
+
+
+
+
Vorgänge
+
+
Akten angelegt ${zahl(v.akten)}
+
Akten offen ${zahl(v.aktenOffen)}
+
Berichte ${zahl(v.berichte)}
+
Berichte im Entwurf ${zahl(v.berichteEntwurf)}
+
Fahndungen ${zahl(v.fahndungen)}
+
Fahndungen aktiv ${zahl(v.fahndungenAktiv)}
+
Beweise erfasst ${zahl(v.beweise)}
+
Asservate eingelagert ${zahl(v.asservate)}
+
+
+
+
+
Akten nach Art
+ ${verteilung(v.aktenNachTyp)}
+
+
+
+ Personal nach Abteilung
+ ${p.imDienst} gerade im Dienst
+
+ ${verteilung(p.nachAbteilung)}
+
+
+
Dienstabdeckung
+
Mittlere Besetzung je Tageszeit über ${d.tage} Tage — ein Planungswert.
+ Er sagt nichts darüber, wer Dienst hatte.
+
+
+ ${kachel(zahl(d.schichten), "Schichten im Zeitraum")}
+ ${kachel(d.hoechstwert.toFixed(2), "stärkste Stunde", "gleichzeitig im Dienst")}
+ ${kachel(schwach.map((s) => s.stunde + " Uhr").join(", "), "dünnste Stunden")}
+
+
+
+
+ Besetzung nach Tageszeit
+ Durchschnittlich gleichzeitig im Dienst
+
+
+ ${d.stunden.map((s) => `
+
+
+
+
${String(s.stunde).padStart(2, "0")}
+
`).join("")}
+
+
+
Schichten nach Abteilung
+ ${verteilung(d.nachAbteilung)}
+
+
+
Katalogauswertung
+
Welche Delikte kommen vor und wie oft weicht die Entscheidung vom
+ Vorschlag ab. Eine hohe Abweichungsquote heißt: der Katalogwert passt
+ nicht — nicht, dass jemand falsch entschieden hat.
+
+
+ ${kachel(zahl(d.anzeigen), "ausgewertete Anzeigen", "letzte " + d.tage + " Tage")}
+ ${kachel(zahl(d.delikte.length), "verwendete Delikte")}
+ ${kachel(zahl(d.ungenutzt.length), "nie verwendet", "von " + d.katalogGesamt + " im Katalog")}
+
+
+
+
Häufigste Delikte
+ ${d.delikte.length ? `
+
+ ${d.delikte.map((delikt) => `
+
+
${sicher(delikt.kennung)}
+
+
${sicher(delikt.name)}
+
${sicher(delikt.paragraph || "")}
+
+
${zahl(delikt.anzahl)}×
+
0 ? "info" : "neutral"}"
+ title="Anteil der Anzeigen mit diesem Delikt, in denen vom Vorschlag abgewichen wurde">
+ ${delikt.abweichungsAnteil} % abweichend
+
`).join("")}
+
`
+ : `
Im Zeitraum wurde keine Anzeige bestätigt.
`}
+
+
+ Im Zeitraum nie verwendet
+ Kandidaten zum Aufräumen des Katalogs
+
+ ${d.ungenutzt.length ? `
+
+ ${d.ungenutzt.map((delikt) => `
+
+ ${sicher(delikt.kennung)} · ${sicher(delikt.bezeichnung)} `).join("")}
+
`
+ : `
Jedes Delikt des Katalogs kam vor.
`}
+
Statistik
+
Konnte nicht geladen werden: ${sicher(f.message)}
Aether — Shop
+
+
+
+
+
🛒
+
+
LS 24/7
+
● Geöffnet · Alles für den Alltag
+
+
+
+
+
+
+
+
+
+