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;
|
||||
}
|
||||
|
||||
167
src/web/anmeldung.ts
Normal file
167
src/web/anmeldung.ts
Normal file
@@ -0,0 +1,167 @@
|
||||
// U1/U2 in der Oberfläche: Anmeldeseite, Einrichtung, wer angemeldet ist, Benutzerverwaltung.
|
||||
|
||||
import { type Feld, type Zeile, TEST_BENUTZER, api, dialog, esc, inhalt, merke, seite, tabelle } from "./ui.js";
|
||||
|
||||
export type Rolle = "inhaber" | "buero" | "mitarbeiter";
|
||||
export interface Sitzung {
|
||||
art: "passwort" | "testversion";
|
||||
benutzer: { id: string | null; name: string; anmeldename: string; rolle: Rolle; kontakt_id: string | null } | null;
|
||||
einrichtung: boolean;
|
||||
auswahl?: { id: string; name: string; rolle: Rolle }[];
|
||||
}
|
||||
|
||||
export const ROLLE_TEXT: Record<Rolle, string> = { inhaber: "Inhaber", buero: "Büro", mitarbeiter: "Mitarbeiter" };
|
||||
|
||||
/** Anmeldeseite, auf dem Server auch die Einrichtung beim ersten Start. Danach lädt die Seite neu. */
|
||||
export function anmeldeSeite(s: Sitzung): void {
|
||||
document.body.classList.add("abgemeldet");
|
||||
const einrichtung = s.einrichtung;
|
||||
inhalt.innerHTML = `<form class="anmeldung" autocomplete="on">
|
||||
<img src="${esc((document.querySelector("#marke img") as HTMLImageElement | null)?.src ?? "")}" alt="Holzbau Schaarschmidt">
|
||||
<h1>${einrichtung ? "Programm einrichten" : "Anmelden"}</h1>
|
||||
${einrichtung ? `<p class="hinweis">Lege dich als Inhaber an. Den Einrichtungscode findest du im Protokoll des Servers.</p>
|
||||
<label for="a-name">Dein Name</label><input id="a-name" autocomplete="name" required>` : ""}
|
||||
<label for="a-anmeldename">Anmeldename</label><input id="a-anmeldename" autocomplete="username" autocapitalize="none" spellcheck="false" required>
|
||||
<label for="a-passwort">Passwort</label><input id="a-passwort" type="password" autocomplete="${einrichtung ? "new-password" : "current-password"}" required>
|
||||
${einrichtung ? `<label for="a-code">Einrichtungscode</label><input id="a-code" autocapitalize="none" spellcheck="false" required>` : ""}
|
||||
<p class="fehler" id="a-fehler" role="alert"></p>
|
||||
<button type="submit" class="haupt">${einrichtung ? "Einrichten und anmelden" : "Anmelden"}</button>
|
||||
${einrichtung ? "" : '<p class="hinweis">Passwort vergessen? Henning vergibt dir ein neues.</p>'}
|
||||
</form>`;
|
||||
const form = inhalt.querySelector("form")!;
|
||||
const wert = (id: string) => (form.querySelector(`#${id}`) as HTMLInputElement | null)?.value ?? "";
|
||||
(form.querySelector("input") as HTMLInputElement).focus();
|
||||
form.addEventListener("submit", async (ev) => {
|
||||
ev.preventDefault();
|
||||
const knopf = form.querySelector("button")!;
|
||||
knopf.disabled = true;
|
||||
try {
|
||||
if (einrichtung) await api("einrichtung", "POST", { name: wert("a-name"), anmeldename: wert("a-anmeldename"), passwort: wert("a-passwort"), code: wert("a-code") });
|
||||
else await api("anmeldung", "POST", { anmeldename: wert("a-anmeldename"), passwort: wert("a-passwort") });
|
||||
location.reload();
|
||||
} catch (e) {
|
||||
form.querySelector("#a-fehler")!.textContent = (e as Error).message;
|
||||
knopf.disabled = false;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/** Unten in der Seitenleiste: wer angemeldet ist. Testversion: Auswahl, als wer gearbeitet wird. */
|
||||
export function werLeiste(s: Sitzung): void {
|
||||
const ziel = document.getElementById("wer");
|
||||
const b = s.benutzer;
|
||||
if (!ziel || !b) return;
|
||||
if (s.art === "testversion") {
|
||||
const auswahl = s.auswahl ?? [];
|
||||
ziel.innerHTML = auswahl.length
|
||||
? `<label for="wer-wahl">Arbeiten als</label><select id="wer-wahl">${auswahl.map((x) =>
|
||||
`<option value="${esc(x.id)}"${x.id === b.id ? " selected" : ""}>${esc(x.name)} (${ROLLE_TEXT[x.rolle]})</option>`).join("")}</select>`
|
||||
: `<span>${esc(b.name)} · ${ROLLE_TEXT[b.rolle]}</span>`;
|
||||
const wahl = ziel.querySelector<HTMLSelectElement>("#wer-wahl");
|
||||
if (wahl) wahl.onchange = () => {
|
||||
merke(TEST_BENUTZER, wahl.value);
|
||||
location.hash = "";
|
||||
location.reload();
|
||||
};
|
||||
return;
|
||||
}
|
||||
const kurz = b.name.split(/\s+/).map((t) => t[0]).join("").slice(0, 2).toUpperCase();
|
||||
ziel.innerHTML = `<span>${esc(b.name)}<small>${ROLLE_TEXT[b.rolle]}</small></span>
|
||||
<button class="verweis" data-a="passwort">Passwort ändern</button> <button class="verweis" data-a="abmelden">Abmelden</button>
|
||||
<button class="konto" data-a="menue" aria-label="${esc(b.name)}: Konto">${esc(kurz)}</button>`;
|
||||
ziel.onclick = async (ev) => {
|
||||
let a = (ev.target as HTMLElement).closest<HTMLElement>("[data-a]")?.dataset.a;
|
||||
// am Handy: ein Knopf mit den Initialen, dahinter Passwort ändern und Abmelden
|
||||
if (a === "menue") a = await auswahl(`${b.name} (${ROLLE_TEXT[b.rolle]})`, [["passwort", "Passwort ändern"], ["abmelden", "Abmelden"]]);
|
||||
if (a === "abmelden") {
|
||||
await api("abmeldung", "POST").catch(() => {});
|
||||
location.hash = "";
|
||||
location.reload();
|
||||
}
|
||||
if (a === "passwort") await passwortAendern();
|
||||
};
|
||||
}
|
||||
|
||||
/** Kleiner eigener Auswahldialog (keine Browser-Abfragen) */
|
||||
function auswahl(titel: string, knoepfe: [string, string][]): Promise<string | undefined> {
|
||||
return new Promise((fertig) => {
|
||||
const huelle = document.getElementById("dialog-huelle")!;
|
||||
huelle.innerHTML = `<div class="dialog"><h2>${esc(titel)}</h2><div class="knoepfe">${knoepfe.map(([a, t]) =>
|
||||
`<button class="neben" data-w="${esc(a)}">${esc(t)}</button>`).join("")}<button class="neben" data-w="">Schließen</button></div></div>`;
|
||||
huelle.hidden = false;
|
||||
huelle.onclick = (ev) => {
|
||||
const w = (ev.target as HTMLElement).closest<HTMLElement>("[data-w]")?.dataset.w;
|
||||
if (w === undefined) return;
|
||||
huelle.hidden = true;
|
||||
huelle.innerHTML = "";
|
||||
huelle.onclick = null;
|
||||
fertig(w || undefined);
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
export async function passwortAendern(): Promise<void> {
|
||||
const felder: Feld[] = [
|
||||
{ name: "alt", titel: "Bisheriges Passwort", art: "passwort", pflicht: true },
|
||||
{ name: "neu", titel: "Neues Passwort", art: "passwort", pflicht: true, hilfe: "Mindestens 8 Zeichen. Andere Geräte werden abgemeldet." },
|
||||
];
|
||||
for (;;) {
|
||||
const r = await dialog("Passwort ändern", felder, {}, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
try {
|
||||
await api("ich/passwort", "POST", r.daten);
|
||||
return;
|
||||
} catch (e) {
|
||||
felder[0]!.hilfe = (e as Error).message;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- Benutzerverwaltung (nur Inhaber) ----------
|
||||
|
||||
export async function benutzerSeite(s: Sitzung): Promise<void> {
|
||||
const [liste, kontakte] = await Promise.all([api<Zeile[]>("benutzer"), api<Zeile[]>("kontakte")]);
|
||||
const mitarbeiter = kontakte.filter((k) => k.rolle === "mitarbeiter");
|
||||
const kontaktName = Object.fromEntries(kontakte.map((k) => [k.id, k.name]));
|
||||
const testversion = s.art === "testversion";
|
||||
const felder = (neu: boolean): Feld[] => [
|
||||
{ name: "name", titel: "Name", pflicht: true },
|
||||
{ name: "anmeldename", titel: "Anmeldename", pflicht: true, hilfe: "Kleinbuchstaben ohne Leerzeichen, z. B. jan oder j.meier" },
|
||||
{ name: "rolle", titel: "Rolle", art: "auswahl", optionen: [["mitarbeiter", "Mitarbeiter: eigene Einsätze und Stunden am Handy"], ["buero", "Büro: alles außer Löhnen, Jahresplan, BWA"], ["inhaber", "Inhaber: alles"]] },
|
||||
{ name: "kontakt_id", titel: "Kontakt (für Einsätze und Stunden)", art: "auswahl",
|
||||
optionen: [["", "– bei Mitarbeitern automatisch anlegen –"], ...mitarbeiter.map((k): [string, string] => [k.id, k.name])] },
|
||||
...(testversion ? [] : [{ name: "passwort", titel: neu ? "Passwort" : "Neues Passwort", art: "passwort" as const,
|
||||
hilfe: neu ? "Mindestens 8 Zeichen. Sag es der Person persönlich." : "Leer lassen, um das bisherige zu behalten. Ein neues meldet alle Geräte dieser Person ab." }]),
|
||||
{ name: "aktiv", titel: "Zugang", art: "auswahl", optionen: [["ja", "aktiv"], ["nein", "gesperrt"]] },
|
||||
];
|
||||
const ausDialog = (d: Zeile) => ({ ...d, aktiv: d.aktiv !== "nein", kontakt_id: d.kontakt_id || null, passwort: d.passwort || undefined });
|
||||
const oeffnen = async (z: Zeile | null) => {
|
||||
const werte = z ? { ...z, aktiv: z.aktiv ? "ja" : "nein", kontakt_id: z.kontakt_id ?? "" } : { rolle: "mitarbeiter", aktiv: "ja" };
|
||||
const f = felder(!z);
|
||||
for (;;) {
|
||||
const r = await dialog(z ? z.name : "Neuer Benutzer", f, werte, !!z && z.id !== s.benutzer?.id);
|
||||
if (!r) return;
|
||||
try {
|
||||
if (r.aktion === "loeschen") await api(`benutzer/${z!.id}`, "DELETE");
|
||||
else if (z) await api(`benutzer/${z.id}`, "PATCH", ausDialog(r.daten));
|
||||
else await api("benutzer", "POST", ausDialog(r.daten));
|
||||
return benutzerSeite(s);
|
||||
} catch (e) {
|
||||
if (r.aktion === "speichern") Object.assign(werte, r.daten);
|
||||
f.at(-1)!.hilfe = (e as Error).message;
|
||||
}
|
||||
}
|
||||
};
|
||||
seite("Benutzer", { text: "Neuer Benutzer", aktion: () => void oeffnen(null) });
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: "Name", wert: (z) => esc(z.name) },
|
||||
{ titel: "Anmeldename", wert: (z) => esc(z.anmeldename), klasse: "optional" },
|
||||
{ titel: "Rolle", wert: (z) => esc(ROLLE_TEXT[z.rolle as Rolle]) },
|
||||
{ titel: "Kontakt", wert: (z) => esc(kontaktName[z.kontakt_id] ?? ""), klasse: "optional" },
|
||||
...(testversion ? [] : [{ titel: "Passwort", wert: (z: Zeile) => (z.hat_passwort ? "vergeben" : '<span class="fehler">fehlt</span>') }]),
|
||||
{ titel: "Zugang", wert: (z) => (z.aktiv ? "aktiv" : '<span class="fehler">gesperrt</span>') },
|
||||
], liste, (z) => void oeffnen(z)));
|
||||
inhalt.insertAdjacentHTML("beforeend", testversion
|
||||
? `<p class="hinweis">Testversion: Passwörter gibt es erst auf dem Server. Unten links wählst du, als wer du arbeitest, und siehst so z. B. die Mitarbeiter-Ansicht.</p>`
|
||||
: `<p class="hinweis">Mitarbeiter sehen am Handy nur ihre eigenen Einsätze mit Adresse, ihre Stunden und die Ablage ihrer Projekte, keine Beträge. Das Büro sieht alles außer Löhnen, Jahresplan, BWA und dieser Seite.</p>`);
|
||||
}
|
||||
241
src/web/app.ts
241
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<string, any>;
|
||||
|
||||
// ---------- Hilfen ----------
|
||||
|
||||
function esc(v: unknown): string {
|
||||
return String(v ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" })[c]!);
|
||||
}
|
||||
|
||||
async function api<T = any>(pfad: string, methode = "GET", body?: unknown): Promise<T> {
|
||||
const r = await fetch(`/api/${pfad}`, {
|
||||
method: methode,
|
||||
headers: body === undefined ? {} : { "content-type": "application/json" },
|
||||
body: body === undefined ? undefined : JSON.stringify(body),
|
||||
});
|
||||
if (r.status === 204) return undefined as T;
|
||||
const j = await r.json().catch(() => ({}));
|
||||
if (!r.ok) throw new Error([j.fehler ?? `Fehler ${r.status}`, ...(j.details ?? [])].join("\n"));
|
||||
return j as T;
|
||||
}
|
||||
|
||||
const inhalt = document.getElementById("inhalt")!;
|
||||
const huelle = document.getElementById("dialog-huelle")!;
|
||||
const heute = () => new Date().toISOString().slice(0, 10);
|
||||
const euro = (c: number | null | undefined) => (c == null ? "" : formatEuro(c));
|
||||
const dat = (d: string | null | undefined) => (d ? formatDatum(d) : "");
|
||||
const MONATSNAMEN = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
|
||||
|
||||
// ---------- Eigene Dialoge (keine Browser-Abfragen) ----------
|
||||
|
||||
interface Feld {
|
||||
name: string;
|
||||
titel: string;
|
||||
art?: "text" | "euro" | "datum" | "auswahl" | "zahl" | "langtext";
|
||||
optionen?: [string, string][];
|
||||
pflicht?: boolean;
|
||||
/** Auswahl mit letztem Eintrag „… bearbeiten“: öffnet einen Editor und liefert die neuen Optionen */
|
||||
bearbeiten?: { text: string; aktion: () => Promise<[string, string][]> };
|
||||
}
|
||||
|
||||
const BEARBEITEN = "__bearbeiten";
|
||||
const optionenHtml = (optionen: [string, string][], wert: string, bearbeiten?: Feld["bearbeiten"]) =>
|
||||
optionen.map(([w, t]) => `<option value="${esc(w)}"${w === wert ? " selected" : ""}>${esc(t)}</option>`).join("")
|
||||
+ (bearbeiten ? `<option value="${BEARBEITEN}">${esc(bearbeiten.text)}</option>` : "");
|
||||
|
||||
/** Ein Auswahlfeld mit Eintrag „… bearbeiten“ verdrahten: nach dem Bearbeiten neue Optionen, alte Wahl bleibt. */
|
||||
function bearbeitbareAuswahl(sel: HTMLSelectElement, b: NonNullable<Feld["bearbeiten"]>, geaendert?: () => void): void {
|
||||
let vorher = sel.value;
|
||||
sel.addEventListener("change", async () => {
|
||||
if (sel.value !== BEARBEITEN) { vorher = sel.value; geaendert?.(); return; }
|
||||
const neu = await b.aktion();
|
||||
sel.innerHTML = optionenHtml(neu, neu.some(([w]) => w === vorher) ? vorher : "", b);
|
||||
vorher = sel.value;
|
||||
geaendert?.();
|
||||
});
|
||||
}
|
||||
|
||||
function dialog(titel: string, felder: Feld[], werte: Zeile, mitLoeschen: boolean): Promise<{ aktion: "speichern"; daten: Zeile } | { aktion: "loeschen" } | null> {
|
||||
return new Promise((fertig) => {
|
||||
const feldHtml = felder
|
||||
.map((f) => {
|
||||
const v = werte[f.name];
|
||||
const id = `f-${f.name}`;
|
||||
let eingabe: string;
|
||||
if (f.art === "auswahl") {
|
||||
eingabe = `<select id="${id}">${optionenHtml(f.optionen!, v ?? "", f.bearbeiten)}</select>`;
|
||||
} else if (f.art === "langtext") {
|
||||
eingabe = `<textarea id="${id}" rows="3">${esc(v)}</textarea>`;
|
||||
} else {
|
||||
const typ = f.art === "datum" ? "date" : "text";
|
||||
const anzeige = f.art === "euro" && v != null ? formatEuro(v, false) : v;
|
||||
eingabe = `<input id="${id}" type="${typ}" value="${esc(anzeige)}"${f.art === "euro" || f.art === "zahl" ? ' inputmode="decimal"' : ""}>`;
|
||||
}
|
||||
return `<label for="${id}">${esc(f.titel)}${f.pflicht ? " *" : ""}</label>${eingabe}`;
|
||||
})
|
||||
.join("");
|
||||
huelle.innerHTML = `<form class="dialog"><h2>${esc(titel)}</h2>${feldHtml}<p class="fehler" id="dialog-fehler"></p>
|
||||
<div class="knoepfe">${mitLoeschen ? '<button type="button" class="neben links" data-a="loeschen">Löschen</button>' : ""}
|
||||
<button type="button" class="neben" data-a="abbrechen">Abbrechen</button><button type="submit" class="haupt">Speichern</button></div></form>`;
|
||||
huelle.hidden = false;
|
||||
const form = huelle.querySelector("form")!;
|
||||
const schliessen = (e: Parameters<typeof fertig>[0]) => {
|
||||
huelle.hidden = true;
|
||||
huelle.innerHTML = "";
|
||||
document.removeEventListener("keydown", taste);
|
||||
fertig(e);
|
||||
};
|
||||
const taste = (ev: KeyboardEvent) => ev.key === "Escape" && schliessen(null);
|
||||
document.addEventListener("keydown", taste);
|
||||
(form.querySelector("input,select,textarea") as HTMLElement | null)?.focus();
|
||||
for (const f of felder) if (f.bearbeiten) bearbeitbareAuswahl(form.querySelector(`#f-${f.name}`)!, f.bearbeiten);
|
||||
form.addEventListener("click", (ev) => {
|
||||
const a = (ev.target as HTMLElement).dataset.a;
|
||||
if (a === "abbrechen") schliessen(null);
|
||||
if (a === "loeschen") bestaetigen("Wirklich löschen?").then((ja) => ja && schliessen({ aktion: "loeschen" }));
|
||||
});
|
||||
form.addEventListener("submit", (ev) => {
|
||||
ev.preventDefault();
|
||||
const daten: Zeile = {};
|
||||
try {
|
||||
for (const f of felder) {
|
||||
const roh = (form.querySelector(`#f-${f.name}`) as HTMLInputElement).value.trim();
|
||||
if (f.pflicht && !roh) throw new Error(`${f.titel} fehlt`);
|
||||
if (f.art === "euro") daten[f.name] = roh ? parseEuro(roh) : f.pflicht ? 0 : null;
|
||||
else if (f.art === "zahl") daten[f.name] = roh ? Number(roh.replace(",", ".")) : null;
|
||||
else daten[f.name] = roh || null;
|
||||
}
|
||||
} catch (e) {
|
||||
form.querySelector("#dialog-fehler")!.textContent = (e as Error).message;
|
||||
return;
|
||||
}
|
||||
schliessen({ aktion: "speichern", daten });
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function bestaetigen(frage: string): Promise<boolean> {
|
||||
return new Promise((fertig) => {
|
||||
const box = document.createElement("div");
|
||||
box.className = "dialog";
|
||||
box.style.position = "fixed";
|
||||
box.innerHTML = `<h2>${esc(frage)}</h2><div class="knoepfe"><button class="neben" data-a="nein">Abbrechen</button><button class="haupt" data-a="ja">Ja</button></div>`;
|
||||
huelle.appendChild(box);
|
||||
box.addEventListener("click", (ev) => {
|
||||
const a = (ev.target as HTMLElement).dataset.a;
|
||||
if (!a) return;
|
||||
box.remove();
|
||||
fertig(a === "ja");
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
async function bearbeiten(pfad: string, titel: string, felder: Feld[], zeile: Zeile | null, vorgaben: Zeile = {}): Promise<boolean> {
|
||||
const e = await dialog(titel, felder, zeile ?? vorgaben, !!zeile);
|
||||
if (!e) return false;
|
||||
let antwort: Zeile | undefined;
|
||||
if (e.aktion === "loeschen") await api(`${pfad}/${zeile!.id}`, "DELETE");
|
||||
else if (zeile) antwort = await api(`${pfad}/${zeile.id}`, "PATCH", e.daten);
|
||||
else antwort = await api(pfad, "POST", { ...vorgaben, ...e.daten });
|
||||
// gespeichert, aber z. B. der Projektordner in der Nextcloud hat nicht geklappt
|
||||
if (antwort?.ordner_fehler) hinweisNachLaden = antwort.ordner_fehler;
|
||||
return true;
|
||||
}
|
||||
|
||||
let hinweisNachLaden = "";
|
||||
|
||||
function tabelle(spalten: { titel: string; wert: (z: Zeile) => string; klasse?: string }[], zeilen: Zeile[], klick?: (z: Zeile) => void): HTMLTableElement {
|
||||
const t = document.createElement("table");
|
||||
t.innerHTML = `<thead><tr>${spalten.map((s) => `<th class="${s.klasse ?? ""}">${esc(s.titel)}</th>`).join("")}</tr></thead>
|
||||
<tbody>${zeilen.map((z, i) => `<tr data-i="${i}" class="${klick ? "klickbar" : ""}">${spalten.map((s) => `<td class="${s.klasse ?? ""}">${s.wert(z)}</td>`).join("")}</tr>`).join("")}</tbody>`;
|
||||
if (klick) t.addEventListener("click", (ev) => {
|
||||
const tr = (ev.target as HTMLElement).closest("tr[data-i]") as HTMLElement | null;
|
||||
if (tr) klick(zeilen[Number(tr.dataset.i)]!);
|
||||
});
|
||||
return t;
|
||||
}
|
||||
|
||||
// Kopf wie bei Plancraft: Titel links, Hauptknopf rechts; darunter eine Leiste für Filter
|
||||
function seite(titel: string, knopf?: { text: string; aktion: () => void }): HTMLElement {
|
||||
inhalt.innerHTML = `<div class="kopf"><h1>${esc(titel)}</h1></div>${hinweisNachLaden ? `<div class="warnung">${esc(hinweisNachLaden)}</div>` : ""}`;
|
||||
hinweisNachLaden = "";
|
||||
if (knopf) {
|
||||
const b = document.createElement("button");
|
||||
b.className = "haupt";
|
||||
b.textContent = knopf.text;
|
||||
b.onclick = knopf.aktion;
|
||||
inhalt.firstElementChild!.appendChild(b);
|
||||
}
|
||||
const leiste = document.createElement("div");
|
||||
leiste.className = "leiste";
|
||||
inhalt.appendChild(leiste);
|
||||
return leiste;
|
||||
}
|
||||
|
||||
// ---------- Reiter ----------
|
||||
|
||||
@@ -236,7 +66,7 @@ async function projekte(): Promise<void> {
|
||||
const e = await dialog("Neues Projekt", await projektFelder(), { status: "anfrage" }, false);
|
||||
if (e?.aktion !== "speichern") return;
|
||||
const p = await api<Zeile>("projekte", "POST", ohneNull(e.daten));
|
||||
if (p.ordner_fehler) hinweisNachLaden = p.ordner_fehler;
|
||||
if (p.ordner_fehler) hinweis.text = p.ordner_fehler;
|
||||
location.hash = `projekt-${p.id}`;
|
||||
};
|
||||
seite("Projekte", { text: "Neues Projekt", aktion: neu });
|
||||
@@ -303,7 +133,7 @@ async function projektSeite(id: string): Promise<void> {
|
||||
const eigeneAufgaben = alleAufgaben.filter((a) => a.projekt_id === id);
|
||||
const umsatz = p.umsatz_netto, kostenGesamt = kostenSumme(p);
|
||||
|
||||
inhalt.innerHTML = `${hinweisNachLaden ? `<div class="warnung">${esc(hinweisNachLaden)}</div>` : ""}
|
||||
inhalt.innerHTML = `${hinweis.text ? `<div class="warnung">${esc(hinweis.text)}</div>` : ""}
|
||||
<div class="kopf projekt-kopf"><a class="neben zurueck" href="#projekte" aria-label="Zurück zur Projektliste">←</a>
|
||||
<h1>${esc(p.bezeichnung)} <span class="nummer">(${esc(p.nummer)})</span></h1>
|
||||
<select id="p-status" class="etikett ${esc(p.status)}" aria-label="Status">${optionenHtml(STATUS, p.status)}</select>
|
||||
@@ -318,7 +148,7 @@ async function projektSeite(id: string): Promise<void> {
|
||||
</div>
|
||||
<aside class="karte projekt-aufgaben" aria-label="Offene Aufgaben"></aside>
|
||||
</div>`;
|
||||
hinweisNachLaden = "";
|
||||
hinweis.text = "";
|
||||
const oben = inhalt.querySelector<HTMLElement>("#p-oben")!;
|
||||
const unten = inhalt.querySelector<HTMLElement>("#p-unten")!;
|
||||
const teil = unten.querySelector<HTMLElement>("#teil")!;
|
||||
@@ -514,7 +344,7 @@ async function projektSeite(id: string): Promise<void> {
|
||||
if (!e) return;
|
||||
if (e.aktion === "loeschen") { await api(`projekte/${id}`, "DELETE"); location.hash = "projekte"; return; }
|
||||
const r = await api<Zeile>(`projekte/${id}`, "PATCH", ohneNull(e.daten));
|
||||
if (r.ordner_fehler) hinweisNachLaden = r.ordner_fehler;
|
||||
if (r.ordner_fehler) hinweis.text = r.ordner_fehler;
|
||||
return neuLaden();
|
||||
}
|
||||
if (a === "zahlungsplan") {
|
||||
@@ -538,7 +368,7 @@ async function projektSeite(id: string): Promise<void> {
|
||||
});
|
||||
(inhalt.querySelector("#p-status") as HTMLSelectElement).onchange = async (ev) => {
|
||||
const r = await api<Zeile>(`projekte/${id}`, "PATCH", { status: (ev.target as HTMLSelectElement).value });
|
||||
if (r.ordner_fehler) hinweisNachLaden = r.ordner_fehler;
|
||||
if (r.ordner_fehler) hinweis.text = r.ordner_fehler;
|
||||
neuLaden();
|
||||
};
|
||||
}
|
||||
@@ -939,13 +769,20 @@ async function daten(): Promise<void> {
|
||||
inhalt.appendChild(knopf);
|
||||
}
|
||||
|
||||
// Reihenfolge wie die Module im Lastenheft (Henning, 18.10.2026); Daten immer zuletzt
|
||||
const REITER: [string, string, () => Promise<void>][] = [
|
||||
["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte],
|
||||
["terminplan", "Terminplan", terminplan], ["kontakte", "Kontakte", kontakte],
|
||||
["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten],
|
||||
["daten", "Daten", daten],
|
||||
];
|
||||
// Reihenfolge wie die Module im Lastenheft (Henning, 18.10.2026); Benutzer und Daten immer zuletzt.
|
||||
// Was jemand sieht, hängt an seiner Rolle (U2); Mitarbeiter bekommen ihre eigene, schlanke Ansicht (E27).
|
||||
type Reiter = [string, string, () => Promise<void>];
|
||||
function reiterFuer(s: Sitzung): Reiter[] {
|
||||
const rolle = s.benutzer?.rolle;
|
||||
if (rolle === "mitarbeiter") return [["meine-einsaetze", "Meine Einsätze", meineEinsaetze]];
|
||||
const alle: Reiter[] = [
|
||||
["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte],
|
||||
["terminplan", "Terminplan", terminplan], ["kontakte", "Kontakte", kontakte],
|
||||
["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten],
|
||||
];
|
||||
if (rolle === "inhaber") alle.push(["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]);
|
||||
return alle;
|
||||
}
|
||||
|
||||
// Einfache Strichsymbole (24er Raster), Farbe kommt aus der Schrift
|
||||
const SYMBOLE: Record<string, string> = {
|
||||
@@ -956,34 +793,54 @@ const SYMBOLE: Record<string, string> = {
|
||||
kontakte: '<circle cx="12" cy="8" r="4"/><path d="M4 21c1-4 4-6 8-6s7 2 8 6"/>',
|
||||
liquiditaet: '<path d="M3 17l6-6 4 4 8-8"/><path d="M15 7h6v6"/>',
|
||||
"laufende-kosten": '<rect x="3" y="6" width="18" height="13" rx="1"/><path d="M3 10h18M7 15h4"/>',
|
||||
benutzer: '<circle cx="9" cy="8" r="3.5"/><path d="M2.5 20c.8-3.6 3.3-5.5 6.5-5.5s5.7 1.9 6.5 5.5"/><circle cx="17" cy="9" r="2.5"/><path d="M16 14.6c2.8.1 4.8 1.9 5.5 5.4"/>',
|
||||
"meine-einsaetze": '<rect x="3" y="5" width="18" height="16" rx="1"/><path d="M3 10h18M8 3v4M16 3v4M8 15l2.5 2.5L16 13"/>',
|
||||
daten: '<ellipse cx="12" cy="6" rx="8" ry="3"/><path d="M4 6v12c0 1.7 3.6 3 8 3s8-1.3 8-3V6M4 12c0 1.7 3.6 3 8 3s8-1.3 8-3"/>',
|
||||
};
|
||||
const symbol = (id: string) => `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${SYMBOLE[id] ?? ""}</svg>`;
|
||||
|
||||
const nav = document.getElementById("reiter")!;
|
||||
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("");
|
||||
let REITER: Reiter[] = [];
|
||||
nav.addEventListener("click", (ev) => {
|
||||
const r = ((ev.target as HTMLElement).closest("button[data-r]") as HTMLElement | null)?.dataset.r;
|
||||
if (r) location.hash = r;
|
||||
});
|
||||
|
||||
async function zeige(): Promise<void> {
|
||||
const id = location.hash.slice(1) || "uebersicht";
|
||||
// Projektseite: #projekt-<id>, gehört zum Reiter Projekte
|
||||
const id = location.hash.slice(1) || REITER[0]![0];
|
||||
// Projektseite: #projekt-<id>, gehört zum Reiter Projekte; Mitarbeiter: #ablage-<id>
|
||||
const treffer = /^projekt-([0-9a-f-]{36})(?:-(dokumente|berichte|ablage|zahlungen))?$/.exec(id);
|
||||
const ablage = /^ablage-([0-9a-f-]{36})$/.exec(id)?.[1];
|
||||
const projekt = treffer?.[1];
|
||||
if (treffer?.[2]) projektTeil = treffer[2];
|
||||
const reiter = REITER.find(([r]) => r === (projekt ? "projekte" : id)) ?? REITER[0]!;
|
||||
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0]));
|
||||
try {
|
||||
await (projekt ? projektSeite(projekt) : reiter[2]());
|
||||
await (ablage ? ablageSeite(ablage) : projekt && REITER.some(([r]) => r === "projekte") ? projektSeite(projekt) : reiter[2]());
|
||||
} catch (e) {
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`);
|
||||
}
|
||||
}
|
||||
window.addEventListener("hashchange", zeige);
|
||||
|
||||
window.addEventListener("unhandledrejection", (ev) => {
|
||||
inhalt.insertAdjacentHTML("afterbegin", `<p class="fehler">${esc(ev.reason?.message ?? ev.reason)}</p>`);
|
||||
});
|
||||
zeige();
|
||||
|
||||
async function start(): Promise<void> {
|
||||
let s = await api<Sitzung>("sitzung");
|
||||
// Testversion: gewählter Benutzer gelöscht oder gesperrt → wieder als Inhaber
|
||||
if (s.art === "testversion" && lies(TEST_BENUTZER) && s.benutzer?.id !== lies(TEST_BENUTZER)) {
|
||||
merke(TEST_BENUTZER, null);
|
||||
s = await api<Sitzung>("sitzung");
|
||||
}
|
||||
if (!s.benutzer) return anmeldeSeite(s);
|
||||
abgemeldet.melden = () => { location.hash = ""; location.reload(); };
|
||||
document.body.classList.toggle("rolle-mitarbeiter", s.benutzer.rolle === "mitarbeiter");
|
||||
REITER = reiterFuer(s);
|
||||
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("");
|
||||
werLeiste(s);
|
||||
window.addEventListener("hashchange", zeige);
|
||||
await zeige();
|
||||
}
|
||||
start().catch((e) => inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`));
|
||||
api("status").then((s) => (document.getElementById("version")!.textContent = `Version ${s.version}`)).catch(() => {});
|
||||
|
||||
@@ -11,6 +11,7 @@
|
||||
<aside id="seitenleiste">
|
||||
<div id="marke"><img src="/bilder/logo.png" alt="Holzbau Schaarschmidt"></div>
|
||||
<nav id="reiter"></nav>
|
||||
<div id="wer"></div>
|
||||
<span id="version"></span>
|
||||
</aside>
|
||||
<main id="inhalt"></main>
|
||||
|
||||
60
src/web/mitarbeiter.ts
Normal file
60
src/web/mitarbeiter.ts
Normal file
@@ -0,0 +1,60 @@
|
||||
// Ansicht für Mitarbeiter am Handy (E27, M9 vorab): eigene Einsätze mit Baustelle und Adresse, Ablage der eigenen Projekte.
|
||||
// Keine Beträge, keine Angebote oder Rechnungen (P13). Der Freitag erscheint nicht als Reserve.
|
||||
|
||||
import { type Zeile, api, dat, esc, heute, inhalt, seite } from "./ui.js";
|
||||
|
||||
const WOCHENTAG_LANG = ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"];
|
||||
const tagName = (d: string) => WOCHENTAG_LANG[new Date(`${d}T00:00:00Z`).getUTCDay()]!;
|
||||
const adresse = (e: Zeile) => [e.baustelle_strasse, [e.baustelle_plz, e.baustelle_ort].filter(Boolean).join(" ")].filter(Boolean).join(", ");
|
||||
|
||||
export async function meineEinsaetze(): Promise<void> {
|
||||
const r = await api<{ heute: string; bis: string; arbeitstage: number[]; einsaetze: Zeile[] }>(`ich/einsaetze?heute=${heute()}&tage=21`);
|
||||
seite("Meine Einsätze");
|
||||
if (!r.einsaetze.length) {
|
||||
inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis leer">In den nächsten drei Wochen bist du nirgends eingeteilt.</p>');
|
||||
return;
|
||||
}
|
||||
// je Arbeitstag, an dem etwas ansteht, die Einsätze untereinander
|
||||
const tage: string[] = [];
|
||||
for (let d = r.heute; d <= r.bis; d = new Date(Date.parse(`${d}T00:00:00Z`) + 86400000).toISOString().slice(0, 10)) {
|
||||
const wt = new Date(`${d}T00:00:00Z`).getUTCDay() || 7;
|
||||
if (r.arbeitstage.includes(wt)) tage.push(d);
|
||||
}
|
||||
const html = tage.map((d) => {
|
||||
const heuteDa = r.einsaetze.filter((e) => e.anfang <= d && e.ende >= d);
|
||||
if (!heuteDa.length) return "";
|
||||
return `<section class="tag-karte${d === r.heute ? " heute" : ""}"><h2>${d === r.heute ? "Heute, " : ""}${tagName(d)} ${dat(d)}</h2>
|
||||
${heuteDa.map((e) => {
|
||||
const ort = adresse(e);
|
||||
return `<article class="einsatz-karte"><h3>${esc(e.nummer)} ${esc(e.bezeichnung)}</h3><p>${esc(e.name)}</p>
|
||||
${ort ? `<p class="ort">${esc(ort)} <a class="neben" href="https://www.google.com/maps/dir/?api=1&destination=${encodeURIComponent(ort)}" target="_blank" rel="noopener">Route</a></p>` : ""}
|
||||
<p><a class="neben" href="#ablage-${esc(e.projekt_id)}">Ablage</a></p></article>`;
|
||||
}).join("")}</section>`;
|
||||
}).join("");
|
||||
inhalt.insertAdjacentHTML("beforeend", `<div class="meine-einsaetze">${html}</div>`);
|
||||
}
|
||||
|
||||
/** Projektordner in der Nextcloud, nur lesen */
|
||||
export async function ablageSeite(projektId: string, pfad = ""): Promise<void> {
|
||||
seite("Ablage");
|
||||
const ziel = document.createElement("div");
|
||||
inhalt.appendChild(ziel);
|
||||
ziel.innerHTML = '<p class="hinweis leer">Lade den Projektordner …</p>';
|
||||
try {
|
||||
const a = await api<{ ordner: string; eintraege: { name: string; ordner: boolean; groesse: number }[] }>(`projekte/${projektId}/ablage?pfad=${encodeURIComponent(pfad)}`);
|
||||
const teile = pfad ? pfad.split("/") : [];
|
||||
const voll = (n: string) => (pfad ? `${pfad}/${n}` : n);
|
||||
ziel.innerHTML = `<nav class="pfad"><button class="verweis" data-ablage="">${esc(a.ordner.split("/").at(-1))}</button>${teile.map((t, i) =>
|
||||
` / <button class="verweis" data-ablage="${esc(teile.slice(0, i + 1).join("/"))}">${esc(t)}</button>`).join("")}</nav>
|
||||
${a.eintraege.length ? `<ul class="ablage">${a.eintraege.map((e) => e.ordner
|
||||
? `<li><button class="eintrag" data-ablage="${esc(voll(e.name))}"><span class="sym" aria-hidden="true">📁</span><span class="name">${esc(e.name)}</span></button></li>`
|
||||
: `<li><a class="eintrag" href="/api/projekte/${esc(projektId)}/ablage/datei?pfad=${encodeURIComponent(voll(e.name))}" target="_blank" rel="noopener"><span class="sym" aria-hidden="true">📄</span><span class="name">${esc(e.name)}</span></a></li>`).join("")}</ul>`
|
||||
: '<p class="hinweis leer">Der Ordner ist leer.</p>'}`;
|
||||
ziel.onclick = (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-ablage]");
|
||||
if (b) void ablageSeite(projektId, b.dataset.ablage!);
|
||||
};
|
||||
} catch (e) {
|
||||
ziel.innerHTML = `<p class="hinweis leer">${esc((e as Error).message)}</p>`;
|
||||
}
|
||||
}
|
||||
@@ -420,3 +420,38 @@ h3.gruppe { padding: 8px 0 6px; border-bottom: 1px solid var(--linie); margin-to
|
||||
.uebersicht-kacheln { grid-template-columns: 1fr; grid-template-areas: "stunden" "kunde" "zeitraum" "baustelle" "beschreibung"; padding: 10px 4px; }
|
||||
}
|
||||
.g-links .g-raten.leise { color: var(--leise); text-decoration: none; }
|
||||
|
||||
/* Stufe 2: Anmeldung, wer angemeldet ist, Mitarbeiter-Ansicht */
|
||||
.dialog .hilfe { display: block; font-size: 12px; color: var(--leise); margin-top: 4px; }
|
||||
#wer { font-size: 13px; padding: 10px 10px 0; border-top: 1px solid rgb(255 255 255 / 0.08); display: flex; flex-direction: column; gap: 4px; }
|
||||
#wer:empty { display: none; }
|
||||
#wer span { color: #fff; display: flex; flex-direction: column; }
|
||||
#wer small { color: var(--leiste-text); }
|
||||
#wer label { color: var(--leiste-text); }
|
||||
#wer select { width: 100%; font: inherit; padding: 5px 6px; border-radius: 6px; border: 1px solid rgb(255 255 255 / 0.2); background: var(--leiste-aktiv); color: #fff; }
|
||||
#wer .verweis { color: var(--leiste-text); text-align: left; padding: 0; }
|
||||
#wer .verweis:hover { color: #fff; }
|
||||
#wer .konto { display: none; }
|
||||
body.abgemeldet #seitenleiste { display: none; }
|
||||
body.abgemeldet #inhalt { display: grid; place-items: center; min-height: 100vh; }
|
||||
.anmeldung { background: var(--fl); border: 1px solid var(--linie); border-radius: 14px; padding: 26px 24px; width: min(380px, 100%); display: flex; flex-direction: column; }
|
||||
.anmeldung img { width: 110px; align-self: center; margin-bottom: 6px; }
|
||||
.anmeldung h1 { font-size: 22px; margin: 6px 0 4px; text-align: center; }
|
||||
.anmeldung label { font-size: 13px; color: var(--leise); margin: 14px 0 4px; }
|
||||
.anmeldung input { font: inherit; font-size: 17px; padding: 11px 12px; border-radius: 8px; border: 1px solid var(--linie); background: var(--bg); color: var(--text); }
|
||||
.anmeldung button.haupt { margin-top: 18px; padding: 13px 18px; font-size: 17px; }
|
||||
.anmeldung .fehler:empty { display: none; }
|
||||
.anmeldung .hinweis { font-size: 13px; text-align: center; margin: 12px 0 0; }
|
||||
.meine-einsaetze { display: flex; flex-direction: column; gap: 14px; max-width: 640px; }
|
||||
.tag-karte h2 { font-size: 16px; margin: 0 0 8px; }
|
||||
.tag-karte.heute h2 { color: var(--akzent); }
|
||||
.einsatz-karte { background: var(--fl); border: 1px solid var(--linie); border-radius: 12px; padding: 14px 16px; margin-bottom: 8px; }
|
||||
.einsatz-karte h3 { margin: 0 0 4px; font-size: 17px; }
|
||||
.einsatz-karte p { margin: 6px 0 0; }
|
||||
.einsatz-karte .ort { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; color: var(--leise); }
|
||||
@media (max-width: 800px) {
|
||||
#wer { flex-direction: row; align-items: center; border: 0; padding: 0 0 0 6px; white-space: nowrap; margin-left: auto; }
|
||||
#wer span, #wer label, #wer .verweis { display: none; }
|
||||
#wer .konto { display: grid; place-items: center; width: 36px; height: 36px; border-radius: 50%; border: 0; background: var(--leiste-aktiv); color: #fff; font: inherit; font-weight: 600; cursor: pointer; }
|
||||
#wer select { width: auto; }
|
||||
}
|
||||
|
||||
194
src/web/ui.ts
Normal file
194
src/web/ui.ts
Normal file
@@ -0,0 +1,194 @@
|
||||
// Bausteine der Oberfläche: Abruf, eigene Dialoge (keine Browser-Abfragen), Tabellen, Seitenkopf.
|
||||
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { formatDatum } from "../domain/datum.js";
|
||||
|
||||
export type Zeile = Record<string, any>;
|
||||
|
||||
// ---------- Hilfen ----------
|
||||
|
||||
export function esc(v: unknown): string {
|
||||
return String(v ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" })[c]!);
|
||||
}
|
||||
|
||||
/** Testversion: als wer Henning gerade arbeitet (Benutzer-ID), damit er die Mitarbeiter-Ansicht ausprobieren kann */
|
||||
export const TEST_BENUTZER = "betrieb-test-benutzer";
|
||||
export function lies(schluessel: string): string | null {
|
||||
try { return localStorage.getItem(schluessel); } catch { return null; }
|
||||
}
|
||||
export function merke(schluessel: string, wert: string | null): void {
|
||||
try { if (wert === null) localStorage.removeItem(schluessel); else localStorage.setItem(schluessel, wert); } catch { /* ohne Speicher */ }
|
||||
}
|
||||
|
||||
/** Wird aufgerufen, wenn der Server „bitte anmelden“ meldet (Sitzung abgelaufen oder abgemeldet) */
|
||||
export const abgemeldet = { melden: () => {} };
|
||||
|
||||
export async function api<T = any>(pfad: string, methode = "GET", body?: unknown): Promise<T> {
|
||||
const kopf: Record<string, string> = body === undefined ? {} : { "content-type": "application/json" };
|
||||
const test = lies(TEST_BENUTZER);
|
||||
if (test) kopf["x-test-benutzer"] = test;
|
||||
const r = await fetch(`/api/${pfad}`, { method: methode, headers: kopf, body: body === undefined ? undefined : JSON.stringify(body) });
|
||||
if (r.status === 401 && !["sitzung", "anmeldung"].includes(pfad)) abgemeldet.melden();
|
||||
if (r.status === 204) return undefined as T;
|
||||
const j = await r.json().catch(() => ({}));
|
||||
if (!r.ok) throw new Error([j.fehler ?? `Fehler ${r.status}`, ...(j.details ?? [])].join("\n"));
|
||||
return j as T;
|
||||
}
|
||||
|
||||
export const inhalt = document.getElementById("inhalt")!;
|
||||
export const huelle = document.getElementById("dialog-huelle")!;
|
||||
export const heute = () => new Date().toISOString().slice(0, 10);
|
||||
export const euro = (c: number | null | undefined) => (c == null ? "" : formatEuro(c));
|
||||
export const dat = (d: string | null | undefined) => (d ? formatDatum(d) : "");
|
||||
export const MONATSNAMEN = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
|
||||
|
||||
// ---------- Eigene Dialoge (keine Browser-Abfragen) ----------
|
||||
|
||||
export interface Feld {
|
||||
name: string;
|
||||
titel: string;
|
||||
art?: "text" | "euro" | "datum" | "auswahl" | "zahl" | "langtext" | "passwort";
|
||||
/** kleiner Hinweis unter dem Feld */
|
||||
hilfe?: string;
|
||||
optionen?: [string, string][];
|
||||
pflicht?: boolean;
|
||||
/** Auswahl mit letztem Eintrag „… bearbeiten“: öffnet einen Editor und liefert die neuen Optionen */
|
||||
bearbeiten?: { text: string; aktion: () => Promise<[string, string][]> };
|
||||
}
|
||||
|
||||
export const BEARBEITEN = "__bearbeiten";
|
||||
export const optionenHtml = (optionen: [string, string][], wert: string, bearbeiten?: Feld["bearbeiten"]) =>
|
||||
optionen.map(([w, t]) => `<option value="${esc(w)}"${w === wert ? " selected" : ""}>${esc(t)}</option>`).join("")
|
||||
+ (bearbeiten ? `<option value="${BEARBEITEN}">${esc(bearbeiten.text)}</option>` : "");
|
||||
|
||||
/** Ein Auswahlfeld mit Eintrag „… bearbeiten“ verdrahten: nach dem Bearbeiten neue Optionen, alte Wahl bleibt. */
|
||||
export function bearbeitbareAuswahl(sel: HTMLSelectElement, b: NonNullable<Feld["bearbeiten"]>, geaendert?: () => void): void {
|
||||
let vorher = sel.value;
|
||||
sel.addEventListener("change", async () => {
|
||||
if (sel.value !== BEARBEITEN) { vorher = sel.value; geaendert?.(); return; }
|
||||
const neu = await b.aktion();
|
||||
sel.innerHTML = optionenHtml(neu, neu.some(([w]) => w === vorher) ? vorher : "", b);
|
||||
vorher = sel.value;
|
||||
geaendert?.();
|
||||
});
|
||||
}
|
||||
|
||||
export function dialog(titel: string, felder: Feld[], werte: Zeile, mitLoeschen: boolean): Promise<{ aktion: "speichern"; daten: Zeile } | { aktion: "loeschen" } | null> {
|
||||
return new Promise((fertig) => {
|
||||
const feldHtml = felder
|
||||
.map((f) => {
|
||||
const v = werte[f.name];
|
||||
const id = `f-${f.name}`;
|
||||
let eingabe: string;
|
||||
if (f.art === "auswahl") {
|
||||
eingabe = `<select id="${id}">${optionenHtml(f.optionen!, v ?? "", f.bearbeiten)}</select>`;
|
||||
} else if (f.art === "langtext") {
|
||||
eingabe = `<textarea id="${id}" rows="3">${esc(v)}</textarea>`;
|
||||
} else {
|
||||
const typ = f.art === "datum" ? "date" : f.art === "passwort" ? "password" : "text";
|
||||
const anzeige = f.art === "euro" && v != null ? formatEuro(v, false) : v;
|
||||
eingabe = `<input id="${id}" type="${typ}" value="${esc(anzeige)}"${f.art === "euro" || f.art === "zahl" ? ' inputmode="decimal"' : ""}${f.art === "passwort" ? ' autocomplete="new-password"' : ""}>`;
|
||||
}
|
||||
return `<label for="${id}">${esc(f.titel)}${f.pflicht ? " *" : ""}</label>${eingabe}${f.hilfe ? `<small class="hilfe">${esc(f.hilfe)}</small>` : ""}`;
|
||||
})
|
||||
.join("");
|
||||
huelle.innerHTML = `<form class="dialog"><h2>${esc(titel)}</h2>${feldHtml}<p class="fehler" id="dialog-fehler"></p>
|
||||
<div class="knoepfe">${mitLoeschen ? '<button type="button" class="neben links" data-a="loeschen">Löschen</button>' : ""}
|
||||
<button type="button" class="neben" data-a="abbrechen">Abbrechen</button><button type="submit" class="haupt">Speichern</button></div></form>`;
|
||||
huelle.hidden = false;
|
||||
const form = huelle.querySelector("form")!;
|
||||
const schliessen = (e: Parameters<typeof fertig>[0]) => {
|
||||
huelle.hidden = true;
|
||||
huelle.innerHTML = "";
|
||||
document.removeEventListener("keydown", taste);
|
||||
fertig(e);
|
||||
};
|
||||
const taste = (ev: KeyboardEvent) => ev.key === "Escape" && schliessen(null);
|
||||
document.addEventListener("keydown", taste);
|
||||
(form.querySelector("input,select,textarea") as HTMLElement | null)?.focus();
|
||||
for (const f of felder) if (f.bearbeiten) bearbeitbareAuswahl(form.querySelector(`#f-${f.name}`)!, f.bearbeiten);
|
||||
form.addEventListener("click", (ev) => {
|
||||
const a = (ev.target as HTMLElement).dataset.a;
|
||||
if (a === "abbrechen") schliessen(null);
|
||||
if (a === "loeschen") bestaetigen("Wirklich löschen?").then((ja) => ja && schliessen({ aktion: "loeschen" }));
|
||||
});
|
||||
form.addEventListener("submit", (ev) => {
|
||||
ev.preventDefault();
|
||||
const daten: Zeile = {};
|
||||
try {
|
||||
for (const f of felder) {
|
||||
const wert = (form.querySelector(`#f-${f.name}`) as HTMLInputElement).value;
|
||||
const roh = f.art === "passwort" ? wert : wert.trim();
|
||||
if (f.pflicht && !roh) throw new Error(`${f.titel} fehlt`);
|
||||
if (f.art === "euro") daten[f.name] = roh ? parseEuro(roh) : f.pflicht ? 0 : null;
|
||||
else if (f.art === "zahl") daten[f.name] = roh ? Number(roh.replace(",", ".")) : null;
|
||||
else daten[f.name] = roh || null;
|
||||
}
|
||||
} catch (e) {
|
||||
form.querySelector("#dialog-fehler")!.textContent = (e as Error).message;
|
||||
return;
|
||||
}
|
||||
schliessen({ aktion: "speichern", daten });
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
export function bestaetigen(frage: string): Promise<boolean> {
|
||||
return new Promise((fertig) => {
|
||||
const box = document.createElement("div");
|
||||
box.className = "dialog";
|
||||
box.style.position = "fixed";
|
||||
box.innerHTML = `<h2>${esc(frage)}</h2><div class="knoepfe"><button class="neben" data-a="nein">Abbrechen</button><button class="haupt" data-a="ja">Ja</button></div>`;
|
||||
huelle.appendChild(box);
|
||||
box.addEventListener("click", (ev) => {
|
||||
const a = (ev.target as HTMLElement).dataset.a;
|
||||
if (!a) return;
|
||||
box.remove();
|
||||
fertig(a === "ja");
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
export async function bearbeiten(pfad: string, titel: string, felder: Feld[], zeile: Zeile | null, vorgaben: Zeile = {}): Promise<boolean> {
|
||||
const e = await dialog(titel, felder, zeile ?? vorgaben, !!zeile);
|
||||
if (!e) return false;
|
||||
let antwort: Zeile | undefined;
|
||||
if (e.aktion === "loeschen") await api(`${pfad}/${zeile!.id}`, "DELETE");
|
||||
else if (zeile) antwort = await api(`${pfad}/${zeile.id}`, "PATCH", e.daten);
|
||||
else antwort = await api(pfad, "POST", { ...vorgaben, ...e.daten });
|
||||
// gespeichert, aber z. B. der Projektordner in der Nextcloud hat nicht geklappt
|
||||
if (antwort?.ordner_fehler) hinweis.text = antwort.ordner_fehler;
|
||||
return true;
|
||||
}
|
||||
|
||||
/** Hinweis, der nach dem nächsten Neuaufbau der Seite oben steht */
|
||||
export const hinweis = { text: "" };
|
||||
|
||||
export function tabelle(spalten: { titel: string; wert: (z: Zeile) => string; klasse?: string }[], zeilen: Zeile[], klick?: (z: Zeile) => void): HTMLTableElement {
|
||||
const t = document.createElement("table");
|
||||
t.innerHTML = `<thead><tr>${spalten.map((s) => `<th class="${s.klasse ?? ""}">${esc(s.titel)}</th>`).join("")}</tr></thead>
|
||||
<tbody>${zeilen.map((z, i) => `<tr data-i="${i}" class="${klick ? "klickbar" : ""}">${spalten.map((s) => `<td class="${s.klasse ?? ""}">${s.wert(z)}</td>`).join("")}</tr>`).join("")}</tbody>`;
|
||||
if (klick) t.addEventListener("click", (ev) => {
|
||||
const tr = (ev.target as HTMLElement).closest("tr[data-i]") as HTMLElement | null;
|
||||
if (tr) klick(zeilen[Number(tr.dataset.i)]!);
|
||||
});
|
||||
return t;
|
||||
}
|
||||
|
||||
// Kopf wie bei Plancraft: Titel links, Hauptknopf rechts; darunter eine Leiste für Filter
|
||||
export function seite(titel: string, knopf?: { text: string; aktion: () => void }): HTMLElement {
|
||||
inhalt.innerHTML = `<div class="kopf"><h1>${esc(titel)}</h1></div>${hinweis.text ? `<div class="warnung">${esc(hinweis.text)}</div>` : ""}`;
|
||||
hinweis.text = "";
|
||||
if (knopf) {
|
||||
const b = document.createElement("button");
|
||||
b.className = "haupt";
|
||||
b.textContent = knopf.text;
|
||||
b.onclick = knopf.aktion;
|
||||
inhalt.firstElementChild!.appendChild(b);
|
||||
}
|
||||
const leiste = document.createElement("div");
|
||||
leiste.className = "leiste";
|
||||
inhalt.appendChild(leiste);
|
||||
return leiste;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user