Anmeldung und Rollen: eigene Zugänge, Benutzerverwaltung, Mitarbeiter-Ansicht (0.7.0)
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:
292
src/server/anmeldung.ts
Normal file
292
src/server/anmeldung.ts
Normal 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";
|
||||
@@ -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
39
src/server/ich.ts
Normal 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 };
|
||||
});
|
||||
}
|
||||
@@ -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 });
|
||||
|
||||
|
||||
53
src/server/migrations/007_anmeldung.sql
Normal file
53
src/server/migrations/007_anmeldung.sql
Normal 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
42
src/server/passwort.ts
Normal 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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user