Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
332 lines
18 KiB
TypeScript
332 lines
18 KiB
TypeScript
// Bausteine der Oberfläche: Abruf, eigene Dialoge (keine Browser-Abfragen), Tabellen, Seitenkopf.
|
|
|
|
import { formatEuro, parseEuro } from "../domain/geld.js";
|
|
import { formatDatum } from "../domain/datum.js";
|
|
|
|
export type Zeile = Record<string, any>;
|
|
|
|
// ---------- Hilfen ----------
|
|
|
|
export function esc(v: unknown): string {
|
|
return String(v ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" })[c]!);
|
|
}
|
|
|
|
/** Testversion: als wer Henning gerade arbeitet (Benutzer-ID), damit er die Mitarbeiter-Ansicht ausprobieren kann */
|
|
export const TEST_BENUTZER = "betrieb-test-benutzer";
|
|
export function lies(schluessel: string): string | null {
|
|
try { return localStorage.getItem(schluessel); } catch { return null; }
|
|
}
|
|
export function merke(schluessel: string, wert: string | null): void {
|
|
try { if (wert === null) localStorage.removeItem(schluessel); else localStorage.setItem(schluessel, wert); } catch { /* ohne Speicher */ }
|
|
}
|
|
|
|
// Handy (Henning, 21.10.2026): schmaler Bildschirm = Handy-Ansicht, außer er erzwingt unter „Mehr“ die PC-Ansicht.
|
|
// Erzwungen werden die Handy-Regeln der Stilvorlage abgeschaltet und die Seite passend verkleinert.
|
|
export const PC_ANSICHT = "betrieb-pc-ansicht";
|
|
export const istHandy = () => !lies(PC_ANSICHT) && matchMedia("(max-width: 640px)").matches;
|
|
export function pcAnsichtAnwenden(): void {
|
|
const pc = !!lies(PC_ANSICHT);
|
|
for (const blatt of [...document.styleSheets]) {
|
|
let regeln: CSSRuleList;
|
|
try { regeln = blatt.cssRules; } catch { continue; }
|
|
for (const r of [...regeln]) {
|
|
if (!(r instanceof CSSMediaRule)) continue;
|
|
const t = r.media.mediaText;
|
|
if (pc && t.includes("max-width: 640px")) r.media.mediaText = t.replace("max-width: 640px", "max-width: 1px");
|
|
else if (!pc && t.includes("max-width: 1px")) r.media.mediaText = t.replace("max-width: 1px", "max-width: 640px");
|
|
}
|
|
}
|
|
document.documentElement.classList.toggle("pc-erzwungen", pc);
|
|
document.documentElement.style.zoom = pc && innerWidth < 1100 ? String(Math.max(0.3, innerWidth / 1100)) : "";
|
|
}
|
|
|
|
/** Wird aufgerufen, wenn der Server „bitte anmelden“ meldet (Sitzung abgelaufen oder abgemeldet) */
|
|
/** Abschaltbare Teile (Einstellungen → module); kommt mit der Sitzung, fehlt ein Eintrag, ist der Teil an */
|
|
export const MODULE: Record<string, boolean> = {};
|
|
export const modulAn = (m: "angebote" | "zeiterfassung" | "stundensaetze" | "jahresplanung") => MODULE[m] !== false;
|
|
export const abgemeldet = { melden: () => {} };
|
|
|
|
export async function api<T = any>(pfad: string, methode = "GET", body?: unknown): Promise<T> {
|
|
const kopf: Record<string, string> = body === undefined ? {} : { "content-type": "application/json" };
|
|
const test = lies(TEST_BENUTZER);
|
|
if (test) kopf["x-test-benutzer"] = test;
|
|
const r = await fetch(`/api/${pfad}`, { method: methode, headers: kopf, body: body === undefined ? undefined : JSON.stringify(body) });
|
|
if (r.status === 401 && !["sitzung", "anmeldung"].includes(pfad)) abgemeldet.melden();
|
|
if (r.status === 204) return undefined as T;
|
|
const j = await r.json().catch(() => ({}));
|
|
if (!r.ok) throw new Error([j.fehler ?? `Fehler ${r.status}`, ...(j.details ?? [])].join("\n"));
|
|
return j as T;
|
|
}
|
|
|
|
/** Eine Datei vom Server holen und speichern lassen (Testversion: über das Speichern der Artifact-Seite). Gibt eine Meldung zurück. */
|
|
export async function dateiSpeichern(pfad: string, dateiname: string): Promise<string> {
|
|
const kopf: Record<string, string> = {};
|
|
const test = lies(TEST_BENUTZER);
|
|
if (test) kopf["x-test-benutzer"] = test;
|
|
const r = await fetch(`/api/${pfad}`, { headers: kopf });
|
|
if (!r.ok) {
|
|
const j = await r.json().catch(() => ({}));
|
|
throw new Error(j.fehler ?? `Fehler ${r.status}`);
|
|
}
|
|
const tv = (globalThis as { betriebTestversion?: { datei?(name: string, text: string): Promise<string> } }).betriebTestversion;
|
|
// ignoreBOM: das BOM am Anfang muss mit, sonst zeigt Excel die Umlaute falsch
|
|
if (tv?.datei) return tv.datei(dateiname, new TextDecoder("utf-8", { ignoreBOM: true }).decode(await r.arrayBuffer()));
|
|
const url = URL.createObjectURL(await r.blob());
|
|
const a = Object.assign(document.createElement("a"), { href: url, download: dateiname });
|
|
document.body.appendChild(a);
|
|
a.click();
|
|
a.remove();
|
|
setTimeout(() => URL.revokeObjectURL(url), 10000);
|
|
return "";
|
|
}
|
|
|
|
export const inhalt = document.getElementById("inhalt")!;
|
|
export const huelle = document.getElementById("dialog-huelle")!;
|
|
export const heute = () => new Date().toISOString().slice(0, 10);
|
|
export const euro = (c: number | null | undefined) => (c == null ? "" : formatEuro(c));
|
|
export const dat = (d: string | null | undefined) => (d ? formatDatum(d) : "");
|
|
export const MONATSNAMEN = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
|
|
|
|
// ---------- Eigene Dialoge (keine Browser-Abfragen) ----------
|
|
|
|
export interface Feld {
|
|
name: string;
|
|
titel: string;
|
|
art?: "text" | "euro" | "datum" | "auswahl" | "zahl" | "langtext" | "passwort";
|
|
/** kleiner Hinweis unter dem Feld */
|
|
hilfe?: string;
|
|
optionen?: [string, string][];
|
|
pflicht?: boolean;
|
|
/** Auswahl mit letztem Eintrag „… bearbeiten“: öffnet einen Editor und liefert die neuen Optionen */
|
|
bearbeiten?: { text: string; aktion: () => Promise<[string, string][]> };
|
|
/** Auswahl mit Eintrag „+ Neu …“ oben: kleine Maske direkt unter dem Feld, der Dialog bleibt offen (Henning, 26.10.2026) */
|
|
neu?: { text: string; titel: string; felder: Feld[]; anlegen: (daten: Zeile) => Promise<[string, string]> };
|
|
/** Umschaltknopf rechts neben einer Auswahl, z. B. vor | nach (Henning, 26.10.2026); Titel und Hinweis wechseln mit,
|
|
* der Wert landet unter `name` in den Daten; ohne gewählten Eintrag ist der Knopf verborgen */
|
|
umschalter?: { name: string; optionen: [string, string][]; titel?: Record<string, string>; hilfe?: Record<string, string> };
|
|
}
|
|
export const NEU = "__neu";
|
|
|
|
export const BEARBEITEN = "__bearbeiten";
|
|
export const optionenHtml = (optionen: [string, string][], wert: string, bearbeiten?: Feld["bearbeiten"]) =>
|
|
optionen.map(([w, t]) => `<option value="${esc(w)}"${w === wert ? " selected" : ""}>${esc(t)}</option>`).join("")
|
|
+ (bearbeiten ? `<option value="${BEARBEITEN}">${esc(bearbeiten.text)}</option>` : "");
|
|
|
|
/** Ein Auswahlfeld mit Eintrag „… bearbeiten“ verdrahten: nach dem Bearbeiten neue Optionen, alte Wahl bleibt. */
|
|
export function bearbeitbareAuswahl(sel: HTMLSelectElement, b: NonNullable<Feld["bearbeiten"]>, geaendert?: () => void): void {
|
|
let vorher = sel.value;
|
|
sel.addEventListener("change", async () => {
|
|
if (sel.value !== BEARBEITEN) { vorher = sel.value; geaendert?.(); return; }
|
|
const neu = await b.aktion();
|
|
sel.innerHTML = optionenHtml(neu, neu.some(([w]) => w === vorher) ? vorher : "", b);
|
|
vorher = sel.value;
|
|
geaendert?.();
|
|
});
|
|
}
|
|
|
|
/** Prüfung vor dem Schließen: Fehlertext, optional mit Knopf, der einen Wert einsetzt (z. B. nächste freie Nummer) */
|
|
export type DialogPruefung = (daten: Zeile) => { fehler: string; vorschlag?: { feld: string; wert: string; text: string } } | null;
|
|
|
|
export function dialog(titel: string, felder: Feld[], werte: Zeile, mitLoeschen: boolean, pruefe?: DialogPruefung): Promise<{ aktion: "speichern"; daten: Zeile } | { aktion: "loeschen" } | null> {
|
|
return new Promise((fertig) => {
|
|
const feldHtml = felder
|
|
.map((f) => {
|
|
const v = werte[f.name];
|
|
const id = `f-${f.name}`;
|
|
let eingabe: string;
|
|
if (f.art === "auswahl") {
|
|
eingabe = `<select id="${id}">${f.neu ? `<option value="${NEU}">${esc(f.neu.text)}</option>` : ""}${optionenHtml(f.optionen!, v ?? "", f.bearbeiten)}</select>`;
|
|
if (f.neu) eingabe += `<div class="unterform" data-neu="${f.name}" hidden><h3>${esc(f.neu.titel)}</h3>${f.neu.felder.map((u) =>
|
|
`<label for="fn-${u.name}">${esc(u.titel)}${u.pflicht ? " *" : ""}</label><input id="fn-${u.name}" type="text">`).join("")}
|
|
<p class="fehler"></p><div class="knoepfe"><button type="button" class="neben" data-a="neu-abbrechen">Abbrechen</button><button type="button" class="haupt" data-a="neu-anlegen">Anlegen</button></div></div>`;
|
|
if (f.umschalter) {
|
|
const u = f.umschalter, an = werte[u.name] ?? u.optionen[0]![0];
|
|
eingabe = `<div class="mit-umschalter">${eingabe}<div class="um-knopf" role="group" data-um="${f.name}"${v ? "" : " hidden"}>${u.optionen.map(([w, t]) =>
|
|
`<button type="button" data-wert="${esc(w)}" aria-pressed="${w === an}"${w === an ? ' class="an"' : ""}>${esc(t)}</button>`).join("")}</div></div>`;
|
|
}
|
|
} else if (f.art === "langtext") {
|
|
eingabe = `<textarea id="${id}" rows="3">${esc(v)}</textarea>`;
|
|
} else {
|
|
const typ = f.art === "datum" ? "date" : f.art === "passwort" ? "password" : "text";
|
|
const anzeige = f.art === "euro" && v != null ? formatEuro(v, false) : v;
|
|
eingabe = `<input id="${id}" type="${typ}" value="${esc(anzeige)}"${f.art === "euro" || f.art === "zahl" ? ' inputmode="decimal"' : ""}${f.art === "passwort" ? ' autocomplete="new-password"' : ""}>`;
|
|
}
|
|
const an = f.umschalter ? werte[f.umschalter.name] ?? f.umschalter.optionen[0]![0] : "";
|
|
const titelText = f.umschalter?.titel?.[an] ?? f.titel, hilfe = (v && f.umschalter?.hilfe?.[an]) || f.hilfe;
|
|
return `<label for="${id}">${esc(titelText)}${f.pflicht ? " *" : ""}</label>${eingabe}${hilfe ? `<small class="hilfe" data-hilfe="${f.name}">${esc(hilfe)}</small>` : ""}`;
|
|
})
|
|
.join("");
|
|
huelle.innerHTML = `<form class="dialog"><h2>${esc(titel)}</h2>${feldHtml}<p class="fehler" id="dialog-fehler"></p>
|
|
<div class="knoepfe">${mitLoeschen ? '<button type="button" class="neben links" data-a="loeschen">Löschen</button>' : ""}
|
|
<button type="button" class="neben" data-a="abbrechen">Abbrechen</button><button type="submit" class="haupt">Speichern</button></div></form>`;
|
|
huelle.hidden = false;
|
|
const form = huelle.querySelector("form")!;
|
|
const schliessen = (e: Parameters<typeof fertig>[0]) => {
|
|
huelle.hidden = true;
|
|
huelle.innerHTML = "";
|
|
document.removeEventListener("keydown", taste);
|
|
fertig(e);
|
|
};
|
|
const taste = (ev: KeyboardEvent) => ev.key === "Escape" && schliessen(null);
|
|
document.addEventListener("keydown", taste);
|
|
(form.querySelector("input,select,textarea") as HTMLElement | null)?.focus();
|
|
for (const f of felder) if (f.bearbeiten) bearbeitbareAuswahl(form.querySelector(`#f-${f.name}`)!, f.bearbeiten);
|
|
// Umschaltknopf: Wahl merken, Titel und Hinweis mitziehen; ohne Auswahl verborgen
|
|
const umWert = new Map<string, string>();
|
|
for (const f of felder) {
|
|
const u = f.umschalter;
|
|
if (!u) continue;
|
|
const sel = form.querySelector<HTMLSelectElement>(`#f-${f.name}`)!, knopf = form.querySelector<HTMLElement>(`[data-um="${f.name}"]`)!;
|
|
const zeigen = () => {
|
|
const w = umWert.get(f.name)!;
|
|
for (const b of knopf.querySelectorAll<HTMLButtonElement>("button")) { b.classList.toggle("an", b.dataset.wert === w); b.setAttribute("aria-pressed", String(b.dataset.wert === w)); }
|
|
knopf.hidden = !sel.value;
|
|
const l = form.querySelector(`label[for="f-${f.name}"]`);
|
|
if (l) l.textContent = (u.titel?.[w] ?? f.titel) + (f.pflicht ? " *" : "");
|
|
let h = form.querySelector<HTMLElement>(`[data-hilfe="${f.name}"]`);
|
|
const text = (sel.value && u.hilfe?.[w]) || f.hilfe || "";
|
|
if (!h && text) { h = document.createElement("small"); h.className = "hilfe"; h.dataset.hilfe = f.name; sel.closest(".mit-umschalter")!.after(h); }
|
|
if (h) { h.textContent = text; h.hidden = !text; }
|
|
};
|
|
umWert.set(f.name, werte[u.name] ?? u.optionen[0]![0]);
|
|
knopf.addEventListener("click", (ev) => {
|
|
const w = (ev.target as HTMLElement).closest<HTMLElement>("[data-wert]")?.dataset.wert;
|
|
if (w) { umWert.set(f.name, w); zeigen(); }
|
|
});
|
|
sel.addEventListener("change", zeigen);
|
|
}
|
|
// „+ Neu …“: Maske unter der Auswahl öffnen, anlegen, neuen Eintrag auswählen; Abbrechen stellt die alte Wahl wieder her
|
|
const neuAnlegen = new Map<string, () => Promise<void>>();
|
|
for (const f of felder) {
|
|
if (!f.neu) continue;
|
|
const sel = form.querySelector<HTMLSelectElement>(`#f-${f.name}`)!, box = form.querySelector<HTMLElement>(`[data-neu="${f.name}"]`)!;
|
|
let vorher = sel.value;
|
|
const zu = (wert: string) => { box.hidden = true; sel.value = wert; vorher = wert; sel.focus(); };
|
|
sel.addEventListener("change", () => {
|
|
if (sel.value !== NEU) { vorher = sel.value; box.hidden = true; return; }
|
|
box.hidden = false;
|
|
box.querySelector<HTMLElement>(".fehler")!.textContent = "";
|
|
for (const i of box.querySelectorAll("input")) i.value = "";
|
|
box.querySelector("input")?.focus();
|
|
});
|
|
const anlegen = async () => {
|
|
const daten: Zeile = {};
|
|
try {
|
|
for (const u of f.neu!.felder) {
|
|
const roh = box.querySelector<HTMLInputElement>(`#fn-${u.name}`)!.value.trim();
|
|
if (u.pflicht && !roh) throw new Error(`${u.titel} fehlt`);
|
|
daten[u.name] = roh || null;
|
|
}
|
|
const [wert, text] = await f.neu!.anlegen(daten);
|
|
const o = document.createElement("option");
|
|
o.value = wert; o.textContent = text;
|
|
sel.querySelector(`option[value="${NEU}"]`)!.after(o);
|
|
zu(wert);
|
|
} catch (e) { box.querySelector<HTMLElement>(".fehler")!.textContent = (e as Error).message; }
|
|
};
|
|
neuAnlegen.set(f.name, anlegen);
|
|
box.addEventListener("click", (ev) => {
|
|
const a = (ev.target as HTMLElement).dataset.a;
|
|
if (a === "neu-anlegen") void anlegen();
|
|
if (a === "neu-abbrechen") zu(vorher);
|
|
});
|
|
}
|
|
form.addEventListener("click", (ev) => {
|
|
const a = (ev.target as HTMLElement).dataset.a;
|
|
if (a === "abbrechen") schliessen(null);
|
|
if (a === "loeschen") bestaetigen("Wirklich löschen?").then((ja) => ja && schliessen({ aktion: "loeschen" }));
|
|
});
|
|
form.addEventListener("submit", (ev) => {
|
|
ev.preventDefault();
|
|
// Enter in der kleinen Maske legt dort an, statt den ganzen Dialog zu speichern
|
|
const offen = (document.activeElement as HTMLElement | null)?.closest<HTMLElement>("[data-neu]");
|
|
if (offen) { void neuAnlegen.get(offen.dataset.neu!)?.(); return; }
|
|
const daten: Zeile = {};
|
|
try {
|
|
for (const f of felder) {
|
|
if (f.neu && (form.querySelector(`#f-${f.name}`) as HTMLSelectElement).value === NEU) throw new Error(`${f.titel}: bitte erst anlegen oder abbrechen`);
|
|
const wert = (form.querySelector(`#f-${f.name}`) as HTMLInputElement).value;
|
|
const roh = f.art === "passwort" ? wert : wert.trim();
|
|
if (f.pflicht && !roh) throw new Error(`${f.titel} fehlt`);
|
|
if (f.art === "euro") daten[f.name] = roh ? parseEuro(roh) : f.pflicht ? 0 : null;
|
|
else if (f.art === "zahl") daten[f.name] = roh ? Number(roh.replace(",", ".")) : null;
|
|
else daten[f.name] = roh || null;
|
|
if (f.umschalter) daten[f.umschalter.name] = umWert.get(f.name);
|
|
}
|
|
} catch (e) {
|
|
form.querySelector("#dialog-fehler")!.textContent = (e as Error).message;
|
|
return;
|
|
}
|
|
const p = pruefe?.(daten);
|
|
if (p) {
|
|
const f = form.querySelector<HTMLElement>("#dialog-fehler")!;
|
|
f.textContent = p.fehler;
|
|
if (p.vorschlag) {
|
|
const v = p.vorschlag, b = document.createElement("button");
|
|
b.type = "button"; b.className = "neben vorschlag-knopf"; b.textContent = v.text;
|
|
b.onclick = () => { const i = form.querySelector<HTMLInputElement>(`#f-${v.feld}`); if (i) { i.value = v.wert; i.focus(); } f.textContent = ""; };
|
|
f.append(" ", b);
|
|
}
|
|
return;
|
|
}
|
|
schliessen({ aktion: "speichern", daten });
|
|
});
|
|
});
|
|
}
|
|
|
|
export function bestaetigen(frage: string, o: { hinweis?: string; ja?: string; nein?: string } = {}): Promise<boolean> {
|
|
return new Promise((fertig) => {
|
|
// außerhalb eines Dialogs ist die Hülle verborgen: dann für die Frage zeigen und danach wieder verbergen
|
|
const warVerborgen = huelle.hidden;
|
|
huelle.hidden = false;
|
|
const box = document.createElement("div");
|
|
box.className = "dialog";
|
|
box.style.position = "fixed";
|
|
box.innerHTML = `<h2>${esc(frage)}</h2>${o.hinweis ? `<p class="hinweis">${esc(o.hinweis)}</p>` : ""}<div class="knoepfe"><button class="neben" data-a="nein">${esc(o.nein ?? "Abbrechen")}</button><button class="haupt" data-a="ja">${esc(o.ja ?? "Ja")}</button></div>`;
|
|
huelle.appendChild(box);
|
|
box.querySelector<HTMLButtonElement>('[data-a="ja"]')!.focus();
|
|
box.addEventListener("click", (ev) => {
|
|
const a = (ev.target as HTMLElement).dataset.a;
|
|
if (!a) return;
|
|
box.remove();
|
|
if (warVerborgen) huelle.hidden = true;
|
|
fertig(a === "ja");
|
|
});
|
|
});
|
|
}
|
|
|
|
export async function bearbeiten(pfad: string, titel: string, felder: Feld[], zeile: Zeile | null, vorgaben: Zeile = {}, loeschbar = true): Promise<boolean> {
|
|
const e = await dialog(titel, felder, zeile ?? vorgaben, !!zeile && loeschbar);
|
|
if (!e) return false;
|
|
let antwort: Zeile | undefined;
|
|
if (e.aktion === "loeschen") await api(`${pfad}/${zeile!.id}`, "DELETE");
|
|
else if (zeile) antwort = await api(`${pfad}/${zeile.id}`, "PATCH", e.daten);
|
|
else antwort = await api(pfad, "POST", { ...vorgaben, ...e.daten });
|
|
// gespeichert, aber z. B. der Projektordner in der Nextcloud hat nicht geklappt
|
|
if (antwort?.ordner_fehler) hinweis.text = antwort.ordner_fehler;
|
|
return true;
|
|
}
|
|
|
|
/** Hinweis, der nach dem nächsten Neuaufbau der Seite oben steht */
|
|
export const hinweis = { text: "", gut: false };
|
|
export const hinweisHtml = () => (hinweis.text ? `<div class="${hinweis.gut ? "erfolg" : "warnung"}" role="status">${esc(hinweis.text)}</div>` : "");
|
|
|
|
// Kopf wie bei Plancraft: Titel links, Hauptknopf rechts; darunter eine Leiste für Filter
|
|
export function seite(titel: string, knopf?: { text: string; aktion: () => void }): HTMLElement {
|
|
inhalt.innerHTML = `<div class="kopf"><h1>${esc(titel)}</h1></div>${hinweisHtml()}`;
|
|
hinweis.text = "";
|
|
hinweis.gut = false;
|
|
if (knopf) {
|
|
const b = document.createElement("button");
|
|
b.className = "haupt";
|
|
b.textContent = knopf.text;
|
|
b.onclick = knopf.aktion;
|
|
inhalt.firstElementChild!.appendChild(b);
|
|
}
|
|
const leiste = document.createElement("div");
|
|
leiste.className = "leiste";
|
|
inhalt.appendChild(leiste);
|
|
return leiste;
|
|
}
|
|
|