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

292
src/server/anmeldung.ts Normal file
View File

@@ -0,0 +1,292 @@
// U1/U2: Anmeldung und Rollen (Stufe 2).
// Auf dem Server meldet sich jeder mit Anmeldename und Passwort an; das Gerät bleibt 90 Tage angemeldet (Cookie).
// In der Testversion im Browser gibt es keine Passwörter: dort wählt Henning, als wer er arbeitet.
import type { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
import { z } from "zod";
import { type Pool, transaktion } from "./db.js";
import { hashePasswort, neuerSchluessel, passwortFehler, pruefePasswort, schluesselId } from "./passwort.js";
export type Rolle = "inhaber" | "buero" | "mitarbeiter";
export const ROLLEN: Rolle[] = ["inhaber", "buero", "mitarbeiter"];
export interface Angemeldet {
/** null: Testversion ohne angelegte Benutzer, oder interne Aufrufe der Testversion */
id: string | null;
anmeldename: string;
name: string;
rolle: Rolle;
kontakt_id: string | null;
}
declare module "fastify" {
interface FastifyRequest { wer?: Angemeldet }
}
export type Anmeldeart = "passwort" | "testversion";
const COOKIE = "betrieb";
const TAGE = 90;
const SEKUNDEN = TAGE * 24 * 3600;
/** Wer welche Route aufrufen darf. Alles, was hier nicht steht, ist für Inhaber und Büro. */
type Recht = "offen" | "alle" | "buero" | "inhaber";
const OFFEN = new Set(["GET /api/status", "GET /api/sitzung", "POST /api/anmeldung", "POST /api/abmeldung", "POST /api/einrichtung"]);
const ALLE = new Set(["GET /api/projekte/:id/ablage", "GET /api/projekte/:id/ablage/datei"]);
const INHABER = new Set(["PUT /api/einstellungen", "POST /api/import/v70", "POST /api/import/stand", "GET /api/export", "GET /api/protokoll"]);
function recht(methode: string, muster: string | undefined, url: string): Recht {
if (!url.startsWith("/api/")) return "offen";
const k = `${methode} ${muster ?? ""}`;
if (OFFEN.has(k)) return "offen";
if (muster?.startsWith("/api/ich/") || muster === "/api/ich" || ALLE.has(k)) return "alle";
if (muster?.startsWith("/api/benutzer") || INHABER.has(k)) return "inhaber";
return muster ? "buero" : "inhaber";
}
function cookieWert(req: FastifyRequest): string | undefined {
const roh = req.headers.cookie;
const kopf = Array.isArray(roh) ? roh.join("; ") : roh;
for (const teil of (kopf ?? "").split(";")) {
const [k, ...v] = teil.trim().split("=");
if (k === COOKIE) return v.join("=");
}
return undefined;
}
const kopfWert = (req: FastifyRequest, name: string) => {
const h = req.headers[name];
return (Array.isArray(h) ? h[0] : h)?.trim() || undefined;
};
function setzeCookie(req: FastifyRequest, reply: FastifyReply, wert: string, sekunden: number): void {
const https = kopfWert(req, "x-forwarded-proto") === "https" || (req as { protocol?: string }).protocol === "https";
reply.header("set-cookie", `${COOKIE}=${wert}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${sekunden}${https ? "; Secure" : ""}`);
}
const Anmeldename = z.string().trim().toLowerCase().regex(/^[a-z0-9._-]{2,40}$/, "Anmeldename: 2 bis 40 Zeichen, nur Kleinbuchstaben, Ziffern, Punkt, Strich");
const Name = z.string().trim().min(1, "Name fehlt").max(100);
const Passwort = z.string().max(200).superRefine((p, ctx) => {
const f = passwortFehler(p);
if (f) ctx.addIssue({ code: "custom", message: f });
});
const BenutzerNeu = z.object({
anmeldename: Anmeldename,
name: Name,
rolle: z.enum(ROLLEN),
kontakt_id: z.uuid().nullable().optional(),
passwort: Passwort.optional(),
aktiv: z.boolean().optional(),
});
const BenutzerAenderung = BenutzerNeu.partial();
const SPALTEN = "id, anmeldename, name, rolle, kontakt_id, aktiv, passwort is not null as hat_passwort, angelegt_am, geaendert_am";
class Fehler extends Error {
constructor(public statusCode: number, nachricht: string) { super(nachricht); }
}
/**
* Hängt die Anmeldung vor jede Anfrage und legt die Routen dafür an.
* einrichtungsCode: nur auf dem Server; wer den ersten Benutzer (Inhaber) anlegt, muss ihn kennen.
*/
export function registriereAnmeldung(app: FastifyInstance, pool: Pool, art: Anmeldeart, einrichtungsCode?: string): void {
const fehlversuche = new Map<string, { anzahl: number; bis: number }>();
async function ausSitzung(req: FastifyRequest): Promise<Angemeldet | undefined> {
const s = cookieWert(req);
if (!s || s.length > 100) return undefined;
const id = schluesselId(s);
const r = await pool.query(
`select b.id, b.anmeldename, b.name, b.rolle, b.kontakt_id, s.gueltig_bis from sitzung s join benutzer b on b.id = s.benutzer_id
where s.id = $1 and s.gueltig_bis > now() and b.aktiv`, [id]);
const b = r.rows[0];
if (!b) return undefined;
// gleitend: wer das Programm benutzt, bleibt angemeldet (höchstens einmal am Tag schreiben)
if (new Date(b.gueltig_bis).getTime() - Date.now() < (TAGE - 1) * 86400_000) {
await pool.query(`update sitzung set gueltig_bis = now() + interval '${TAGE} days' where id = $1`, [id]);
}
const { gueltig_bis: _, ...wer } = b;
return wer as Angemeldet;
}
async function inTestversion(req: FastifyRequest): Promise<Angemeldet> {
const gewaehlt = kopfWert(req, "x-test-benutzer");
if (gewaehlt && z.uuid().safeParse(gewaehlt).success) {
const b = (await pool.query("select id, anmeldename, name, rolle, kontakt_id from benutzer where id = $1 and aktiv", [gewaehlt])).rows[0];
if (b) return b;
}
// interne Aufrufe der Testversion (Laden, Speichern) und Tests
const name = kopfWert(req, "x-benutzer");
if (name) return { id: null, anmeldename: name, name, rolle: "inhaber", kontakt_id: null };
const b = (await pool.query("select id, anmeldename, name, rolle, kontakt_id from benutzer where rolle = 'inhaber' and aktiv order by angelegt_am limit 1")).rows[0];
return b ?? { id: null, anmeldename: "henning", name: "Henning", rolle: "inhaber", kontakt_id: null };
}
app.addHook("onRequest", async (req, reply) => {
const r = recht(req.method, req.routeOptions?.url, req.url);
if (art === "passwort" && req.method !== "GET" && req.method !== "HEAD") {
// Anfragen von fremden Seiten abweisen
const herkunft = kopfWert(req, "origin");
if (herkunft && herkunft !== "null") {
let host = "";
try { host = new URL(herkunft).host; } catch { /* ungültig */ }
if (host !== kopfWert(req, "host")) return reply.status(403).send({ fehler: "Anfrage von einer fremden Seite" });
}
}
req.wer = art === "testversion" ? await inTestversion(req) : await ausSitzung(req);
if (r === "offen") return;
if (!req.wer) return reply.status(401).send({ fehler: "Bitte anmelden." });
if (r === "alle") return;
if (req.wer.rolle === "mitarbeiter" || (r === "inhaber" && req.wer.rolle !== "inhaber")) {
return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." });
}
});
const sicht = (w: Angemeldet | undefined) => (w ? { id: w.id, name: w.name, anmeldename: w.anmeldename, rolle: w.rolle, kontakt_id: w.kontakt_id } : null);
app.get("/api/sitzung", async (req) => {
const anzahl = Number((await pool.query("select count(*) as n from benutzer")).rows[0].n);
const antwort: Record<string, unknown> = { art, benutzer: sicht(req.wer), einrichtung: art === "passwort" && anzahl === 0 };
// Testversion: Auswahl, als wer man arbeitet
if (art === "testversion") antwort.auswahl = (await pool.query("select id, name, rolle from benutzer where aktiv order by rolle, name")).rows;
return antwort;
});
async function anmelden(req: FastifyRequest, reply: FastifyReply, benutzerId: string) {
const { schluessel, id } = neuerSchluessel();
const geraet = (kopfWert(req, "user-agent") ?? "").slice(0, 200);
await pool.query(`insert into sitzung (id, benutzer_id, gueltig_bis, geraet) values ($1, $2, now() + interval '${TAGE} days', $3)`, [id, benutzerId, geraet]);
// abgelaufene Sitzungen bei der Gelegenheit aufräumen
await pool.query("delete from sitzung where gueltig_bis < now()");
setzeCookie(req, reply, schluessel, SEKUNDEN);
}
app.post("/api/anmeldung", async (req, reply) => {
if (art !== "passwort") return reply.status(400).send({ fehler: "In der Testversion gibt es keine Anmeldung." });
const q = z.object({ anmeldename: z.string().trim().toLowerCase().max(40), passwort: z.string().max(200) }).parse(req.body);
const sperre = fehlversuche.get(q.anmeldename);
if (sperre && sperre.anzahl >= 5 && sperre.bis > Date.now()) {
return reply.status(429).send({ fehler: `Zu viele Fehlversuche. Bitte in ${Math.ceil((sperre.bis - Date.now()) / 60000)} Minuten noch einmal.` });
}
const b = (await pool.query("select id, passwort from benutzer where anmeldename = $1 and aktiv", [q.anmeldename])).rows[0];
if (!(await pruefePasswort(q.passwort, b?.passwort ?? null))) {
const n = (sperre?.anzahl ?? 0) + 1;
fehlversuche.set(q.anmeldename, { anzahl: n, bis: Date.now() + Math.min(60, 2 ** Math.max(0, n - 5)) * 60000 });
return reply.status(401).send({ fehler: "Anmeldename oder Passwort stimmt nicht." });
}
fehlversuche.delete(q.anmeldename);
await anmelden(req, reply, b.id);
return { ok: true };
});
app.post("/api/abmeldung", async (req, reply) => {
const s = cookieWert(req);
if (s) await pool.query("delete from sitzung where id = $1", [schluesselId(s)]);
setzeCookie(req, reply, "", 0);
return { ok: true };
});
// Erster Start auf dem Server: Inhaber anlegen
app.post("/api/einrichtung", async (req, reply) => {
if (art !== "passwort") return reply.status(400).send({ fehler: "Nur auf dem Server nötig." });
const q = z.object({ name: Name, anmeldename: Anmeldename, passwort: Passwort, code: z.string().trim() }).parse(req.body);
if (!einrichtungsCode || q.code !== einrichtungsCode) return reply.status(403).send({ fehler: "Der Einrichtungscode stimmt nicht." });
const hash = await hashePasswort(q.passwort);
const b = await transaktion(pool, q.anmeldename, async (c) => {
await c.query("lock table benutzer in exclusive mode");
if ((await c.query("select 1 from benutzer limit 1")).rowCount) return null;
return (await c.query("insert into benutzer (anmeldename, name, rolle, passwort) values ($1, $2, 'inhaber', $3) returning id", [q.anmeldename, q.name, hash])).rows[0];
});
if (!b) return reply.status(409).send({ fehler: "Das Programm ist schon eingerichtet." });
await anmelden(req, reply, b.id);
return reply.status(201).send({ ok: true });
});
app.post("/api/ich/passwort", async (req, reply) => {
if (art !== "passwort" || !req.wer?.id) return reply.status(400).send({ fehler: "In der Testversion gibt es keine Passwörter." });
const q = z.object({ alt: z.string().max(200), neu: Passwort }).parse(req.body);
const b = (await pool.query("select passwort from benutzer where id = $1", [req.wer.id])).rows[0];
if (!(await pruefePasswort(q.alt, b?.passwort ?? null))) return reply.status(400).send({ fehler: "Das bisherige Passwort stimmt nicht." });
const hash = await hashePasswort(q.neu);
const s = cookieWert(req);
await transaktion(pool, req.wer.anmeldename, async (c) => {
await c.query("update benutzer set passwort = $2 where id = $1", [req.wer!.id, hash]);
// andere Geräte abmelden
await c.query("delete from sitzung where benutzer_id = $1 and id <> $2", [req.wer!.id, s ? schluesselId(s) : ""]);
});
return { ok: true };
});
// ---------- Benutzerverwaltung (nur Inhaber) ----------
app.get("/api/benutzer", async () => (await pool.query(`select ${SPALTEN} from benutzer order by aktiv desc, rolle, name`)).rows);
/** Nach jeder Änderung: es bleibt ein aktiver Inhaber, der sich anmelden kann */
async function pruefeInhaber(c: { query: Pool["query"] }) {
const n = (await c.query(`select count(*) as n from benutzer where rolle = 'inhaber' and aktiv ${art === "passwort" ? "and passwort is not null" : ""}`)).rows[0].n;
const alle = (await c.query("select count(*) as n from benutzer")).rows[0].n;
if (Number(alle) > 0 && Number(n) === 0) throw new Fehler(409, "Es muss immer einen aktiven Inhaber geben, der sich anmelden kann.");
}
/** Mitarbeiter ohne Kontakt: Kontakt mit Rolle Mitarbeiter anlegen, damit Besetzung und Stunden zusammenpassen */
async function kontaktFuer(c: { query: Pool["query"] }, name: string): Promise<string> {
const da = (await c.query("select id from kontakt where rolle = 'mitarbeiter' and lower(name) = lower($1) and id not in (select kontakt_id from benutzer where kontakt_id is not null) limit 1", [name])).rows[0];
if (da) return da.id;
return (await c.query("insert into kontakt (name, rolle) values ($1, 'mitarbeiter') returning id", [name])).rows[0].id;
}
app.post("/api/benutzer", async (req, reply) => {
const q = BenutzerNeu.parse(req.body);
if (art === "testversion" && q.passwort) return reply.status(400).send({ fehler: "In der Testversion gibt es keine Passwörter." });
const hash = q.passwort ? await hashePasswort(q.passwort) : null;
const b = await transaktion(pool, req.wer!.anmeldename, async (c) => {
// Testversion: wer bisher ohne Benutzer gearbeitet hat, wird beim ersten neuen Benutzer selbst als Inhaber angelegt
if (art === "testversion" && !req.wer!.id && !(await c.query("select 1 from benutzer where rolle = 'inhaber' and aktiv")).rowCount) {
await c.query("insert into benutzer (anmeldename, name, rolle) values ($1, $2, 'inhaber') on conflict (anmeldename) do update set rolle = 'inhaber', aktiv = true",
[req.wer!.anmeldename, req.wer!.name]);
}
const kontakt = q.kontakt_id ?? (q.rolle === "mitarbeiter" ? await kontaktFuer(c, q.name) : null);
const neu = (await c.query(`insert into benutzer (anmeldename, name, rolle, kontakt_id, passwort, aktiv) values ($1, $2, $3, $4, $5, $6) returning ${SPALTEN}`,
[q.anmeldename, q.name, q.rolle, kontakt, hash, q.aktiv ?? true])).rows[0];
await pruefeInhaber(c);
return neu;
});
return reply.status(201).send(b);
});
app.patch("/api/benutzer/:id", async (req, reply) => {
const { id } = z.object({ id: z.uuid() }).parse(req.params);
const q = BenutzerAenderung.parse(req.body);
if (art === "testversion" && q.passwort) return reply.status(400).send({ fehler: "In der Testversion gibt es keine Passwörter." });
const hash = q.passwort ? await hashePasswort(q.passwort) : undefined;
const b = await transaktion(pool, req.wer!.anmeldename, async (c) => {
const alt = (await c.query("select * from benutzer where id = $1", [id])).rows[0];
if (!alt) return null;
const rolle = q.rolle ?? alt.rolle;
let kontakt = q.kontakt_id !== undefined ? q.kontakt_id : alt.kontakt_id;
if (rolle === "mitarbeiter" && !kontakt) kontakt = await kontaktFuer(c, q.name ?? alt.name);
const neu = (await c.query(`update benutzer set anmeldename = $2, name = $3, rolle = $4, kontakt_id = $5, aktiv = $6, passwort = coalesce($7, passwort)
where id = $1 returning ${SPALTEN}`, [id, q.anmeldename ?? alt.anmeldename, q.name ?? alt.name, rolle, kontakt, q.aktiv ?? alt.aktiv, hash ?? null])).rows[0];
// neues Passwort, andere Rolle oder gesperrt: auf allen Geräten neu anmelden
if (hash || rolle !== alt.rolle || neu.aktiv === false) await c.query("delete from sitzung where benutzer_id = $1", [id]);
await pruefeInhaber(c);
return neu;
});
return b ?? reply.status(404).send({ fehler: "Nicht gefunden" });
});
app.delete("/api/benutzer/:id", async (req, reply) => {
const { id } = z.object({ id: z.uuid() }).parse(req.params);
if (id === req.wer!.id) return reply.status(409).send({ fehler: "Du kannst dich nicht selbst löschen." });
const n = await transaktion(pool, req.wer!.anmeldename, async (c) => {
const r = (await c.query("delete from benutzer where id = $1", [id])).rowCount;
await pruefeInhaber(c);
return r;
});
return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
});
}
/** Für Protokoll und Transaktionen */
export const werName = (req: FastifyRequest) => req.wer?.anmeldename ?? "system";

View File

@@ -17,8 +17,10 @@ import { liquiditaet } from "../domain/liquiditaet.js";
import { liquiditaetsDaten } from "../domain/projektplan.js";
import { uebernimmV70 } from "../domain/v70.js";
import { speichereUebernahme } from "./v70import.js";
import { pruefeStand, speichereStand } from "./stand.js";
import { benutzerFuerSicherung, pruefeStand, speichereStand } from "./stand.js";
import { VERSION } from "./version.js";
import { type Anmeldeart, registriereAnmeldung, werName } from "./anmeldung.js";
import { istEingeteilt, registriereIch } from "./ich.js";
export interface Optionen {
pool: Pool;
@@ -26,13 +28,14 @@ export interface Optionen {
nextcloud?: Nextcloud;
webOrdner?: string;
logger?: boolean;
/** passwort: Server; testversion: Browser-Testversion und Tests, ohne Passwörter */
anmeldung?: Anmeldeart;
/** Nur auf dem Server: Code, mit dem der erste Benutzer (Inhaber) angelegt wird */
einrichtungsCode?: string;
}
/** Benutzer kommt vom Proxy (Anmeldung); ohne Proxy, z. B. lokal, gilt "lokal". */
function benutzer(req: FastifyRequest): string {
const h = req.headers["x-benutzer"];
return (Array.isArray(h) ? h[0] : h)?.trim() || "lokal";
}
/** Wer angemeldet ist, steht im Änderungsprotokoll */
const benutzer = (req: FastifyRequest): string => werName(req);
const IdParam = z.object({ id: z.uuid() });
@@ -56,6 +59,10 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
return reply.status(500).send({ fehler: "Interner Fehler" });
});
registriereAnmeldung(app, pool, o.anmeldung ?? "passwort", o.einrichtungsCode);
registriereIch(app, pool, ladeEinstellungen);
app.get("/api/status", async () => {
await pool.query("select 1");
return { ok: true, version: VERSION };
@@ -91,9 +98,12 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
if (!p) return null;
return [p.nextcloud_link, unter.replace(/^\/+|\/+$/g, "")].filter(Boolean).join("/");
}
// P13: Mitarbeiter sehen die Ablage der Projekte, auf denen sie eingeteilt sind
const ablageErlaubt = async (req: FastifyRequest, id: string) => req.wer?.rolle !== "mitarbeiter" || istEingeteilt(pool, req.wer.kontakt_id, id);
app.get("/api/projekte/:id/ablage", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const { pfad } = AblageAnfrage.parse(req.query);
if (!(await ablageErlaubt(req, id))) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." });
if (!o.nextcloud) return reply.status(409).send({ fehler: "Die Ablage zeigt den Projektordner in der Nextcloud. Das geht, sobald das Programm auf dem Server läuft." });
const p = (await pool.query("select nextcloud_link from projekt where id = $1", [id])).rows[0];
if (!p) return reply.status(404).send({ fehler: "Nicht gefunden" });
@@ -105,6 +115,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
app.get("/api/projekte/:id/ablage/datei", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const { pfad } = AblageAnfrage.parse(req.query);
if (!(await ablageErlaubt(req, id))) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." });
if (!o.nextcloud || !pfad) return reply.status(404).send({ fehler: "Nicht gefunden" });
const voll = await ablagePfad(id, pfad);
if (!voll) return reply.status(404).send({ fehler: "Nicht gefunden" });
@@ -325,6 +336,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
app.get("/api/export", async (_req, reply) => {
const daten: Record<string, unknown[]> = {};
for (const t of TABELLEN) daten[t.pfad] = (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows;
daten.benutzer = await benutzerFuerSicherung(pool);
const stand = new Date().toISOString();
reply.header("content-disposition", `attachment; filename="betrieb-${stand.slice(0, 10)}.json"`);
return { programm: "betrieb", version: VERSION, stand, einstellungen: await ladeEinstellungen(), daten };

39
src/server/ich.ts Normal file
View File

@@ -0,0 +1,39 @@
// Was jeder Angemeldete für sich selbst sieht, auch Mitarbeiter am Handy (E27):
// eigene Einsätze mit Baustelle und Adresse, später eigene Stunden und Urlaub. Keine Beträge.
import type { FastifyInstance } from "fastify";
import { z } from "zod";
import type { Pool } from "./db.js";
import type { Einstellungen } from "./einstellungen.js";
import { anfang, ende } from "../domain/terminplan.js";
import { plusTage } from "../domain/datum.js";
const Tag = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
/** Projekte, an denen ein Kontakt eingeteilt ist (für Ablage und Stunden) */
export async function istEingeteilt(pool: Pool, kontaktId: string | null, projektId: string): Promise<boolean> {
if (!kontaktId) return false;
const r = await pool.query(`select 1 from besetzung b join vorgang v on v.id = b.vorgang_id join abschnitt a on a.id = v.abschnitt_id
where b.kontakt_id = $1 and a.projekt_id = $2 limit 1`, [kontaktId, projektId]);
return !!r.rowCount;
}
export function registriereIch(app: FastifyInstance, pool: Pool, einstellungen: () => Promise<Einstellungen>): void {
// Eigene Einsätze von heute an, Standard drei Wochen
app.get("/api/ich/einsaetze", async (req) => {
const q = z.object({ heute: Tag.optional(), tage: z.coerce.number().int().min(1).max(92).default(21) }).parse(req.query);
const heute = q.heute ?? new Date().toISOString().slice(0, 10);
const bis = plusTage(heute, q.tage - 1);
const kontakt = req.wer!.kontakt_id;
if (!kontakt) return { heute, bis, einsaetze: [] };
const woche = { tage: (await einstellungen()).arbeitstage };
const r = await pool.query(
`select v.id, v.name, v.start, v.dauer, p.id as projekt_id, p.nummer, p.bezeichnung, p.baustelle_strasse, p.baustelle_plz, p.baustelle_ort
from besetzung b join vorgang v on v.id = b.vorgang_id join abschnitt a on a.id = v.abschnitt_id join projekt p on p.id = a.projekt_id
where b.kontakt_id = $1 and b.freigegeben order by v.start, p.nummer`, [kontakt]);
const einsaetze = r.rows
.map((v) => ({ ...v, dauer: Number(v.dauer), anfang: anfang({ ...v, dauer: Number(v.dauer) }, woche), ende: ende({ ...v, dauer: Number(v.dauer) }, woche) }))
.filter((v) => v.ende >= heute && v.anfang <= bis)
.map(({ start: _s, dauer: _d, ...v }) => v);
return { heute, bis, arbeitstage: woche.tage, einsaetze };
});
}

View File

@@ -1,3 +1,4 @@
import { randomBytes } from "node:crypto";
import { erstellePool } from "./db.js";
import { migriere } from "./migrate.js";
import { baueApp } from "./app.js";
@@ -14,7 +15,13 @@ await migriere(pool, (t) => console.log(t));
// P10: Ordner der Projekte; gleicher Zugang wie für die Sicherung, eigene Adresse
const { NEXTCLOUD_PROJEKTE_URL: ncUrl, NEXTCLOUD_BENUTZER: ncBenutzer, NEXTCLOUD_PASSWORT: ncPasswort } = process.env;
const nextcloud = ncUrl && ncBenutzer && ncPasswort ? new Nextcloud({ url: ncUrl, benutzer: ncBenutzer, passwort: ncPasswort }) : undefined;
const app = await baueApp({ pool, logger: true, nextcloud });
// U1: Den ersten Benutzer (Inhaber) legt nur an, wer diesen Code kennt. Er steht im Log, solange niemand eingerichtet ist.
let einrichtungsCode = process.env.EINRICHTUNGSCODE;
if (Number((await pool.query("select count(*) as n from benutzer")).rows[0].n) === 0) {
einrichtungsCode ||= randomBytes(6).toString("hex");
console.log(`Noch kein Benutzer angelegt. Einrichtungscode für den Inhaber: ${einrichtungsCode}`);
}
const app = await baueApp({ pool, logger: true, nextcloud, anmeldung: "passwort", einrichtungsCode });
const port = Number(process.env.PORT ?? 3000);
await app.listen({ host: "0.0.0.0", port });

View File

@@ -0,0 +1,53 @@
-- U1/U2: eigene Anmeldung je Person mit Rolle (Stufe 2). Inhaber sieht alles; Büro alles außer Löhnen,
-- Jahresplan, BWA und Benutzerverwaltung; Mitarbeiter nur eigene Einsätze, Adressen und Stunden (E27).
create table benutzer (
id uuid primary key default gen_random_uuid(),
anmeldename text not null unique check (anmeldename ~ '^[a-z0-9._-]{2,40}$'),
name text not null check (trim(name) <> ''),
rolle text not null check (rolle in ('inhaber', 'buero', 'mitarbeiter')),
-- Mitarbeiter: der Kontakt, über den Besetzung und Stunden laufen
kontakt_id uuid unique references kontakt (id) on delete set null,
-- scrypt-Hash; leer, solange kein Passwort vergeben ist (Testversion)
passwort text,
aktiv boolean not null default true,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system',
check (rolle <> 'mitarbeiter' or kontakt_id is not null)
);
-- Protokoll wie überall, aber ohne Passwort-Hash
create function benutzer_protokoll() returns trigger language plpgsql as $$
declare
wer text := coalesce(nullif(current_setting('betrieb.benutzer', true), ''), 'system');
begin
if tg_op = 'DELETE' then
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher)
values (wer, tg_table_name, old.id, 'loeschen', to_jsonb(old) - 'passwort');
return old;
end if;
new.geaendert_am := now();
new.geaendert_von := wer;
if tg_op = 'INSERT' then
new.angelegt_am := now();
insert into protokoll (benutzer, tabelle, datensatz, aktion, nachher)
values (wer, tg_table_name, new.id, 'anlegen', to_jsonb(new) - 'passwort');
else
new.angelegt_am := old.angelegt_am;
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher, nachher)
values (wer, tg_table_name, new.id, 'aendern', to_jsonb(old) - 'passwort', to_jsonb(new) - 'passwort');
end if;
return new;
end $$;
create trigger benutzer_protokoll before insert or update or delete on benutzer
for each row execute function benutzer_protokoll();
-- Angemeldete Geräte. Gespeichert wird nur der SHA-256 des Cookies, nie der Cookie selbst.
create table sitzung (
id text primary key,
benutzer_id uuid not null references benutzer (id) on delete cascade,
angelegt_am timestamptz not null default now(),
gueltig_bis timestamptz not null,
geraet text
);
create index sitzung_benutzer on sitzung (benutzer_id);

42
src/server/passwort.ts Normal file
View File

@@ -0,0 +1,42 @@
// Passwörter mit scrypt aus Node (kein Zusatzpaket). Format: scrypt$N$r$p$salz$hash, beides base64url.
import { createHash, randomBytes, scrypt, timingSafeEqual } from "node:crypto";
const N = 16384, R = 8, P = 1, LAENGE = 32;
function ableiten(passwort: string, salz: Buffer, n: number, r: number, p: number): Promise<Buffer> {
return new Promise((ok, fehler) =>
scrypt(passwort.normalize("NFC"), salz, LAENGE, { N: n, r, p, maxmem: 64 * 1024 * 1024 }, (e, k) => (e ? fehler(e) : ok(k))));
}
export async function hashePasswort(passwort: string): Promise<string> {
const salz = randomBytes(16);
const k = await ableiten(passwort, salz, N, R, P);
return ["scrypt", N, R, P, salz.toString("base64url"), k.toString("base64url")].join("$");
}
export async function pruefePasswort(passwort: string, gespeichert: string | null): Promise<boolean> {
const t = gespeichert?.split("$");
if (!t || t.length !== 6 || t[0] !== "scrypt") {
// gleich lange rechnen, damit man fehlende Benutzer nicht an der Antwortzeit erkennt
await ableiten(passwort, Buffer.alloc(16), N, R, P);
return false;
}
const soll = Buffer.from(t[5]!, "base64url");
const ist = await ableiten(passwort, Buffer.from(t[4]!, "base64url"), Number(t[1]), Number(t[2]), Number(t[3]));
return soll.length === ist.length && timingSafeEqual(soll, ist);
}
/** Zufälliger Sitzungsschlüssel für den Cookie und sein SHA-256 für die Datenbank */
export function neuerSchluessel(): { schluessel: string; id: string } {
const schluessel = randomBytes(32).toString("base64url");
return { schluessel, id: schluesselId(schluessel) };
}
export const schluesselId = (schluessel: string) => createHash("sha256").update(schluessel).digest("hex");
/** Mindestens 8 Zeichen; mehr verlangen wir nicht, damit es am Handy eintippbar bleibt */
export function passwortFehler(passwort: string): string | null {
if (passwort.length < 8) return "Das Passwort braucht mindestens 8 Zeichen.";
if (passwort.length > 200) return "Das Passwort ist zu lang.";
return null;
}

View File

@@ -39,6 +39,7 @@ export async function speichereStand(c: Client, s: Stand): Promise<Record<string
}
anzahl[t.pfad] = zeilen.length;
}
anzahl.benutzer = await speichereBenutzer(c, s.daten.benutzer ?? []);
if (s.einstellungen !== undefined) {
await c.query("update einstellungen set daten = $1", [EinstellungenSchema.parse(s.einstellungen)]);
}
@@ -51,3 +52,19 @@ export async function speichereStand(c: Client, s: Stand): Promise<Record<string
}
return anzahl;
}
/** Benutzer gehören nicht zu TABELLEN (kein Passwort in der Sicherung). Wer schon da ist (gleicher
* Anmeldename, z. B. der Inhaber nach der Einrichtung auf dem Server), behält sein Passwort. */
async function speichereBenutzer(c: Client, zeilen: Record<string, unknown>[]): Promise<number> {
for (const z of zeilen) {
await c.query(`insert into benutzer (id, anmeldename, name, rolle, kontakt_id, aktiv) values ($1, $2, $3, $4, $5, $6)
on conflict (anmeldename) do update set name = excluded.name, rolle = excluded.rolle, kontakt_id = excluded.kontakt_id, aktiv = excluded.aktiv`,
[z.id, z.anmeldename, z.name, z.rolle, z.kontakt_id ?? null, z.aktiv ?? true]);
}
return zeilen.length;
}
/** Für die Sicherung: Benutzer ohne Passwort-Hash */
export async function benutzerFuerSicherung(c: { query: Client["query"] }): Promise<Record<string, unknown>[]> {
return (await c.query("select id, anmeldename, name, rolle, kontakt_id, aktiv, angelegt_am from benutzer order by angelegt_am")).rows;
}

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>`);
}

View File

@@ -1,181 +1,11 @@
// Oberfläche. Die Reiter folgen dem Lastenheft; Projektseite und Listen nach Vorbild Plancraft.
import { formatEuro, parseEuro } from "../domain/geld.js";
import { formatDatum } from "../domain/datum.js";
import { kalenderwoche, terminplanSeite } from "./gantt.js";
import { type Feld, type Zeile, MONATSNAMEN, api, bearbeitbareAuswahl, bearbeiten, bestaetigen, dat, dialog, esc, euro, heute, hinweis,
huelle, inhalt, optionenHtml, seite, tabelle, abgemeldet, lies, merke, TEST_BENUTZER } from "./ui.js";
import { type Sitzung, anmeldeSeite, benutzerSeite, werLeiste } from "./anmeldung.js";
import { ablageSeite, meineEinsaetze } from "./mitarbeiter.js";
type Zeile = Record<string, any>;
// ---------- Hilfen ----------
function esc(v: unknown): string {
return String(v ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]!);
}
async function api<T = any>(pfad: string, methode = "GET", body?: unknown): Promise<T> {
const r = await fetch(`/api/${pfad}`, {
method: methode,
headers: body === undefined ? {} : { "content-type": "application/json" },
body: body === undefined ? undefined : JSON.stringify(body),
});
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;
}
const inhalt = document.getElementById("inhalt")!;
const huelle = document.getElementById("dialog-huelle")!;
const heute = () => new Date().toISOString().slice(0, 10);
const euro = (c: number | null | undefined) => (c == null ? "" : formatEuro(c));
const dat = (d: string | null | undefined) => (d ? formatDatum(d) : "");
const MONATSNAMEN = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
// ---------- Eigene Dialoge (keine Browser-Abfragen) ----------
interface Feld {
name: string;
titel: string;
art?: "text" | "euro" | "datum" | "auswahl" | "zahl" | "langtext";
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][]> };
}
const BEARBEITEN = "__bearbeiten";
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. */
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?.();
});
}
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" : "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"' : ""}>`;
}
return `<label for="${id}">${esc(f.titel)}${f.pflicht ? " *" : ""}</label>${eingabe}`;
})
.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 roh = (form.querySelector(`#f-${f.name}`) as HTMLInputElement).value.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 });
});
});
}
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");
});
});
}
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) hinweisNachLaden = antwort.ordner_fehler;
return true;
}
let hinweisNachLaden = "";
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
function seite(titel: string, knopf?: { text: string; aktion: () => void }): HTMLElement {
inhalt.innerHTML = `<div class="kopf"><h1>${esc(titel)}</h1></div>${hinweisNachLaden ? `<div class="warnung">${esc(hinweisNachLaden)}</div>` : ""}`;
hinweisNachLaden = "";
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;
}
// ---------- Reiter ----------
@@ -236,7 +66,7 @@ async function projekte(): Promise<void> {
const e = await dialog("Neues Projekt", await projektFelder(), { status: "anfrage" }, false);
if (e?.aktion !== "speichern") return;
const p = await api<Zeile>("projekte", "POST", ohneNull(e.daten));
if (p.ordner_fehler) hinweisNachLaden = p.ordner_fehler;
if (p.ordner_fehler) hinweis.text = p.ordner_fehler;
location.hash = `projekt-${p.id}`;
};
seite("Projekte", { text: "Neues Projekt", aktion: neu });
@@ -303,7 +133,7 @@ async function projektSeite(id: string): Promise<void> {
const eigeneAufgaben = alleAufgaben.filter((a) => a.projekt_id === id);
const umsatz = p.umsatz_netto, kostenGesamt = kostenSumme(p);
inhalt.innerHTML = `${hinweisNachLaden ? `<div class="warnung">${esc(hinweisNachLaden)}</div>` : ""}
inhalt.innerHTML = `${hinweis.text ? `<div class="warnung">${esc(hinweis.text)}</div>` : ""}
<div class="kopf projekt-kopf"><a class="neben zurueck" href="#projekte" aria-label="Zurück zur Projektliste">←</a>
<h1>${esc(p.bezeichnung)} <span class="nummer">(${esc(p.nummer)})</span></h1>
<select id="p-status" class="etikett ${esc(p.status)}" aria-label="Status">${optionenHtml(STATUS, p.status)}</select>
@@ -318,7 +148,7 @@ async function projektSeite(id: string): Promise<void> {
</div>
<aside class="karte projekt-aufgaben" aria-label="Offene Aufgaben"></aside>
</div>`;
hinweisNachLaden = "";
hinweis.text = "";
const oben = inhalt.querySelector<HTMLElement>("#p-oben")!;
const unten = inhalt.querySelector<HTMLElement>("#p-unten")!;
const teil = unten.querySelector<HTMLElement>("#teil")!;
@@ -514,7 +344,7 @@ async function projektSeite(id: string): Promise<void> {
if (!e) return;
if (e.aktion === "loeschen") { await api(`projekte/${id}`, "DELETE"); location.hash = "projekte"; return; }
const r = await api<Zeile>(`projekte/${id}`, "PATCH", ohneNull(e.daten));
if (r.ordner_fehler) hinweisNachLaden = r.ordner_fehler;
if (r.ordner_fehler) hinweis.text = r.ordner_fehler;
return neuLaden();
}
if (a === "zahlungsplan") {
@@ -538,7 +368,7 @@ async function projektSeite(id: string): Promise<void> {
});
(inhalt.querySelector("#p-status") as HTMLSelectElement).onchange = async (ev) => {
const r = await api<Zeile>(`projekte/${id}`, "PATCH", { status: (ev.target as HTMLSelectElement).value });
if (r.ordner_fehler) hinweisNachLaden = r.ordner_fehler;
if (r.ordner_fehler) hinweis.text = r.ordner_fehler;
neuLaden();
};
}
@@ -939,13 +769,20 @@ async function daten(): Promise<void> {
inhalt.appendChild(knopf);
}
// Reihenfolge wie die Module im Lastenheft (Henning, 18.10.2026); Daten immer zuletzt
const REITER: [string, string, () => Promise<void>][] = [
["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte],
["terminplan", "Terminplan", terminplan], ["kontakte", "Kontakte", kontakte],
["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten],
["daten", "Daten", daten],
];
// Reihenfolge wie die Module im Lastenheft (Henning, 18.10.2026); Benutzer und Daten immer zuletzt.
// Was jemand sieht, hängt an seiner Rolle (U2); Mitarbeiter bekommen ihre eigene, schlanke Ansicht (E27).
type Reiter = [string, string, () => Promise<void>];
function reiterFuer(s: Sitzung): Reiter[] {
const rolle = s.benutzer?.rolle;
if (rolle === "mitarbeiter") return [["meine-einsaetze", "Meine Einsätze", meineEinsaetze]];
const alle: Reiter[] = [
["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte],
["terminplan", "Terminplan", terminplan], ["kontakte", "Kontakte", kontakte],
["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten],
];
if (rolle === "inhaber") alle.push(["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]);
return alle;
}
// Einfache Strichsymbole (24er Raster), Farbe kommt aus der Schrift
const SYMBOLE: Record<string, string> = {
@@ -956,34 +793,54 @@ const SYMBOLE: Record<string, string> = {
kontakte: '<circle cx="12" cy="8" r="4"/><path d="M4 21c1-4 4-6 8-6s7 2 8 6"/>',
liquiditaet: '<path d="M3 17l6-6 4 4 8-8"/><path d="M15 7h6v6"/>',
"laufende-kosten": '<rect x="3" y="6" width="18" height="13" rx="1"/><path d="M3 10h18M7 15h4"/>',
benutzer: '<circle cx="9" cy="8" r="3.5"/><path d="M2.5 20c.8-3.6 3.3-5.5 6.5-5.5s5.7 1.9 6.5 5.5"/><circle cx="17" cy="9" r="2.5"/><path d="M16 14.6c2.8.1 4.8 1.9 5.5 5.4"/>',
"meine-einsaetze": '<rect x="3" y="5" width="18" height="16" rx="1"/><path d="M3 10h18M8 3v4M16 3v4M8 15l2.5 2.5L16 13"/>',
daten: '<ellipse cx="12" cy="6" rx="8" ry="3"/><path d="M4 6v12c0 1.7 3.6 3 8 3s8-1.3 8-3V6M4 12c0 1.7 3.6 3 8 3s8-1.3 8-3"/>',
};
const symbol = (id: string) => `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${SYMBOLE[id] ?? ""}</svg>`;
const nav = document.getElementById("reiter")!;
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("");
let REITER: Reiter[] = [];
nav.addEventListener("click", (ev) => {
const r = ((ev.target as HTMLElement).closest("button[data-r]") as HTMLElement | null)?.dataset.r;
if (r) location.hash = r;
});
async function zeige(): Promise<void> {
const id = location.hash.slice(1) || "uebersicht";
// Projektseite: #projekt-<id>, gehört zum Reiter Projekte
const id = location.hash.slice(1) || REITER[0]![0];
// Projektseite: #projekt-<id>, gehört zum Reiter Projekte; Mitarbeiter: #ablage-<id>
const treffer = /^projekt-([0-9a-f-]{36})(?:-(dokumente|berichte|ablage|zahlungen))?$/.exec(id);
const ablage = /^ablage-([0-9a-f-]{36})$/.exec(id)?.[1];
const projekt = treffer?.[1];
if (treffer?.[2]) projektTeil = treffer[2];
const reiter = REITER.find(([r]) => r === (projekt ? "projekte" : id)) ?? REITER[0]!;
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0]));
try {
await (projekt ? projektSeite(projekt) : reiter[2]());
await (ablage ? ablageSeite(ablage) : projekt && REITER.some(([r]) => r === "projekte") ? projektSeite(projekt) : reiter[2]());
} catch (e) {
inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`);
}
}
window.addEventListener("hashchange", zeige);
window.addEventListener("unhandledrejection", (ev) => {
inhalt.insertAdjacentHTML("afterbegin", `<p class="fehler">${esc(ev.reason?.message ?? ev.reason)}</p>`);
});
zeige();
async function start(): Promise<void> {
let s = await api<Sitzung>("sitzung");
// Testversion: gewählter Benutzer gelöscht oder gesperrt → wieder als Inhaber
if (s.art === "testversion" && lies(TEST_BENUTZER) && s.benutzer?.id !== lies(TEST_BENUTZER)) {
merke(TEST_BENUTZER, null);
s = await api<Sitzung>("sitzung");
}
if (!s.benutzer) return anmeldeSeite(s);
abgemeldet.melden = () => { location.hash = ""; location.reload(); };
document.body.classList.toggle("rolle-mitarbeiter", s.benutzer.rolle === "mitarbeiter");
REITER = reiterFuer(s);
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("");
werLeiste(s);
window.addEventListener("hashchange", zeige);
await zeige();
}
start().catch((e) => inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`));
api("status").then((s) => (document.getElementById("version")!.textContent = `Version ${s.version}`)).catch(() => {});

View File

@@ -11,6 +11,7 @@
<aside id="seitenleiste">
<div id="marke"><img src="/bilder/logo.png" alt="Holzbau Schaarschmidt"></div>
<nav id="reiter"></nav>
<div id="wer"></div>
<span id="version"></span>
</aside>
<main id="inhalt"></main>

60
src/web/mitarbeiter.ts Normal file
View File

@@ -0,0 +1,60 @@
// Ansicht für Mitarbeiter am Handy (E27, M9 vorab): eigene Einsätze mit Baustelle und Adresse, Ablage der eigenen Projekte.
// Keine Beträge, keine Angebote oder Rechnungen (P13). Der Freitag erscheint nicht als Reserve.
import { type Zeile, api, dat, esc, heute, inhalt, seite } from "./ui.js";
const WOCHENTAG_LANG = ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"];
const tagName = (d: string) => WOCHENTAG_LANG[new Date(`${d}T00:00:00Z`).getUTCDay()]!;
const adresse = (e: Zeile) => [e.baustelle_strasse, [e.baustelle_plz, e.baustelle_ort].filter(Boolean).join(" ")].filter(Boolean).join(", ");
export async function meineEinsaetze(): Promise<void> {
const r = await api<{ heute: string; bis: string; arbeitstage: number[]; einsaetze: Zeile[] }>(`ich/einsaetze?heute=${heute()}&tage=21`);
seite("Meine Einsätze");
if (!r.einsaetze.length) {
inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis leer">In den nächsten drei Wochen bist du nirgends eingeteilt.</p>');
return;
}
// je Arbeitstag, an dem etwas ansteht, die Einsätze untereinander
const tage: string[] = [];
for (let d = r.heute; d <= r.bis; d = new Date(Date.parse(`${d}T00:00:00Z`) + 86400000).toISOString().slice(0, 10)) {
const wt = new Date(`${d}T00:00:00Z`).getUTCDay() || 7;
if (r.arbeitstage.includes(wt)) tage.push(d);
}
const html = tage.map((d) => {
const heuteDa = r.einsaetze.filter((e) => e.anfang <= d && e.ende >= d);
if (!heuteDa.length) return "";
return `<section class="tag-karte${d === r.heute ? " heute" : ""}"><h2>${d === r.heute ? "Heute, " : ""}${tagName(d)} ${dat(d)}</h2>
${heuteDa.map((e) => {
const ort = adresse(e);
return `<article class="einsatz-karte"><h3>${esc(e.nummer)} ${esc(e.bezeichnung)}</h3><p>${esc(e.name)}</p>
${ort ? `<p class="ort">${esc(ort)} <a class="neben" href="https://www.google.com/maps/dir/?api=1&destination=${encodeURIComponent(ort)}" target="_blank" rel="noopener">Route</a></p>` : ""}
<p><a class="neben" href="#ablage-${esc(e.projekt_id)}">Ablage</a></p></article>`;
}).join("")}</section>`;
}).join("");
inhalt.insertAdjacentHTML("beforeend", `<div class="meine-einsaetze">${html}</div>`);
}
/** Projektordner in der Nextcloud, nur lesen */
export async function ablageSeite(projektId: string, pfad = ""): Promise<void> {
seite("Ablage");
const ziel = document.createElement("div");
inhalt.appendChild(ziel);
ziel.innerHTML = '<p class="hinweis leer">Lade den Projektordner …</p>';
try {
const a = await api<{ ordner: string; eintraege: { name: string; ordner: boolean; groesse: number }[] }>(`projekte/${projektId}/ablage?pfad=${encodeURIComponent(pfad)}`);
const teile = pfad ? pfad.split("/") : [];
const voll = (n: string) => (pfad ? `${pfad}/${n}` : n);
ziel.innerHTML = `<nav class="pfad"><button class="verweis" data-ablage="">${esc(a.ordner.split("/").at(-1))}</button>${teile.map((t, i) =>
` / <button class="verweis" data-ablage="${esc(teile.slice(0, i + 1).join("/"))}">${esc(t)}</button>`).join("")}</nav>
${a.eintraege.length ? `<ul class="ablage">${a.eintraege.map((e) => e.ordner
? `<li><button class="eintrag" data-ablage="${esc(voll(e.name))}"><span class="sym" aria-hidden="true">📁</span><span class="name">${esc(e.name)}</span></button></li>`
: `<li><a class="eintrag" href="/api/projekte/${esc(projektId)}/ablage/datei?pfad=${encodeURIComponent(voll(e.name))}" target="_blank" rel="noopener"><span class="sym" aria-hidden="true">📄</span><span class="name">${esc(e.name)}</span></a></li>`).join("")}</ul>`
: '<p class="hinweis leer">Der Ordner ist leer.</p>'}`;
ziel.onclick = (ev) => {
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-ablage]");
if (b) void ablageSeite(projektId, b.dataset.ablage!);
};
} catch (e) {
ziel.innerHTML = `<p class="hinweis leer">${esc((e as Error).message)}</p>`;
}
}

View File

@@ -420,3 +420,38 @@ h3.gruppe { padding: 8px 0 6px; border-bottom: 1px solid var(--linie); margin-to
.uebersicht-kacheln { grid-template-columns: 1fr; grid-template-areas: "stunden" "kunde" "zeitraum" "baustelle" "beschreibung"; padding: 10px 4px; }
}
.g-links .g-raten.leise { color: var(--leise); text-decoration: none; }
/* Stufe 2: Anmeldung, wer angemeldet ist, Mitarbeiter-Ansicht */
.dialog .hilfe { display: block; font-size: 12px; color: var(--leise); margin-top: 4px; }
#wer { font-size: 13px; padding: 10px 10px 0; border-top: 1px solid rgb(255 255 255 / 0.08); display: flex; flex-direction: column; gap: 4px; }
#wer:empty { display: none; }
#wer span { color: #fff; display: flex; flex-direction: column; }
#wer small { color: var(--leiste-text); }
#wer label { color: var(--leiste-text); }
#wer select { width: 100%; font: inherit; padding: 5px 6px; border-radius: 6px; border: 1px solid rgb(255 255 255 / 0.2); background: var(--leiste-aktiv); color: #fff; }
#wer .verweis { color: var(--leiste-text); text-align: left; padding: 0; }
#wer .verweis:hover { color: #fff; }
#wer .konto { display: none; }
body.abgemeldet #seitenleiste { display: none; }
body.abgemeldet #inhalt { display: grid; place-items: center; min-height: 100vh; }
.anmeldung { background: var(--fl); border: 1px solid var(--linie); border-radius: 14px; padding: 26px 24px; width: min(380px, 100%); display: flex; flex-direction: column; }
.anmeldung img { width: 110px; align-self: center; margin-bottom: 6px; }
.anmeldung h1 { font-size: 22px; margin: 6px 0 4px; text-align: center; }
.anmeldung label { font-size: 13px; color: var(--leise); margin: 14px 0 4px; }
.anmeldung input { font: inherit; font-size: 17px; padding: 11px 12px; border-radius: 8px; border: 1px solid var(--linie); background: var(--bg); color: var(--text); }
.anmeldung button.haupt { margin-top: 18px; padding: 13px 18px; font-size: 17px; }
.anmeldung .fehler:empty { display: none; }
.anmeldung .hinweis { font-size: 13px; text-align: center; margin: 12px 0 0; }
.meine-einsaetze { display: flex; flex-direction: column; gap: 14px; max-width: 640px; }
.tag-karte h2 { font-size: 16px; margin: 0 0 8px; }
.tag-karte.heute h2 { color: var(--akzent); }
.einsatz-karte { background: var(--fl); border: 1px solid var(--linie); border-radius: 12px; padding: 14px 16px; margin-bottom: 8px; }
.einsatz-karte h3 { margin: 0 0 4px; font-size: 17px; }
.einsatz-karte p { margin: 6px 0 0; }
.einsatz-karte .ort { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; color: var(--leise); }
@media (max-width: 800px) {
#wer { flex-direction: row; align-items: center; border: 0; padding: 0 0 0 6px; white-space: nowrap; margin-left: auto; }
#wer span, #wer label, #wer .verweis { display: none; }
#wer .konto { display: grid; place-items: center; width: 36px; height: 36px; border-radius: 50%; border: 0; background: var(--leiste-aktiv); color: #fff; font: inherit; font-weight: 600; cursor: pointer; }
#wer select { width: auto; }
}

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;
}