From bc5e15339a1b5969da5e21a86efac60832522ab8 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 20 Oct 2026 06:26:05 +0000 Subject: [PATCH] =?UTF-8?q?Anmeldung=20und=20Rollen:=20eigene=20Zug=C3=A4n?= =?UTF-8?q?ge,=20Benutzerverwaltung,=20Mitarbeiter-Ansicht=20(0.7.0)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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) Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz --- CHANGELOG.md | 8 + README.md | 1 + demo/fastify.ts | 10 +- demo/index.html | 1 + demo/kern.ts | 4 +- demo/main.ts | 5 +- demo/node.ts | 5 + deploy/.env.beispiel | 7 +- deploy/Caddyfile | 31 +-- deploy/docker-compose.yml | 4 +- package.json | 2 +- src/server/anmeldung.ts | 292 ++++++++++++++++++++++++ src/server/app.ts | 24 +- src/server/ich.ts | 39 ++++ src/server/index.ts | 9 +- src/server/migrations/007_anmeldung.sql | 53 +++++ src/server/passwort.ts | 42 ++++ src/server/stand.ts | 17 ++ src/web/anmeldung.ts | 167 ++++++++++++++ src/web/app.ts | 241 ++++--------------- src/web/index.html | 1 + src/web/mitarbeiter.ts | 60 +++++ src/web/styles.css | 35 +++ src/web/ui.ts | 194 ++++++++++++++++ test/api.test.ts | 169 +++++++++++++- 25 files changed, 1179 insertions(+), 242 deletions(-) create mode 100644 src/server/anmeldung.ts create mode 100644 src/server/ich.ts create mode 100644 src/server/migrations/007_anmeldung.sql create mode 100644 src/server/passwort.ts create mode 100644 src/web/anmeldung.ts create mode 100644 src/web/mitarbeiter.ts create mode 100644 src/web/ui.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index 49a6dbd..0e903ba 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,14 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.7.0 + +- Stufe 2 beginnt: Anmeldung und Rollen. Jede Person meldet sich mit eigenem Anmeldenamen und Passwort an; am Handy bleibt sie 90 Tage angemeldet. Unten links stehen Name, „Passwort ändern“ und „Abmelden“. +- Rollen: Inhaber sieht alles; Büro alles außer Benutzern und Daten (später auch Löhne, Jahresplan, BWA); Mitarbeiter nur „Meine Einsätze“ mit Baustelle, Adresse, Route und der Ablage ihrer Projekte, ohne Beträge. +- Neue Seite „Benutzer“ (nur Inhaber): Zugänge anlegen, Rolle ändern, Passwort neu vergeben, sperren. Für einen neuen Mitarbeiter entsteht der Kontakt automatisch, damit er im Terminplan eingeteilt werden kann. +- Erster Start auf dem Server: Inhaber mit Einrichtungscode anlegen. Die Anmeldung am Proxy entfällt. +- Testversion: keine Passwörter. Unten links wählst du, als wer du arbeitest, und siehst so die Mitarbeiter-Ansicht. + ## 0.6.1 - Projektseite wie in der freigegebenen Vorabansicht: Status direkt neben dem Namen, oben Arbeitsstunden, Kunde und Beschreibung gleich breit, darunter Zeitraum schmal und Baustelle doppelt breit; Stunden als „Ist / Soll Std.“ wie bei Plancraft. diff --git a/README.md b/README.md index 101e471..a54a3bd 100644 --- a/README.md +++ b/README.md @@ -50,6 +50,7 @@ cd deploy 1. Server mit Docker und git, Ports 80 und 443 frei, zwei DNS-Einträge (Produktion und Test) auf seine Adresse. 2. Repository von git.deichnet.com auf den Server klonen, `deploy/.env.beispiel` nach `deploy/.env` kopieren und ausfüllen. 3. `cd deploy && ./update.sh test 1.0.0 && ./update.sh produktion 1.0.0` baut das Image und startet beide Umgebungen samt Caddy (`docker compose up -d`). +4. Beim ersten Aufruf fragt das Programm nach dem Inhaber und dem Einrichtungscode (aus `.env` oder `docker compose logs app | grep Einrichtungscode`). Alle weiteren Zugänge legt der Inhaber unter „Benutzer“ an. Sicherung: jede Nacht und vor jedem Update, 30 Tage aufbewahrt, Kopie per WebDAV in die Nextcloud. Eine Sicherung von Hand: `docker compose exec backup sicherung`. diff --git a/demo/fastify.ts b/demo/fastify.ts index d12831a..043cc79 100644 --- a/demo/fastify.ts +++ b/demo/fastify.ts @@ -10,6 +10,8 @@ export interface Anfrage { query: Record; body: unknown; headers: Record; + routeOptions: { url?: string }; + wer?: unknown; } export class Antwort { @@ -30,12 +32,14 @@ export default function Fastify(_o?: unknown) { const routen: Route[] = []; let fehlerHandler: (err: unknown, req: Anfrage, reply: Antwort) => unknown = (err, _r, reply) => reply.status(500).send({ fehler: (err as Error).message }); + const haken: Handler[] = []; const neu = (methode: string) => (pfad: string, handler: Handler) => { routen.push({ methode, teile: pfad.split("/"), handler }); }; const app = { log: { error: console.error, warn: console.warn, info: () => {} }, get: neu("GET"), post: neu("POST"), put: neu("PUT"), patch: neu("PATCH"), delete: neu("DELETE"), setErrorHandler(fn: typeof fehlerHandler) { fehlerHandler = fn; }, + addHook(_art: "onRequest", fn: Handler) { haken.push(fn); }, setNotFoundHandler() {}, async register() {}, async close() {}, @@ -55,11 +59,13 @@ export default function Fastify(_o?: unknown) { break; } } - const req: Anfrage = { method: methode, url: u.pathname + u.search, params, query: Object.fromEntries(u.searchParams), body, headers }; + const req: Anfrage = { method: methode, url: u.pathname + u.search, params, query: Object.fromEntries(u.searchParams), body, headers, + routeOptions: { url: route?.teile.join("/") } }; if (!route) reply.status(404).send({ fehler: "Nicht gefunden" }); else { try { - const erg = await route.handler(req, reply); + for (const h of haken) if (!reply.gesendet) await h(req, reply); + const erg = reply.gesendet ? reply : await route.handler(req, reply); if (!reply.gesendet && erg !== reply) reply.send(erg); } catch (err) { await fehlerHandler(err, req, reply); diff --git a/demo/index.html b/demo/index.html index 9092661..2576668 100644 --- a/demo/index.html +++ b/demo/index.html @@ -10,6 +10,7 @@
diff --git a/demo/kern.ts b/demo/kern.ts index 4d7d531..bd1844c 100644 --- a/demo/kern.ts +++ b/demo/kern.ts @@ -8,10 +8,12 @@ import m003 from "../src/server/migrations/003_vorgangsnummer.sql"; import m004 from "../src/server/migrations/004_besetzung.sql"; import m005 from "../src/server/migrations/005_projektseite_kategorien.sql"; import m006 from "../src/server/migrations/006_zahlungsplan_automatisch.sql"; +import m007 from "../src/server/migrations/007_anmeldung.sql"; const MIGRATIONEN: [string, string][] = [ ["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004], ["005_projektseite_kategorien.sql", m005], ["006_zahlungsplan_automatisch.sql", m006], + ["007_anmeldung.sql", m007], ]; export async function starte(db: PGlite, v70?: unknown) { @@ -24,7 +26,7 @@ export async function starte(db: PGlite, v70?: unknown) { await t.query("insert into schema_version (name) values ($1)", [name]); }); } - const app = (await baueApp({ pool: alsPool(db) as any })) as unknown as { + const app = (await baueApp({ pool: alsPool(db) as any, anmeldung: "testversion" })) as unknown as { verarbeite(methode: string, adresse: string, body?: unknown, headers?: Record): Promise; }; if (v70 && (await db.query("select 1 from projekt limit 1")).rows.length === 0) { diff --git a/demo/main.ts b/demo/main.ts index 054a446..569f764 100644 --- a/demo/main.ts +++ b/demo/main.ts @@ -62,7 +62,7 @@ async function main() { if (speicher) { melde("Deine Daten werden geladen …"); const daten: Record[]> = {}; - for (const t of TABELLEN) daten[t.pfad] = await nochmal(() => alle(speicher, t.pfad)); + for (const pfad of [...TABELLEN.map((t) => t.pfad), "benutzer"]) daten[pfad] = await nochmal(() => alle(speicher, pfad)); const e = await nochmal(() => speicher.doc("meta/einstellungen").get()); if (Object.values(daten).some((z) => z.length) || e.exists) { const r = await app.verarbeite("POST", "/api/import/stand", { programm: "betrieb", einstellungen: e.data()?.daten, daten }); @@ -104,7 +104,8 @@ async function main() { if (!adresse.startsWith("/api/")) return original(eingabe, init); const methode = (init?.method ?? "GET").toUpperCase(); const body = typeof init?.body === "string" ? JSON.parse(init.body) : undefined; - const antwort = await app.verarbeite(methode, adresse, body, { "x-benutzer": "henning" }); + // die Oberfläche schickt mit, als wer Henning gerade arbeitet (x-test-benutzer) + const antwort = await app.verarbeite(methode, adresse, body, Object.fromEntries(new Headers(init?.headers).entries())); if (methode !== "GET" && antwort.ok) await speichern(); return antwort; }; diff --git a/demo/node.ts b/demo/node.ts index 8f3d588..bf0fe18 100644 --- a/demo/node.ts +++ b/demo/node.ts @@ -13,3 +13,8 @@ export function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean { } (globalThis as any).Buffer ??= { from: (s: string) => new TextEncoder().encode(s) }; + +// Passwörter gibt es in der Testversion nicht (src/server/passwort.ts) +const ohne = () => { throw new Error("In der Testversion gibt es keine Passwörter."); }; +export const scrypt = ohne; +export const createHash = () => ({ update: () => ({ digest: () => "" }) }); diff --git a/deploy/.env.beispiel b/deploy/.env.beispiel index 3cb5ea2..61f1b07 100644 --- a/deploy/.env.beispiel +++ b/deploy/.env.beispiel @@ -6,10 +6,9 @@ TEST_VERSION=1.0.0 DOMAIN=betrieb.schaarschmidt-holzbau.de TEST_DOMAIN=betrieb-test.schaarschmidt-holzbau.de DB_PASSWORT=bitte-lang-und-zufaellig -APP_BENUTZER=henning -# Erzeugen mit: docker run --rm caddy:2-alpine caddy hash-password --plaintext 'geheim' -# In .env jedes $ verdoppeln ($$), sonst liest Compose es als Variable. -APP_PASSWORT_HASH= +# Code für die Einrichtung beim ersten Start (Inhaber anlegen). Leer lassen: das Programm +# erzeugt einen und schreibt ihn ins Protokoll (docker compose logs app | grep Einrichtungscode). +EINRICHTUNGSCODE= BACKUP_UHRZEIT=02:30 NEXTCLOUD_URL=https://cloud.example.de/remote.php/dav/files/henning/Sicherungen/betrieb NEXTCLOUD_BENUTZER=henning diff --git a/deploy/Caddyfile b/deploy/Caddyfile index 61c4dc4..7b506d5 100644 --- a/deploy/Caddyfile +++ b/deploy/Caddyfile @@ -1,36 +1,13 @@ # HTTPS mit automatischem Zertifikat für Produktion und Testumgebung. -# Bis zur eigenen Benutzerverwaltung (Modul 16) schützt eine Anmeldung am Proxy -# das Programm; der Name geht als X-Benutzer an die App und ins Änderungsprotokoll. -# Ausnahme: die Kalender-Abos unter /kalender/ (Outlook classic kann sich nicht anmelden); -# sie sind durch ein Geheimnis im Link geschützt, das die App prüft. -(anmeldung) { - basic_auth { - {$APP_BENUTZER} {$APP_PASSWORT_HASH} - } -} +# Anmeldung und Rollen macht das Programm selbst (U1/U2, ab 0.7.0); Caddy reicht nur durch. +# Die Kalender-Abos unter /kalender/ sind durch ein Geheimnis im Link geschützt, das die App prüft. {$DOMAIN} { encode gzip - handle /kalender/* { - reverse_proxy app:3000 - } - handle { - import anmeldung - reverse_proxy app:3000 { - header_up X-Benutzer {http.auth.user.id} - } - } + reverse_proxy app:3000 } {$TEST_DOMAIN} { encode gzip - handle /kalender/* { - reverse_proxy app-test:3000 - } - handle { - import anmeldung - reverse_proxy app-test:3000 { - header_up X-Benutzer {http.auth.user.id} - } - } + reverse_proxy app-test:3000 } diff --git a/deploy/docker-compose.yml b/deploy/docker-compose.yml index c3d8fd5..9d0b144 100644 --- a/deploy/docker-compose.yml +++ b/deploy/docker-compose.yml @@ -41,6 +41,7 @@ services: image: ${IMAGE}:${APP_VERSION} environment: DATABASE_URL: postgres://betrieb:${DB_PASSWORT}@db:5432/betrieb + EINRICHTUNGSCODE: ${EINRICHTUNGSCODE:-} NEXTCLOUD_PROJEKTE_URL: ${NEXTCLOUD_PROJEKTE_URL:-} NEXTCLOUD_BENUTZER: ${NEXTCLOUD_BENUTZER:-} NEXTCLOUD_PASSWORT: ${NEXTCLOUD_PASSWORT:-} @@ -64,6 +65,7 @@ services: image: ${IMAGE}:${TEST_VERSION} environment: DATABASE_URL: postgres://betrieb:${DB_PASSWORT}@db-test:5432/betrieb + EINRICHTUNGSCODE: ${EINRICHTUNGSCODE:-} depends_on: db-test: { condition: service_healthy } db-test: @@ -87,8 +89,6 @@ services: environment: DOMAIN: ${DOMAIN} TEST_DOMAIN: ${TEST_DOMAIN} - APP_BENUTZER: ${APP_BENUTZER} - APP_PASSWORT_HASH: ${APP_PASSWORT_HASH} volumes: - ./Caddyfile:/etc/caddy/Caddyfile:ro - caddy:/data diff --git a/package.json b/package.json index e8b173c..b34bf6a 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.6.1", + "version": "0.7.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/server/anmeldung.ts b/src/server/anmeldung.ts new file mode 100644 index 0000000..de05c75 --- /dev/null +++ b/src/server/anmeldung.ts @@ -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(); + + async function ausSitzung(req: FastifyRequest): Promise { + 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 { + 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 = { 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 { + 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"; diff --git a/src/server/app.ts b/src/server/app.ts index b85c5e2..25c6134 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -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 { 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 { 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 { 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 { app.get("/api/export", async (_req, reply) => { const daten: Record = {}; 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 }; diff --git a/src/server/ich.ts b/src/server/ich.ts new file mode 100644 index 0000000..6b3d865 --- /dev/null +++ b/src/server/ich.ts @@ -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 { + 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): 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 }; + }); +} diff --git a/src/server/index.ts b/src/server/index.ts index 3e34f8b..c23d99a 100644 --- a/src/server/index.ts +++ b/src/server/index.ts @@ -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 }); diff --git a/src/server/migrations/007_anmeldung.sql b/src/server/migrations/007_anmeldung.sql new file mode 100644 index 0000000..93c1873 --- /dev/null +++ b/src/server/migrations/007_anmeldung.sql @@ -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); diff --git a/src/server/passwort.ts b/src/server/passwort.ts new file mode 100644 index 0000000..547c57d --- /dev/null +++ b/src/server/passwort.ts @@ -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 { + 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 { + 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 { + 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; +} diff --git a/src/server/stand.ts b/src/server/stand.ts index ba01e67..0f26305 100644 --- a/src/server/stand.ts +++ b/src/server/stand.ts @@ -39,6 +39,7 @@ export async function speichereStand(c: Client, s: Stand): Promise[]): Promise { + 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[]> { + return (await c.query("select id, anmeldename, name, rolle, kontakt_id, aktiv, angelegt_am from benutzer order by angelegt_am")).rows; +} diff --git a/src/web/anmeldung.ts b/src/web/anmeldung.ts new file mode 100644 index 0000000..842aab5 --- /dev/null +++ b/src/web/anmeldung.ts @@ -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 = { 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 = `
+ Holzbau Schaarschmidt +

${einrichtung ? "Programm einrichten" : "Anmelden"}

+ ${einrichtung ? `

Lege dich als Inhaber an. Den Einrichtungscode findest du im Protokoll des Servers.

+ ` : ""} + + + ${einrichtung ? `` : ""} + + + ${einrichtung ? "" : '

Passwort vergessen? Henning vergibt dir ein neues.

'} +
`; + 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 + ? `` + : `${esc(b.name)} · ${ROLLE_TEXT[b.rolle]}`; + const wahl = ziel.querySelector("#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 = `${esc(b.name)}${ROLLE_TEXT[b.rolle]} + + `; + ziel.onclick = async (ev) => { + let a = (ev.target as HTMLElement).closest("[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 { + return new Promise((fertig) => { + const huelle = document.getElementById("dialog-huelle")!; + huelle.innerHTML = `

${esc(titel)}

${knoepfe.map(([a, t]) => + ``).join("")}
`; + huelle.hidden = false; + huelle.onclick = (ev) => { + const w = (ev.target as HTMLElement).closest("[data-w]")?.dataset.w; + if (w === undefined) return; + huelle.hidden = true; + huelle.innerHTML = ""; + huelle.onclick = null; + fertig(w || undefined); + }; + }); +} + +export async function passwortAendern(): Promise { + 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 { + const [liste, kontakte] = await Promise.all([api("benutzer"), api("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" : 'fehlt') }]), + { titel: "Zugang", wert: (z) => (z.aktiv ? "aktiv" : 'gesperrt') }, + ], liste, (z) => void oeffnen(z))); + inhalt.insertAdjacentHTML("beforeend", testversion + ? `

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.

` + : `

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.

`); +} diff --git a/src/web/app.ts b/src/web/app.ts index 525cdfa..afb96e5 100644 --- a/src/web/app.ts +++ b/src/web/app.ts @@ -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; - -// ---------- Hilfen ---------- - -function esc(v: unknown): string { - return String(v ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" })[c]!); -} - -async function api(pfad: string, methode = "GET", body?: unknown): Promise { - 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]) => ``).join("") - + (bearbeiten ? `` : ""); - -/** Ein Auswahlfeld mit Eintrag „… bearbeiten“ verdrahten: nach dem Bearbeiten neue Optionen, alte Wahl bleibt. */ -function bearbeitbareAuswahl(sel: HTMLSelectElement, b: NonNullable, 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 = ``; - } else if (f.art === "langtext") { - eingabe = ``; - } else { - const typ = f.art === "datum" ? "date" : "text"; - const anzeige = f.art === "euro" && v != null ? formatEuro(v, false) : v; - eingabe = ``; - } - return `${eingabe}`; - }) - .join(""); - huelle.innerHTML = `

${esc(titel)}

${feldHtml}

-
${mitLoeschen ? '' : ""} -
`; - huelle.hidden = false; - const form = huelle.querySelector("form")!; - const schliessen = (e: Parameters[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 { - return new Promise((fertig) => { - const box = document.createElement("div"); - box.className = "dialog"; - box.style.position = "fixed"; - box.innerHTML = `

${esc(frage)}

`; - 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 { - 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 = `${spalten.map((s) => `${esc(s.titel)}`).join("")} - ${zeilen.map((z, i) => `${spalten.map((s) => `${s.wert(z)}`).join("")}`).join("")}`; - 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 = `

${esc(titel)}

${hinweisNachLaden ? `
${esc(hinweisNachLaden)}
` : ""}`; - 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 { const e = await dialog("Neues Projekt", await projektFelder(), { status: "anfrage" }, false); if (e?.aktion !== "speichern") return; const p = await api("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 { const eigeneAufgaben = alleAufgaben.filter((a) => a.projekt_id === id); const umsatz = p.umsatz_netto, kostenGesamt = kostenSumme(p); - inhalt.innerHTML = `${hinweisNachLaden ? `
${esc(hinweisNachLaden)}
` : ""} + inhalt.innerHTML = `${hinweis.text ? `
${esc(hinweis.text)}
` : ""}
←

${esc(p.bezeichnung)} (${esc(p.nummer)})

@@ -318,7 +148,7 @@ async function projektSeite(id: string): Promise {
`; - hinweisNachLaden = ""; + hinweis.text = ""; const oben = inhalt.querySelector("#p-oben")!; const unten = inhalt.querySelector("#p-unten")!; const teil = unten.querySelector("#teil")!; @@ -514,7 +344,7 @@ async function projektSeite(id: string): Promise { if (!e) return; if (e.aktion === "loeschen") { await api(`projekte/${id}`, "DELETE"); location.hash = "projekte"; return; } const r = await api(`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 { }); (inhalt.querySelector("#p-status") as HTMLSelectElement).onchange = async (ev) => { const r = await api(`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 { inhalt.appendChild(knopf); } -// Reihenfolge wie die Module im Lastenheft (Henning, 18.10.2026); Daten immer zuletzt -const REITER: [string, string, () => Promise][] = [ - ["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]; +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 = { @@ -956,34 +793,54 @@ const SYMBOLE: Record = { kontakte: '', liquiditaet: '', "laufende-kosten": '', + benutzer: '', + "meine-einsaetze": '', daten: '', }; const symbol = (id: string) => ``; const nav = document.getElementById("reiter")!; -nav.innerHTML = REITER.map(([id, titel]) => ``).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 { - const id = location.hash.slice(1) || "uebersicht"; - // Projektseite: #projekt-, gehört zum Reiter Projekte + const id = location.hash.slice(1) || REITER[0]![0]; + // Projektseite: #projekt-, gehört zum Reiter Projekte; Mitarbeiter: #ablage- 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", `

${esc((e as Error).message)}

`); } } -window.addEventListener("hashchange", zeige); + window.addEventListener("unhandledrejection", (ev) => { inhalt.insertAdjacentHTML("afterbegin", `

${esc(ev.reason?.message ?? ev.reason)}

`); }); -zeige(); + +async function start(): Promise { + let s = await api("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"); + } + 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]) => ``).join(""); + werLeiste(s); + window.addEventListener("hashchange", zeige); + await zeige(); +} +start().catch((e) => inhalt.insertAdjacentHTML("beforeend", `

${esc((e as Error).message)}

`)); api("status").then((s) => (document.getElementById("version")!.textContent = `Version ${s.version}`)).catch(() => {}); diff --git a/src/web/index.html b/src/web/index.html index 10e52b7..393726a 100644 --- a/src/web/index.html +++ b/src/web/index.html @@ -11,6 +11,7 @@
diff --git a/src/web/mitarbeiter.ts b/src/web/mitarbeiter.ts new file mode 100644 index 0000000..f063222 --- /dev/null +++ b/src/web/mitarbeiter.ts @@ -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 { + 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", '

In den nächsten drei Wochen bist du nirgends eingeteilt.

'); + 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 `

${d === r.heute ? "Heute, " : ""}${tagName(d)} ${dat(d)}

+ ${heuteDa.map((e) => { + const ort = adresse(e); + return `

${esc(e.nummer)} ${esc(e.bezeichnung)}

${esc(e.name)}

+ ${ort ? `

${esc(ort)} Route

` : ""} +

Ablage

`; + }).join("")}
`; + }).join(""); + inhalt.insertAdjacentHTML("beforeend", `
${html}
`); +} + +/** Projektordner in der Nextcloud, nur lesen */ +export async function ablageSeite(projektId: string, pfad = ""): Promise { + seite("Ablage"); + const ziel = document.createElement("div"); + inhalt.appendChild(ziel); + ziel.innerHTML = '

Lade den Projektordner …

'; + 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 = ` + ${a.eintraege.length ? `
    ${a.eintraege.map((e) => e.ordner + ? `
  • ` + : `
  • ${esc(e.name)}
  • `).join("")}
` + : '

Der Ordner ist leer.

'}`; + ziel.onclick = (ev) => { + const b = (ev.target as HTMLElement).closest("[data-ablage]"); + if (b) void ablageSeite(projektId, b.dataset.ablage!); + }; + } catch (e) { + ziel.innerHTML = `

${esc((e as Error).message)}

`; + } +} diff --git a/src/web/styles.css b/src/web/styles.css index ca82ed1..fa95557 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -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; } +} diff --git a/src/web/ui.ts b/src/web/ui.ts new file mode 100644 index 0000000..e99d323 --- /dev/null +++ b/src/web/ui.ts @@ -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; + +// ---------- Hilfen ---------- + +export function esc(v: unknown): string { + return String(v ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" })[c]!); +} + +/** Testversion: als wer Henning gerade arbeitet (Benutzer-ID), damit er die Mitarbeiter-Ansicht ausprobieren kann */ +export const TEST_BENUTZER = "betrieb-test-benutzer"; +export function lies(schluessel: string): string | null { + try { return localStorage.getItem(schluessel); } catch { return null; } +} +export function merke(schluessel: string, wert: string | null): void { + try { if (wert === null) localStorage.removeItem(schluessel); else localStorage.setItem(schluessel, wert); } catch { /* ohne Speicher */ } +} + +/** Wird aufgerufen, wenn der Server „bitte anmelden“ meldet (Sitzung abgelaufen oder abgemeldet) */ +export const abgemeldet = { melden: () => {} }; + +export async function api(pfad: string, methode = "GET", body?: unknown): Promise { + const kopf: Record = 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]) => ``).join("") + + (bearbeiten ? `` : ""); + +/** Ein Auswahlfeld mit Eintrag „… bearbeiten“ verdrahten: nach dem Bearbeiten neue Optionen, alte Wahl bleibt. */ +export function bearbeitbareAuswahl(sel: HTMLSelectElement, b: NonNullable, 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 = ``; + } else if (f.art === "langtext") { + eingabe = ``; + } else { + const typ = f.art === "datum" ? "date" : f.art === "passwort" ? "password" : "text"; + const anzeige = f.art === "euro" && v != null ? formatEuro(v, false) : v; + eingabe = ``; + } + return `${eingabe}${f.hilfe ? `${esc(f.hilfe)}` : ""}`; + }) + .join(""); + huelle.innerHTML = `

${esc(titel)}

${feldHtml}

+
${mitLoeschen ? '' : ""} +
`; + huelle.hidden = false; + const form = huelle.querySelector("form")!; + const schliessen = (e: Parameters[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 { + return new Promise((fertig) => { + const box = document.createElement("div"); + box.className = "dialog"; + box.style.position = "fixed"; + box.innerHTML = `

${esc(frage)}

`; + 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 { + 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 = `${spalten.map((s) => `${esc(s.titel)}`).join("")} + ${zeilen.map((z, i) => `${spalten.map((s) => `${s.wert(z)}`).join("")}`).join("")}`; + 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 = `

${esc(titel)}

${hinweis.text ? `
${esc(hinweis.text)}
` : ""}`; + 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; +} + diff --git a/test/api.test.ts b/test/api.test.ts index 9427cb4..4079664 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -21,7 +21,7 @@ describe.skipIf(!url)("API mit Datenbank", () => { pool = erstellePool(url!); await pool.query("drop schema public cascade; create schema public;"); await migriere(pool); - app = await baueApp({ pool, webOrdner: "/gibt-es-nicht" }); + app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" }); }); afterAll(async () => { await app?.close(); @@ -113,7 +113,7 @@ describe.skipIf(!url)("Übernahme aus V70 über die API", () => { pool = erstellePool(url!); await pool.query("drop schema public cascade; create schema public;"); await migriere(pool); - app = await baueApp({ pool, webOrdner: "/gibt-es-nicht" }); + app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" }); }); afterAll(async () => { await app?.close(); @@ -301,7 +301,7 @@ describe.skipIf(!url)("Projektordner in der Nextcloud über die API", () => { pool = erstellePool(url!); await pool.query("drop schema public cascade; create schema public;"); await migriere(pool); - app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", nextcloud: f.nc }); + app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", nextcloud: f.nc, anmeldung: "testversion" }); }); afterAll(async () => { await app?.close(); @@ -342,6 +342,17 @@ describe.skipIf(!url)("Projektordner in der Nextcloud über die API", () => { const nochmal = (await app.inject({ method: "POST", url: `/api/projekte/${r.json().id}/ordner` })).json(); expect(nochmal.nextcloud_link).toBe("01 Angebot/A-26-131 Gaube"); }); + + it("Testversion: der erste neue Benutzer legt den bisherigen Inhaber mit an", async () => { + const r = await app.inject({ method: "POST", url: "/api/benutzer", payload: { anmeldename: "jan", name: "Jan", rolle: "mitarbeiter" } }); + expect(r.statusCode, r.body).toBe(201); + const s = (await app.inject("/api/sitzung")).json(); + expect(s.benutzer).toMatchObject({ anmeldename: "henning", rolle: "inhaber" }); + expect(s.benutzer.id).toBeTruthy(); + expect(s.auswahl.map((x: { name: string }) => x.name).sort()).toEqual(["Henning", "Jan"]); + // Passwörter gibt es in der Testversion nicht + expect((await app.inject({ method: "PATCH", url: `/api/benutzer/${r.json().id}`, payload: { passwort: "geheim123" } })).statusCode).toBe(400); + }); }); describe.skipIf(!url)("Sicherung einspielen (Umzug aus der Testversion)", () => { @@ -353,7 +364,7 @@ describe.skipIf(!url)("Sicherung einspielen (Umzug aus der Testversion)", () => pool = erstellePool(url!); await pool.query("drop schema public cascade; create schema public;"); await migriere(pool); - app = await baueApp({ pool, webOrdner: "/gibt-es-nicht" }); + app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" }); }); afterAll(async () => { await app?.close(); @@ -390,3 +401,153 @@ describe.skipIf(!url)("Sicherung einspielen (Umzug aus der Testversion)", () => expect(v.json().nummer).toBeGreaterThan(Math.max(...vorher.daten.vorgaenge.map((x: { nummer: number }) => x.nummer))); }); }); + +describe.skipIf(!url)("Anmeldung und Rollen (U1, U2)", () => { + let pool: Pool; + let app: FastifyInstance; + const CODE = "einrichtung-123"; + + beforeAll(async () => { + pool = erstellePool(url!); + await pool.query("drop schema public cascade; create schema public;"); + await migriere(pool); + app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "passwort", einrichtungsCode: CODE }); + }); + afterAll(async () => { + await app?.close(); + await pool?.end(); + }); + + const keks = (r: { headers: Record }) => String(r.headers["set-cookie"]).split(";")[0]!; + const als = (cookie: string, method: "GET" | "POST" | "PATCH" | "DELETE", u: string, payload?: object) => + app.inject({ method, url: u, payload, headers: { cookie } }); + const anmelden = async (anmeldename: string, passwort: string) => { + const r = await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename, passwort } }); + expect(r.statusCode, r.body).toBe(200); + return keks(r); + }; + let inhaber = ""; + + it("ohne Anmeldung nichts außer Status und Anmeldeseite", async () => { + expect((await app.inject("/api/projekte")).statusCode).toBe(401); + expect((await app.inject("/api/status")).statusCode).toBe(200); + expect((await app.inject("/api/sitzung")).json()).toMatchObject({ art: "passwort", benutzer: null, einrichtung: true }); + }); + + it("Einrichtung legt den Inhaber nur mit dem richtigen Code an, und nur einmal", async () => { + const daten = { name: "Henning Schaarschmidt", anmeldename: "Henning", passwort: "sehrgeheim1" }; + expect((await app.inject({ method: "POST", url: "/api/einrichtung", payload: { ...daten, code: "falsch" } })).statusCode).toBe(403); + expect((await app.inject({ method: "POST", url: "/api/einrichtung", payload: { ...daten, passwort: "kurz", code: CODE } })).statusCode).toBe(400); + const r = await app.inject({ method: "POST", url: "/api/einrichtung", payload: { ...daten, code: CODE } }); + expect(r.statusCode, r.body).toBe(201); + expect(String(r.headers["set-cookie"])).toMatch(/HttpOnly; SameSite=Lax; Max-Age=7776000/); + inhaber = keks(r); + expect((await als(inhaber, "GET", "/api/sitzung")).json().benutzer).toMatchObject({ anmeldename: "henning", rolle: "inhaber" }); + expect((await als(inhaber, "GET", "/api/projekte")).statusCode).toBe(200); + expect((await app.inject({ method: "POST", url: "/api/einrichtung", payload: { ...daten, anmeldename: "zweiter", code: CODE } })).statusCode).toBe(409); + }); + + it("falsches Passwort und Sperre nach fünf Fehlversuchen", async () => { + expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "gibtsnicht", passwort: "x" } })).statusCode).toBe(401); + for (let i = 0; i < 5; i++) { + expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "henning", passwort: "falsch" } })).statusCode).toBe(401); + } + expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "henning", passwort: "sehrgeheim1" } })).statusCode).toBe(429); + // Groß/klein und Leerzeichen umgehen die Sperre nicht + expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "HENNING ", passwort: "sehrgeheim1" } })).statusCode).toBe(429); + }); + + it("Büro und Mitarbeiter: jeder sieht nur, was zu seiner Rolle gehört (E27, P13)", async () => { + const buero = await als(inhaber, "POST", "/api/benutzer", { anmeldename: "buero", name: "Büro", rolle: "buero", passwort: "buero12345" }); + expect(buero.statusCode, buero.body).toBe(201); + expect(buero.json()).not.toHaveProperty("passwort"); + expect(buero.json().hat_passwort).toBe(true); + const ma = (await als(inhaber, "POST", "/api/benutzer", { anmeldename: "jan", name: "Jan Zimmermann", rolle: "mitarbeiter", passwort: "jan123456" })).json(); + expect(ma.kontakt_id).toBeTruthy(); + const kontakt = (await als(inhaber, "GET", `/api/kontakte/${ma.kontakt_id}`)).json(); + expect(kontakt).toMatchObject({ name: "Jan Zimmermann", rolle: "mitarbeiter" }); + + // Jan ist auf einem von zwei Projekten eingeteilt + const neu = async (pfad: string, d: object) => (await als(inhaber, "POST", `/api/${pfad}`, d)).json(); + const p1 = await neu("projekte", { nummer: "P-26-101", bezeichnung: "Carport Kruse", baustelle_ort: "Mölln", umsatz_netto: 1_000_000 }); + const p2 = await neu("projekte", { nummer: "P-26-102", bezeichnung: "Dach Lange" }); + const a1 = await neu("abschnitte", { projekt_id: p1.id, name: "Montage" }); + const a2 = await neu("abschnitte", { projekt_id: p2.id, name: "Montage" }); + const v1 = await neu("vorgaenge", { abschnitt_id: a1.id, name: "Abbund", start: "2026-11-02", dauer: 2 }); + await neu("vorgaenge", { abschnitt_id: a2.id, name: "Richten", start: "2026-11-02", dauer: 2 }); + await neu("besetzungen", { vorgang_id: v1.id, kontakt_id: ma.kontakt_id }); + + const b = await anmelden("buero", "buero12345"); + expect((await als(b, "GET", "/api/projekte")).statusCode).toBe(200); + expect((await als(b, "GET", "/api/benutzer")).statusCode).toBe(403); + expect((await als(b, "GET", "/api/export")).statusCode).toBe(403); + expect((await als(b, "PATCH", `/api/projekte/${p2.id}`, { notiz: "Büro war hier" })).statusCode).toBe(200); + + const j = await anmelden("jan", "jan123456"); + for (const u of ["/api/projekte", "/api/zahlungen", "/api/kontakte", "/api/terminplan", "/api/uebersicht", "/api/liquiditaet", "/api/benutzer", "/api/einstellungen"]) { + expect((await als(j, "GET", u)).statusCode, u).toBe(403); + } + expect((await als(j, "PATCH", `/api/projekte/${p1.id}`, { umsatz_netto: 1 })).statusCode).toBe(403); + const e = (await als(j, "GET", "/api/ich/einsaetze?heute=2026-11-02")).json(); + expect(e.einsaetze).toHaveLength(1); + expect(e.einsaetze[0]).toMatchObject({ name: "Abbund", nummer: "P-26-101", baustelle_ort: "Mölln", anfang: "2026-11-02", ende: "2026-11-03" }); + expect(JSON.stringify(e)).not.toMatch(/umsatz|netto/); + // Ablage nur für eigene Projekte; ohne Nextcloud kommt beim eigenen der Hinweis + expect((await als(j, "GET", `/api/projekte/${p2.id}/ablage`)).statusCode).toBe(403); + expect((await als(j, "GET", `/api/projekte/${p1.id}/ablage`)).statusCode).toBe(409); + }); + + it("Passwort ändern meldet andere Geräte ab; gesperrte Benutzer kommen nicht mehr rein", async () => { + const j1 = await anmelden("jan", "jan123456"); + const j2 = await anmelden("jan", "jan123456"); + expect((await als(j1, "POST", "/api/ich/passwort", { alt: "falsch", neu: "neuespasswort" })).statusCode).toBe(400); + expect((await als(j1, "POST", "/api/ich/passwort", { alt: "jan123456", neu: "neuespasswort" })).statusCode).toBe(200); + expect((await als(j1, "GET", "/api/ich/einsaetze")).statusCode).toBe(200); + expect((await als(j2, "GET", "/api/ich/einsaetze")).statusCode).toBe(401); + + const jan = (await als(inhaber, "GET", "/api/benutzer")).json().find((x: { anmeldename: string }) => x.anmeldename === "jan"); + expect((await als(inhaber, "PATCH", `/api/benutzer/${jan.id}`, { aktiv: false })).statusCode).toBe(200); + expect((await als(j1, "GET", "/api/ich/einsaetze")).statusCode).toBe(401); + expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "jan", passwort: "neuespasswort" } })).statusCode).toBe(401); + }); + + it("es bleibt immer ein Inhaber; Passwörter stehen nirgends im Klartext oder im Protokoll", async () => { + const ich = (await als(inhaber, "GET", "/api/sitzung")).json().benutzer; + expect((await als(inhaber, "PATCH", `/api/benutzer/${ich.id}`, { rolle: "buero" })).statusCode).toBe(409); + expect((await als(inhaber, "DELETE", `/api/benutzer/${ich.id}`)).statusCode).toBe(409); + const prot = (await pool.query("select vorher, nachher from protokoll where tabelle = 'benutzer'")).rows; + expect(prot.length).toBeGreaterThan(0); + expect(JSON.stringify(prot)).not.toMatch(/passwort|scrypt/); + const hash = (await pool.query("select passwort from benutzer where anmeldename = 'henning'")).rows[0].passwort; + expect(hash).toMatch(/^scrypt\$/); + expect(hash).not.toContain("sehrgeheim1"); + const sicherung = (await als(inhaber, "GET", "/api/export")).json(); + expect(sicherung.daten.benutzer.length).toBe(3); + expect(JSON.stringify(sicherung)).not.toMatch(/scrypt/); + expect((await pool.query("select id from sitzung")).rows.every((r) => /^[0-9a-f]{64}$/.test(r.id))).toBe(true); + }); + + it("Anfragen von fremden Seiten werden abgewiesen", async () => { + const r = await app.inject({ method: "POST", url: "/api/aufgaben", payload: { text: "x" }, headers: { cookie: inhaber, origin: "https://boese.example", host: "betrieb.schaarschmidt-holzbau.de" } }); + expect(r.statusCode).toBe(403); + const ok = await app.inject({ method: "POST", url: "/api/aufgaben", payload: { text: "x" }, headers: { cookie: inhaber, origin: "https://betrieb.schaarschmidt-holzbau.de", host: "betrieb.schaarschmidt-holzbau.de" } }); + expect(ok.statusCode).toBe(201); + }); + + it("Abmelden beendet die Sitzung", async () => { + const b = await anmelden("buero", "buero12345"); + expect((await als(b, "POST", "/api/abmeldung")).statusCode).toBe(200); + expect((await als(b, "GET", "/api/projekte")).statusCode).toBe(401); + }); + + it("Testversion: wer gewählt ist, bekommt dessen Rechte", async () => { + const t = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" }); + const jan = (await pool.query("select id from benutzer where anmeldename = 'jan'")).rows[0].id; + await pool.query("update benutzer set aktiv = true where id = $1", [jan]); + expect((await t.inject("/api/projekte")).statusCode).toBe(200); + expect((await t.inject({ url: "/api/projekte", headers: { "x-test-benutzer": jan } })).statusCode).toBe(403); + expect((await t.inject({ url: "/api/sitzung", headers: { "x-test-benutzer": jan } })).json()).toMatchObject({ art: "testversion", benutzer: { anmeldename: "jan" } }); + expect((await t.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "jan", passwort: "neuespasswort" } })).statusCode).toBe(400); + await t.close(); + }); +});