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

167
src/web/anmeldung.ts Normal file
View File

@@ -0,0 +1,167 @@
// U1/U2 in der Oberfläche: Anmeldeseite, Einrichtung, wer angemeldet ist, Benutzerverwaltung.
import { type Feld, type Zeile, TEST_BENUTZER, api, dialog, esc, inhalt, merke, seite, tabelle } from "./ui.js";
export type Rolle = "inhaber" | "buero" | "mitarbeiter";
export interface Sitzung {
art: "passwort" | "testversion";
benutzer: { id: string | null; name: string; anmeldename: string; rolle: Rolle; kontakt_id: string | null } | null;
einrichtung: boolean;
auswahl?: { id: string; name: string; rolle: Rolle }[];
}
export const ROLLE_TEXT: Record<Rolle, string> = { inhaber: "Inhaber", buero: "Büro", mitarbeiter: "Mitarbeiter" };
/** Anmeldeseite, auf dem Server auch die Einrichtung beim ersten Start. Danach lädt die Seite neu. */
export function anmeldeSeite(s: Sitzung): void {
document.body.classList.add("abgemeldet");
const einrichtung = s.einrichtung;
inhalt.innerHTML = `<form class="anmeldung" autocomplete="on">
<img src="${esc((document.querySelector("#marke img") as HTMLImageElement | null)?.src ?? "")}" alt="Holzbau Schaarschmidt">
<h1>${einrichtung ? "Programm einrichten" : "Anmelden"}</h1>
${einrichtung ? `<p class="hinweis">Lege dich als Inhaber an. Den Einrichtungscode findest du im Protokoll des Servers.</p>
<label for="a-name">Dein Name</label><input id="a-name" autocomplete="name" required>` : ""}
<label for="a-anmeldename">Anmeldename</label><input id="a-anmeldename" autocomplete="username" autocapitalize="none" spellcheck="false" required>
<label for="a-passwort">Passwort</label><input id="a-passwort" type="password" autocomplete="${einrichtung ? "new-password" : "current-password"}" required>
${einrichtung ? `<label for="a-code">Einrichtungscode</label><input id="a-code" autocapitalize="none" spellcheck="false" required>` : ""}
<p class="fehler" id="a-fehler" role="alert"></p>
<button type="submit" class="haupt">${einrichtung ? "Einrichten und anmelden" : "Anmelden"}</button>
${einrichtung ? "" : '<p class="hinweis">Passwort vergessen? Henning vergibt dir ein neues.</p>'}
</form>`;
const form = inhalt.querySelector("form")!;
const wert = (id: string) => (form.querySelector(`#${id}`) as HTMLInputElement | null)?.value ?? "";
(form.querySelector("input") as HTMLInputElement).focus();
form.addEventListener("submit", async (ev) => {
ev.preventDefault();
const knopf = form.querySelector("button")!;
knopf.disabled = true;
try {
if (einrichtung) await api("einrichtung", "POST", { name: wert("a-name"), anmeldename: wert("a-anmeldename"), passwort: wert("a-passwort"), code: wert("a-code") });
else await api("anmeldung", "POST", { anmeldename: wert("a-anmeldename"), passwort: wert("a-passwort") });
location.reload();
} catch (e) {
form.querySelector("#a-fehler")!.textContent = (e as Error).message;
knopf.disabled = false;
}
});
}
/** Unten in der Seitenleiste: wer angemeldet ist. Testversion: Auswahl, als wer gearbeitet wird. */
export function werLeiste(s: Sitzung): void {
const ziel = document.getElementById("wer");
const b = s.benutzer;
if (!ziel || !b) return;
if (s.art === "testversion") {
const auswahl = s.auswahl ?? [];
ziel.innerHTML = auswahl.length
? `<label for="wer-wahl">Arbeiten als</label><select id="wer-wahl">${auswahl.map((x) =>
`<option value="${esc(x.id)}"${x.id === b.id ? " selected" : ""}>${esc(x.name)} (${ROLLE_TEXT[x.rolle]})</option>`).join("")}</select>`
: `<span>${esc(b.name)} · ${ROLLE_TEXT[b.rolle]}</span>`;
const wahl = ziel.querySelector<HTMLSelectElement>("#wer-wahl");
if (wahl) wahl.onchange = () => {
merke(TEST_BENUTZER, wahl.value);
location.hash = "";
location.reload();
};
return;
}
const kurz = b.name.split(/\s+/).map((t) => t[0]).join("").slice(0, 2).toUpperCase();
ziel.innerHTML = `<span>${esc(b.name)}<small>${ROLLE_TEXT[b.rolle]}</small></span>
<button class="verweis" data-a="passwort">Passwort ändern</button> <button class="verweis" data-a="abmelden">Abmelden</button>
<button class="konto" data-a="menue" aria-label="${esc(b.name)}: Konto">${esc(kurz)}</button>`;
ziel.onclick = async (ev) => {
let a = (ev.target as HTMLElement).closest<HTMLElement>("[data-a]")?.dataset.a;
// am Handy: ein Knopf mit den Initialen, dahinter Passwort ändern und Abmelden
if (a === "menue") a = await auswahl(`${b.name} (${ROLLE_TEXT[b.rolle]})`, [["passwort", "Passwort ändern"], ["abmelden", "Abmelden"]]);
if (a === "abmelden") {
await api("abmeldung", "POST").catch(() => {});
location.hash = "";
location.reload();
}
if (a === "passwort") await passwortAendern();
};
}
/** Kleiner eigener Auswahldialog (keine Browser-Abfragen) */
function auswahl(titel: string, knoepfe: [string, string][]): Promise<string | undefined> {
return new Promise((fertig) => {
const huelle = document.getElementById("dialog-huelle")!;
huelle.innerHTML = `<div class="dialog"><h2>${esc(titel)}</h2><div class="knoepfe">${knoepfe.map(([a, t]) =>
`<button class="neben" data-w="${esc(a)}">${esc(t)}</button>`).join("")}<button class="neben" data-w="">Schließen</button></div></div>`;
huelle.hidden = false;
huelle.onclick = (ev) => {
const w = (ev.target as HTMLElement).closest<HTMLElement>("[data-w]")?.dataset.w;
if (w === undefined) return;
huelle.hidden = true;
huelle.innerHTML = "";
huelle.onclick = null;
fertig(w || undefined);
};
});
}
export async function passwortAendern(): Promise<void> {
const felder: Feld[] = [
{ name: "alt", titel: "Bisheriges Passwort", art: "passwort", pflicht: true },
{ name: "neu", titel: "Neues Passwort", art: "passwort", pflicht: true, hilfe: "Mindestens 8 Zeichen. Andere Geräte werden abgemeldet." },
];
for (;;) {
const r = await dialog("Passwort ändern", felder, {}, false);
if (r?.aktion !== "speichern") return;
try {
await api("ich/passwort", "POST", r.daten);
return;
} catch (e) {
felder[0]!.hilfe = (e as Error).message;
}
}
}
// ---------- Benutzerverwaltung (nur Inhaber) ----------
export async function benutzerSeite(s: Sitzung): Promise<void> {
const [liste, kontakte] = await Promise.all([api<Zeile[]>("benutzer"), api<Zeile[]>("kontakte")]);
const mitarbeiter = kontakte.filter((k) => k.rolle === "mitarbeiter");
const kontaktName = Object.fromEntries(kontakte.map((k) => [k.id, k.name]));
const testversion = s.art === "testversion";
const felder = (neu: boolean): Feld[] => [
{ name: "name", titel: "Name", pflicht: true },
{ name: "anmeldename", titel: "Anmeldename", pflicht: true, hilfe: "Kleinbuchstaben ohne Leerzeichen, z. B. jan oder j.meier" },
{ name: "rolle", titel: "Rolle", art: "auswahl", optionen: [["mitarbeiter", "Mitarbeiter: eigene Einsätze und Stunden am Handy"], ["buero", "Büro: alles außer Löhnen, Jahresplan, BWA"], ["inhaber", "Inhaber: alles"]] },
{ name: "kontakt_id", titel: "Kontakt (für Einsätze und Stunden)", art: "auswahl",
optionen: [["", "– bei Mitarbeitern automatisch anlegen –"], ...mitarbeiter.map((k): [string, string] => [k.id, k.name])] },
...(testversion ? [] : [{ name: "passwort", titel: neu ? "Passwort" : "Neues Passwort", art: "passwort" as const,
hilfe: neu ? "Mindestens 8 Zeichen. Sag es der Person persönlich." : "Leer lassen, um das bisherige zu behalten. Ein neues meldet alle Geräte dieser Person ab." }]),
{ name: "aktiv", titel: "Zugang", art: "auswahl", optionen: [["ja", "aktiv"], ["nein", "gesperrt"]] },
];
const ausDialog = (d: Zeile) => ({ ...d, aktiv: d.aktiv !== "nein", kontakt_id: d.kontakt_id || null, passwort: d.passwort || undefined });
const oeffnen = async (z: Zeile | null) => {
const werte = z ? { ...z, aktiv: z.aktiv ? "ja" : "nein", kontakt_id: z.kontakt_id ?? "" } : { rolle: "mitarbeiter", aktiv: "ja" };
const f = felder(!z);
for (;;) {
const r = await dialog(z ? z.name : "Neuer Benutzer", f, werte, !!z && z.id !== s.benutzer?.id);
if (!r) return;
try {
if (r.aktion === "loeschen") await api(`benutzer/${z!.id}`, "DELETE");
else if (z) await api(`benutzer/${z.id}`, "PATCH", ausDialog(r.daten));
else await api("benutzer", "POST", ausDialog(r.daten));
return benutzerSeite(s);
} catch (e) {
if (r.aktion === "speichern") Object.assign(werte, r.daten);
f.at(-1)!.hilfe = (e as Error).message;
}
}
};
seite("Benutzer", { text: "Neuer Benutzer", aktion: () => void oeffnen(null) });
inhalt.appendChild(tabelle([
{ titel: "Name", wert: (z) => esc(z.name) },
{ titel: "Anmeldename", wert: (z) => esc(z.anmeldename), klasse: "optional" },
{ titel: "Rolle", wert: (z) => esc(ROLLE_TEXT[z.rolle as Rolle]) },
{ titel: "Kontakt", wert: (z) => esc(kontaktName[z.kontakt_id] ?? ""), klasse: "optional" },
...(testversion ? [] : [{ titel: "Passwort", wert: (z: Zeile) => (z.hat_passwort ? "vergeben" : '<span class="fehler">fehlt</span>') }]),
{ titel: "Zugang", wert: (z) => (z.aktiv ? "aktiv" : '<span class="fehler">gesperrt</span>') },
], liste, (z) => void oeffnen(z)));
inhalt.insertAdjacentHTML("beforeend", testversion
? `<p class="hinweis">Testversion: Passwörter gibt es erst auf dem Server. Unten links wählst du, als wer du arbeitest, und siehst so z. B. die Mitarbeiter-Ansicht.</p>`
: `<p class="hinweis">Mitarbeiter sehen am Handy nur ihre eigenen Einsätze mit Adresse, ihre Stunden und die Ablage ihrer Projekte, keine Beträge. Das Büro sieht alles außer Löhnen, Jahresplan, BWA und dieser Seite.</p>`);
}