Anmeldung und Rollen: eigene Zugänge, Benutzerverwaltung, Mitarbeiter-Ansicht (0.7.0)
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

Stufe 2, Schritt 1 (U1, U2, E27, P13). Passwörter mit scrypt, Sitzung als
HttpOnly-Cookie (90 Tage, gleitend), in der Datenbank nur der SHA-256.
Rollen Inhaber, Büro, Mitarbeiter; Mitarbeiter sehen nur eigene Einsätze
und die Ablage ihrer Projekte. Testversion ohne Passwörter mit Auswahl,
als wer gearbeitet wird. Anmeldung am Proxy entfällt.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
Claude
2026-10-20 06:26:05 +00:00
parent 212d8107a0
commit bc5e15339a
25 changed files with 1179 additions and 242 deletions

194
src/web/ui.ts Normal file
View File

@@ -0,0 +1,194 @@
// 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) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[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 */ }
}
/** Wird aufgerufen, wenn der Server „bitte anmelden“ meldet (Sitzung abgelaufen oder abgemeldet) */
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;
}
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][]> };
}
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?.();
});
}
export function dialog(titel: string, felder: Feld[], werte: Zeile, mitLoeschen: boolean): 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}">${optionenHtml(f.optionen!, v ?? "", f.bearbeiten)}</select>`;
} 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"' : ""}>`;
}
return `<label for="${id}">${esc(f.titel)}${f.pflicht ? " *" : ""}</label>${eingabe}${f.hilfe ? `<small class="hilfe">${esc(f.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);
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();
const daten: Zeile = {};
try {
for (const f of felder) {
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;
}
} catch (e) {
form.querySelector("#dialog-fehler")!.textContent = (e as Error).message;
return;
}
schliessen({ aktion: "speichern", daten });
});
});
}
export function bestaetigen(frage: string): Promise<boolean> {
return new Promise((fertig) => {
const box = document.createElement("div");
box.className = "dialog";
box.style.position = "fixed";
box.innerHTML = `<h2>${esc(frage)}</h2><div class="knoepfe"><button class="neben" data-a="nein">Abbrechen</button><button class="haupt" data-a="ja">Ja</button></div>`;
huelle.appendChild(box);
box.addEventListener("click", (ev) => {
const a = (ev.target as HTMLElement).dataset.a;
if (!a) return;
box.remove();
fertig(a === "ja");
});
});
}
export async function bearbeiten(pfad: string, titel: string, felder: Feld[], zeile: Zeile | null, vorgaben: Zeile = {}): Promise<boolean> {
const e = await dialog(titel, felder, zeile ?? vorgaben, !!zeile);
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: "" };
export function tabelle(spalten: { titel: string; wert: (z: Zeile) => string; klasse?: string }[], zeilen: Zeile[], klick?: (z: Zeile) => void): HTMLTableElement {
const t = document.createElement("table");
t.innerHTML = `<thead><tr>${spalten.map((s) => `<th class="${s.klasse ?? ""}">${esc(s.titel)}</th>`).join("")}</tr></thead>
<tbody>${zeilen.map((z, i) => `<tr data-i="${i}" class="${klick ? "klickbar" : ""}">${spalten.map((s) => `<td class="${s.klasse ?? ""}">${s.wert(z)}</td>`).join("")}</tr>`).join("")}</tbody>`;
if (klick) t.addEventListener("click", (ev) => {
const tr = (ev.target as HTMLElement).closest("tr[data-i]") as HTMLElement | null;
if (tr) klick(zeilen[Number(tr.dataset.i)]!);
});
return t;
}
// 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>${hinweis.text ? `<div class="warnung">${esc(hinweis.text)}</div>` : ""}`;
hinweis.text = "";
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;
}