Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
174 lines
9.8 KiB
TypeScript
174 lines
9.8 KiB
TypeScript
// 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 } from "./ui.js";
|
||
import { liste as tabelle } from "./liste.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 }[];
|
||
module?: Record<string, boolean>;
|
||
}
|
||
|
||
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({
|
||
schluessel: "benutzer", einheit: ["Benutzer", "Benutzer"],
|
||
spalten: [
|
||
{ id: "name", titel: "Name", wert: (z) => esc(z.name) },
|
||
{ id: "anmeldename", titel: "Anmeldename", wert: (z) => esc(z.anmeldename), klasse: "optional" },
|
||
{ id: "rolle", titel: "Rolle", wert: (z) => esc(ROLLE_TEXT[z.rolle as Rolle]) },
|
||
{ id: "kontakt", titel: "Kontakt", wert: (z) => esc(kontaktName[z.kontakt_id] ?? ""), klasse: "optional" },
|
||
...(testversion ? [] : [{ id: "passwort", titel: "Passwort", wert: (z: Zeile) => (z.hat_passwort ? "vergeben" : '<span class="fehler">fehlt</span>') }]),
|
||
{ id: "zugang", titel: "Zugang", wert: (z) => (z.aktiv ? "aktiv" : '<span class="fehler">gesperrt</span>') },
|
||
],
|
||
zeilen: liste, klick: (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>`);
|
||
}
|