Files
Betriebsf-hrungssoftware/src/web/app.ts
Claude bc5e15339a
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
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
2026-10-20 06:26:05 +00:00

847 lines
62 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Oberfläche. Die Reiter folgen dem Lastenheft; Projektseite und Listen nach Vorbild Plancraft.
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";
// ---------- Reiter ----------
const ROLLEN: [string, string][] = [
["bauherr", "Bauherr"], ["subunternehmer", "Subunternehmer"], ["lieferant", "Lieferant"],
["planer", "Planer"], ["mitarbeiter", "Mitarbeiter"], ["sonstige", "Sonstige"],
];
const KONTAKT_FELDER: Feld[] = [
{ name: "name", titel: "Name", pflicht: true }, { name: "firma", titel: "Firma" },
{ name: "rolle", titel: "Rolle", art: "auswahl", optionen: ROLLEN }, { name: "gewerk", titel: "Gewerk" },
{ name: "telefon", titel: "Telefon" }, { name: "email", titel: "E-Mail" }, { name: "notiz", titel: "Notiz", art: "langtext" },
];
async function kontakte(): Promise<void> {
const neu = async () => (await bearbeiten("kontakte", "Neuer Kontakt", KONTAKT_FELDER, null)) && kontakte();
seite("Kontakte", { text: "Neuer Kontakt", aktion: neu });
const zeilen = await api<Zeile[]>("kontakte");
const rolle = Object.fromEntries(ROLLEN);
inhalt.appendChild(tabelle([
{ titel: "Name", wert: (z) => esc(z.name) },
{ titel: "Firma", wert: (z) => esc(z.firma), klasse: "optional" },
{ titel: "Rolle", wert: (z) => esc(rolle[z.rolle]) },
{ titel: "Telefon", wert: (z) => (z.telefon ? `<a href="tel:${esc(z.telefon)}">${esc(z.telefon)}</a>` : "") },
{ titel: "E-Mail", wert: (z) => esc(z.email), klasse: "optional" },
], zeilen, async (z) => (await bearbeiten("kontakte", "Kontakt bearbeiten", KONTAKT_FELDER, z)) && kontakte()));
}
const STATUS: [string, string][] = [
["anfrage", "Anfrage"], ["angebot", "Angebot"], ["auftrag", "Auftrag erhalten"], ["ausfuehrung", "Ausführung"],
["abgerechnet", "Abgerechnet"], ["gewaehrleistung", "Gewährleistung"], ["abgeschlossen", "Abgeschlossen"],
];
const STATUS_TEXT = Object.fromEntries(STATUS);
const etikett = (status: string) => `<span class="etikett ${esc(status)}">${esc(STATUS_TEXT[status] ?? status)}</span>`;
const VERTRAGSARTEN: [string, string][] = [["", "–"], ["vob", "VOB/B"], ["bgb", "BGB"]];
async function projektFelder(): Promise<Feld[]> {
const kontaktListe = await api<Zeile[]>("kontakte");
const sortiert = [...kontaktListe].sort((a, b) => Number(b.rolle === "bauherr") - Number(a.rolle === "bauherr") || a.name.localeCompare(b.name, "de"));
return [
{ name: "nummer", titel: "Nummer", pflicht: true }, { name: "bezeichnung", titel: "Bezeichnung", pflicht: true },
{ name: "status", titel: "Status", art: "auswahl", optionen: STATUS },
{ name: "bauherr_id", titel: "Kunde (Bauherr)", art: "auswahl", optionen: [["", "–"], ...sortiert.map((k): [string, string] => [k.id, k.name])] },
{ name: "baustelle_strasse", titel: "Baustelle: Straße" }, { name: "baustelle_plz", titel: "Baustelle: PLZ" }, { name: "baustelle_ort", titel: "Baustelle: Ort" },
{ name: "vertragsart", titel: "Vertragsart", art: "auswahl", optionen: VERTRAGSARTEN }, { name: "abnahme_am", titel: "Abnahme am", art: "datum" },
{ name: "umsatz_netto", titel: "Umsatz netto", art: "euro" }, { name: "material_kosten", titel: "Materialkosten", art: "euro" },
{ name: "fremd_kosten", titel: "Fremdkosten", art: "euro" }, { name: "sonstige_kosten", titel: "Sonstige Kosten", art: "euro" },
{ name: "notiz", titel: "Beschreibung", art: "langtext" },
];
}
const BETRAEGE = ["umsatz_netto", "material_kosten", "fremd_kosten", "sonstige_kosten"];
const ohneNull = (d: Zeile) => ({ ...d, ...Object.fromEntries(BETRAEGE.map((k) => [k, d[k] ?? 0])) });
const kostenSumme = (z: Zeile) => z.material_kosten + z.fremd_kosten + z.sonstige_kosten;
const ortZeile = (p: Zeile) => [p.baustelle_strasse, [p.baustelle_plz, p.baustelle_ort].filter(Boolean).join(" ")].filter(Boolean).join(", ");
async function projekte(): Promise<void> {
const neu = async () => {
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) hinweis.text = p.ordner_fehler;
location.hash = `projekt-${p.id}`;
};
seite("Projekte", { text: "Neues Projekt", aktion: neu });
const [zeilen, kontaktListe] = await Promise.all([api<Zeile[]>("projekte"), api<Zeile[]>("kontakte")]);
const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name]));
inhalt.appendChild(tabelle([
{ titel: "Name", wert: (z) => `<strong>${esc(z.bezeichnung)}</strong><span class="unter"><span class="nur-schmal">${esc(z.nummer)} · </span>${esc([ortZeile(z), name[z.bauherr_id]].filter(Boolean).join(" · ") || "–")}</span>` },
{ titel: "Nummer", wert: (z) => esc(z.nummer), klasse: "optional" },
{ titel: "Status", wert: (z) => etikett(z.status) },
{ titel: "Umsatz netto", wert: (z) => euro(z.umsatz_netto), klasse: "zahl optional" },
{ titel: "Kosten", wert: (z) => euro(kostenSumme(z)), klasse: "zahl optional" },
{ titel: "Rohertrag", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), klasse: "zahl optional" },
], zeilen, (z) => (location.hash = `projekt-${z.id}`)));
const gesamt = zeilen.reduce((s, z) => s + z.umsatz_netto - kostenSumme(z), 0);
inhalt.insertAdjacentHTML("beforeend", `<p class="anzahl">${zeilen.length} Projekte</p><p>Rohertrag gesamt: <strong>${euro(gesamt)}</strong></p>`);
}
// ---------- Projektseite (P2), aufgebaut wie bei Plancraft ----------
const ZAHLUNGSARTEN: [string, string][] = [["anzahlung", "Anzahlung"], ["abschlag", "Abschlag"], ["nachtrag", "Nachtrag"], ["schluss", "Schlussrechnung"], ["einbehalt", "Einbehalt"]];
const ZAHLUNGSSTATUS: [string, string][] = [["geplant", "geplant"], ["gestellt", "gestellt"], ["bezahlt", "bezahlt"]];
const KOSTENARTEN: [string, string][] = [["material", "Material"], ["fremd", "Fremdleistung"], ["sonstiges", "Sonstiges"]];
const KOSTENSTATUS: [string, string][] = [["geplant", "geplant"], ["bestellt", "bestellt"], ["bezahlt", "bezahlt"]];
const ZAHLUNG_FELDER: Feld[] = [
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "art", titel: "Art", art: "auswahl", optionen: ZAHLUNGSARTEN },
{ name: "netto", titel: "Betrag netto", art: "euro", pflicht: true }, { name: "termin", titel: "Termin", art: "datum", pflicht: true },
{ name: "status", titel: "Status", art: "auswahl", optionen: ZAHLUNGSSTATUS },
{ name: "rechnungsdatum", titel: "Rechnungsdatum", art: "datum" }, { name: "bezahlt_am", titel: "Bezahlt am", art: "datum" },
];
const KACHEL_SYMBOL: Record<string, string> = {
kunde: '<circle cx="12" cy="8" r="4"/><path d="M4 21c1-4 4-6 8-6s7 2 8 6"/>',
zeitraum: '<rect x="3" y="5" width="18" height="16" rx="1"/><path d="M3 10h18M8 3v4M16 3v4"/>',
baustelle: '<path d="M12 21s-7-6.2-7-11a7 7 0 0 1 14 0c0 4.8-7 11-7 11z"/><circle cx="12" cy="10" r="2.5"/>',
auftrag: '<path d="M7 3h8l4 4v14H7z"/><path d="M15 3v4h4M10 12h6M10 16h6"/>',
stunden: '<circle cx="12" cy="13" r="8"/><path d="M12 9v4l3 2M9 2h6"/>',
ordner: '<path d="M3 6a1 1 0 0 1 1-1h5l2 2h9a1 1 0 0 1 1 1v10a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1z"/>',
beschreibung: '<path d="M4 5h16v11H9l-5 4z"/>',
};
const symbolKachel = (art: string) => `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${KACHEL_SYMBOL[art]}</svg>`;
const kachel = (art: string, titel: string, inhaltHtml: string) => `<section class="kachel ${art}"><h3>${symbolKachel(art)}${esc(titel)}</h3>${inhaltHtml}</section>`;
// Projektseite wie Plancraft (Henning, 20.10.2026): oben Übersicht/Nachkalkulation mit Kacheln, darunter
// Dokumente, Berichte, Ablage und Zahlungsplan, rechts statt des Chats die offenen Aufgaben des Projekts
let projektOben = "uebersicht";
let projektTeil = "dokumente";
const projektAufgabenFilter = { kategorie: "", erledigte: false };
const ZAHLUNGSART_TEXT = Object.fromEntries(ZAHLUNGSARTEN);
const stundenText = (h: number) => `${Math.floor(h)}:${String(Math.round((h % 1) * 60)).padStart(2, "0")} Std.`;
const groesseText = (b: number) => (b >= 1048576 ? `${(b / 1048576).toFixed(1).replace(".", ",")} MB` : `${Math.max(1, Math.round(b / 1024))} KB`);
async function projektSeite(id: string): Promise<void> {
const [p, kontaktListe, plan, zahlungen, kosten, aufgabenDat, alleAufgaben] = await Promise.all([
api<Zeile>(`projekte/${id}`), api<Zeile[]>("kontakte"), api<Zeile>("terminplan"),
api<Zeile[]>("zahlungen"), api<Zeile[]>("kosten"), aufgabenDaten(), api<Zeile[]>("aufgaben"),
]);
const neuLaden = () => projektSeite(id);
const kontakt = Object.fromEntries(kontaktListe.map((k) => [k.id, k]));
const kunde = kontakt[p.bauherr_id];
const abschnitte = plan.abschnitte.filter((a: Zeile) => a.projekt_id === id);
const vorgaenge = plan.vorgaenge.filter((v: Zeile) => abschnitte.some((a: Zeile) => a.id === v.abschnitt_id));
const eigeneZahlungen = zahlungen.filter((z) => z.projekt_id === id);
const eigeneKosten = kosten.filter((k) => k.projekt_id === id);
const eigeneAufgaben = alleAufgaben.filter((a) => a.projekt_id === id);
const umsatz = p.umsatz_netto, kostenGesamt = kostenSumme(p);
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>
<button class="neben" data-a="bearbeiten">Bearbeiten</button></div>
<div class="projekt-raster">
<div class="projekt-haupt">
<section class="karte projekt-teile" id="p-oben"><div class="teile-kopf"><nav class="teile">
<button data-oben="uebersicht">Übersicht</button><button data-oben="nachkalkulation">Nachkalkulation</button></nav></div><div class="oben-inhalt"></div></section>
<section class="karte projekt-teile" id="p-unten"><div class="teile-kopf"><nav class="teile">${([["dokumente", "Dokumente"], ["berichte", "Berichte"], ["ablage", "Ablage"], ["zahlungen", "Zahlungsplan"]] as const)
.map(([t, titel]) => `<button data-teil="${t}">${titel}${t === "zahlungen" && eigeneZahlungen.length ? ` <small>${eigeneZahlungen.length}</small>` : ""}</button>`).join("")}</nav>
<span id="teil-knopf"></span></div><div id="teil"></div></section>
</div>
<aside class="karte projekt-aufgaben" aria-label="Offene Aufgaben"></aside>
</div>`;
hinweis.text = "";
const oben = inhalt.querySelector<HTMLElement>("#p-oben")!;
const unten = inhalt.querySelector<HTMLElement>("#p-unten")!;
const teil = unten.querySelector<HTMLElement>("#teil")!;
const knopfOrt = unten.querySelector<HTMLElement>("#teil-knopf")!;
const knopf = (text: string, aktion: () => void) => {
const b = document.createElement("button");
b.className = "haupt";
b.textContent = text;
b.onclick = aktion;
knopfOrt.replaceChildren(b);
};
const leer = (text: string) => Object.assign(document.createElement("p"), { className: "hinweis leer", textContent: text });
// ---------- oben: Übersicht und Nachkalkulation ----------
const zeigeOben = () => {
oben.querySelectorAll<HTMLElement>("[data-oben]").forEach((b) => b.classList.toggle("aktiv", b.dataset.oben === projektOben));
const ziel = oben.querySelector<HTMLElement>(".oben-inhalt")!;
if (projektOben === "uebersicht") {
const anfang = vorgaenge.map((v: Zeile) => v.anfang).sort()[0];
const ende = vorgaenge.map((v: Zeile) => v.ende).sort().at(-1);
const soll = vorgaenge.reduce((s: number, v: Zeile) => s + (Number(v.stunden) || 0), 0) || Number(p.soll_stunden) || 0;
const ist = 0; // kommt mit der Zeiterfassung (Stufe 2)
const anteil = soll ? Math.round((ist / soll) * 100) : null;
const adresse = ortZeile(p);
ziel.innerHTML = `<div class="uebersicht-kacheln">
${kachel("stunden", "Arbeitsstunden", `<div class="stunden"><div><p class="gross">${stundenText(ist)}</p><p>/ ${soll ? stundenText(soll) : "0:00 Std."}</p></div>
<svg class="ring" viewBox="0 0 36 36" role="img" aria-label="${anteil === null ? "keine Stunden geplant" : `${anteil} Prozent verbraucht`}"><circle cx="18" cy="18" r="15.5"/>${anteil ? `<circle class="wert" cx="18" cy="18" r="15.5" pathLength="100" stroke-dasharray="${Math.min(100, anteil)} 100"/>` : ""}<text x="18" y="21.5">${anteil === null ? "– %" : `${anteil} %`}</text></svg></div>
<p class="hinweis">Ist-Stunden kommen mit der Zeiterfassung.</p>`)}
${kachel("kunde", "Kunde", kunde
? `<p><a href="#kontakte" class="gross">${esc(kunde.name)}</a>${kunde.firma ? `<br>${esc(kunde.firma)}` : ""}</p>
<p class="hinweis">${[kunde.telefon && `<a href="tel:${esc(kunde.telefon)}">${esc(kunde.telefon)}</a>`, kunde.email && esc(kunde.email)].filter(Boolean).join("<br>")}</p>`
: '<p><button class="verweis" data-a="bearbeiten">Kunde zuordnen</button></p>')}
<section class="kachel beschreibung"><h3>${symbolKachel("beschreibung")}Beschreibung</h3>
<div class="text zelle-text" data-a="beschreibung" title="Klicken zum Bearbeiten">${p.notiz ? esc(p.notiz) : '<span class="hinweis">Keine Beschreibung. Klicken zum Schreiben.</span>'}</div></section>
${kachel("zeitraum", "Zeitraum", anfang
? `<p class="gross">${dat(anfang)} – ${dat(ende)}</p><p class="hinweis">${vorgaenge.length} ${vorgaenge.length === 1 ? "Vorgang" : "Vorgänge"} in ${abschnitte.length} ${abschnitte.length === 1 ? "Abschnitt" : "Abschnitten"} · <a href="#terminplan">Terminplan</a></p>`
: '<p><a href="#terminplan">Abschnitt im Terminplan hinzufügen</a></p>')}
${kachel("baustelle", "Baustelle", adresse
? `<p><a class="gross" href="https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(adresse)}" target="_blank" rel="noopener">${esc(p.baustelle_strasse ?? "")}<br>${esc([p.baustelle_plz, p.baustelle_ort].filter(Boolean).join(" "))}</a></p>`
: '<p><button class="verweis" data-a="bearbeiten">Adresse eintragen</button></p>')}
</div>`;
} else {
ziel.innerHTML = `<div class="nachkalkulation">
<dl class="werte"><dt>Auftragswert netto</dt><dd>${euro(umsatz)}</dd><dt>Kosten geplant</dt><dd>${euro(kostenGesamt)}</dd>
<dt>Rohertrag</dt><dd><b>${euro(umsatz - kostenGesamt)}</b>${umsatz ? ` <small>(${Math.round(((umsatz - kostenGesamt) / umsatz) * 100)} %)</small>` : ""}</dd>
<dt>Vertrag</dt><dd>${p.vertragsart ? (p.vertragsart === "vob" ? "VOB/B" : "BGB") : "–"}${p.abnahme_am ? ` · Abnahme ${dat(p.abnahme_am)}` : ""}</dd></dl>
<p class="hinweis">Der Vergleich Soll gegen Ist je Kostenart (Lohn, Material, Geräte, Fremdleistung) mit Zeiterfassung und Eingangsrechnungen kommt mit Stufe 5. Bis dahin stehen hier die geplanten Einzelkosten; die Pauschalen änderst du unter „Bearbeiten“.</p>
<div class="kosten-kopf"><h3>Einzelkosten</h3><button class="neben" data-a="kosten-neu">+ Kosten</button></div><div class="kosten-liste"></div></div>`;
const lieferanten = kontaktListe.filter((k) => ["lieferant", "subunternehmer"].includes(k.rolle));
const felder: Feld[] = [
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "art", titel: "Art", art: "auswahl", optionen: KOSTENARTEN },
{ name: "netto", titel: "Betrag netto", art: "euro", pflicht: true }, { name: "termin", titel: "Termin", art: "datum", pflicht: true },
{ name: "kontakt_id", titel: "Lieferant / Subunternehmer", art: "auswahl", optionen: [["", "–"], ...lieferanten.map((k): [string, string] => [k.id, k.name])] },
{ name: "status", titel: "Status", art: "auswahl", optionen: KOSTENSTATUS },
];
ziel.querySelector<HTMLButtonElement>('[data-a="kosten-neu"]')!.onclick = async () =>
(await bearbeiten("kosten", "Neue Kosten", felder, null, { projekt_id: id, art: "material", status: "geplant", termin: heute() })) && neuLaden();
ziel.querySelector(".kosten-liste")!.append(eigeneKosten.length ? tabelle([
{ titel: "Bezeichnung", wert: (k) => `${esc(k.bezeichnung)}<span class="unter">${esc([Object.fromEntries(KOSTENARTEN)[k.art], kontakt[k.kontakt_id]?.name].filter(Boolean).join(" · "))}</span>` },
{ titel: "Termin", wert: (k) => dat(k.termin) },
{ titel: "Status", wert: (k) => esc(k.status), klasse: "optional" },
{ titel: "Netto", wert: (k) => euro(k.netto), klasse: "zahl" },
], eigeneKosten, async (k) => (await bearbeiten("kosten", "Kosten bearbeiten", felder, k)) && neuLaden()) : leer("Noch keine Einzelkosten."));
}
};
// ---------- unten: Dokumente, Berichte, Ablage, Zahlungsplan ----------
let ablagePfad = "";
const zeigeTeil = () => {
unten.querySelectorAll<HTMLElement>("[data-teil]").forEach((b) => b.classList.toggle("aktiv", b.dataset.teil === projektTeil));
teil.replaceChildren();
knopfOrt.replaceChildren();
if (projektTeil === "dokumente") {
// Status getrennt nach Art: Rechnungen offen/überfällig/bezahlt; „Freigegeben“ heißt festgeschrieben
const rechnungen = eigeneZahlungen.filter((z) => z.status !== "geplant").sort((a, b) => (a.rechnungsdatum ?? a.termin).localeCompare(b.rechnungsdatum ?? b.termin));
let abschlag = 0;
const art = (z: Zeile) => (z.art === "abschlag" ? `${++abschlag}. Abschlag` : ZAHLUNGSART_TEXT[z.art] ?? z.art);
teil.innerHTML = `<h3 class="gruppe">Angebote</h3><p class="hinweis leer">Angebote, Kostenvoranschläge und Auftragsbestätigungen schreibst du bis Stufe 5 noch in Plancraft; die PDFs liegen in der Ablage unter „01 Auftrag“.</p>
<h3 class="gruppe">Rechnungen</h3>${rechnungen.length ? `<ul class="dokumente">${rechnungen.map((z) => {
const ueberfaellig = z.status === "gestellt" && z.termin < heute();
return `<li><button class="dokument" data-zahlung="${z.id}"><span><b>${esc(z.bezeichnung)}</b><span class="unter">${z.rechnungsdatum ? `Rechnung vom ${dat(z.rechnungsdatum)}` : `fällig ${dat(z.termin)}`} · ${euro(z.netto)} netto</span></span>
<span class="marken"><span class="marke ${z.status === "bezahlt" ? "gut" : ueberfaellig ? "schlecht" : "offen"}">${z.status === "bezahlt" ? `Bezahlt${z.bezahlt_am ? ` ${dat(z.bezahlt_am)}` : ""}` : ueberfaellig ? "Überfällig" : "Offen"}</span>
<span class="marke grau" title="Festgeschrieben, nicht mehr änderbar">Freigegeben</span><span class="marke dunkel">${esc(art(z))}</span></span></button></li>`;
}).join("")}</ul>` : '<p class="hinweis leer">Noch keine Rechnung gestellt. Eine Rate wird zur Rechnung, wenn du sie im Zahlungsplan auf „gestellt“ setzt.</p>'}`;
} else if (projektTeil === "berichte") {
teil.innerHTML = `<p class="hinweis leer">Noch keine Berichte.</p>
<ul class="kommt"><li><b>Bautagebuch</b> mit Wetter, Personal und Fotos, am Handy (Stufe 4)</li><li><b>Regiebericht</b> für Stundenlohnarbeiten, unterschreiben lassen (Stufe 4)</li><li><b>Abnahmeprotokoll</b> mit Mängeln und Unterschrift; stellt das Projekt auf Gewährleistung (Stufe 5)</li></ul>`;
} else if (projektTeil === "ablage") {
void zeigeAblage();
} else {
zeigeZahlungsplan();
}
};
async function zeigeAblage(): Promise<void> {
teil.innerHTML = '<p class="hinweis leer">Lade den Projektordner …</p>';
const teile = ablagePfad ? ablagePfad.split("/") : [];
const pfadLeiste = `<nav class="pfad" aria-label="Ordner"><button class="verweis" data-ablage="">${esc(p.nextcloud_link ? p.nextcloud_link.split("/").at(-1) : "Projektordner")}</button>${teile.map((t, i) =>
` / <button class="verweis" data-ablage="${esc(teile.slice(0, i + 1).join("/"))}">${esc(t)}</button>`).join("")}</nav>`;
try {
const a = await api<{ eintraege: { name: string; ordner: boolean; groesse: number; geaendert: string | null }[] }>(`projekte/${id}/ablage?pfad=${encodeURIComponent(ablagePfad)}`);
if (projektTeil !== "ablage") return;
const voll = (n: string) => (ablagePfad ? `${ablagePfad}/${n}` : n);
teil.innerHTML = `${pfadLeiste}${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/${id}/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>
<span class="hinweis">${e.geaendert ? dat(e.geaendert.slice(0, 10)) + " · " : ""}${groesseText(e.groesse)}</span></a></li>`).join("")}</ul>` : '<p class="hinweis leer">Der Ordner ist leer.</p>'}`;
} catch (e) {
if (projektTeil !== "ablage") return;
teil.innerHTML = `<p class="hinweis leer">${esc((e as Error).message)}</p>
<p class="hinweis">Im Projektordner liegen die Unterordner „01 Auftrag“ (Angebote, Auftragsbestätigung, Rechnungen, Lieferscheine), „02 Umsetzung“ und „03 Bilder“.</p>`;
}
}
function zeigeZahlungsplan(): void {
// eine geplante Rate hängt an einem Vorgang und wandert mit dessen Ende (Meilenstein im Terminplan)
const vorgangName = (vid: string) => vorgaenge.find((x: Zeile) => x.id === vid)?.name ?? "";
const felder: Feld[] = [...ZAHLUNG_FELDER];
felder.splice(4, 0, { name: "vorgang_id", titel: "Fällig nach Vorgang", art: "auswahl", optionen: [["", "– Termin von Hand –"], ...vorgaenge.map((v: Zeile): [string, string] => [v.id, v.name])] });
knopf("+ Zahlung", async () => (await bearbeiten("zahlungen", "Neue Zahlung", felder, null, { projekt_id: id, art: "abschlag", status: "geplant", termin: heute() })) && neuLaden());
const summe = eigeneZahlungen.reduce((s, z) => s + z.netto, 0);
const info = document.createElement("div");
info.className = "vorschlag";
if (!eigeneZahlungen.length && p.zahlungsplan !== "fest") {
info.innerHTML = `<p>Der Zahlungsplan entsteht automatisch, sobald der Auftragswert eingetragen ist und das Projekt Termine im Terminplan hat: 30 % Anzahlung bei Auftrag, 40 % nach Abbund und Richten, 20 % nach den Restarbeiten, 10 % Schlussrechnung nach Abnahme.</p>
${umsatz ? "" : '<button class="neben" data-a="bearbeiten">Auftragswert eintragen</button>'}`;
} else if (!eigeneZahlungen.length) {
info.innerHTML = `<p>Noch kein Zahlungsplan. Der Standard ist 30 % Anzahlung bei Auftrag, 40 % nach Abbund und Richten, 20 % nach den Restarbeiten und 10 % Schlussrechnung nach Abnahme.</p>
<button class="haupt" data-a="zahlungsplan">Standard-Zahlungsplan anlegen</button> <span class="fehler" role="status"></span>`;
} else {
info.innerHTML = `<p>${p.zahlungsplan === "auto"
? "Automatisch angelegt: Die Raten folgen dem Auftragswert und den Terminen, bis du eine davon von Hand änderst."
: "Fest: Geplante Raten, die an einem Vorgang hängen, wandern mit dessen Ende; Beträge ändern sich nur von Hand."}</p>`;
}
teil.append(info);
if (eigeneZahlungen.length) {
teil.append(tabelle([
{ titel: "Bezeichnung", wert: (z) => `${esc(z.bezeichnung)}<span class="unter">${esc(ZAHLUNGSART_TEXT[z.art] ?? "")}</span>` },
{ titel: "Termin", wert: (z) => `${dat(z.termin)}${z.vorgang_id ? `<span class="unter">nach ${esc(vorgangName(z.vorgang_id))}</span>` : ""}` },
{ titel: "Status", wert: (z) => `<span class="etikett zahlung-${esc(z.status)}">${esc(z.status)}</span>`, klasse: "optional" },
{ titel: "Netto", wert: (z) => euro(z.netto), klasse: "zahl" },
], eigeneZahlungen, async (z) => (await bearbeiten("zahlungen", "Zahlung bearbeiten", felder, z)) && neuLaden()));
teil.insertAdjacentHTML("beforeend", `<p class="summe">Summe ${euro(summe)}${umsatz && summe !== umsatz ? ` · Auftragswert ${euro(umsatz)}, Rest ${euro(umsatz - summe)}` : ""}</p>`);
}
}
// ---------- rechts: offene Aufgaben statt Chat ----------
const zeigeAufgaben = () => {
const f = projektAufgabenFilter;
const liste = eigeneAufgaben
.filter((a) => (f.erledigte || !a.erledigt_am) && (!f.kategorie || (f.kategorie === "ohne" ? !a.kategorie_id : a.kategorie_id === f.kategorie)))
.sort((a, b) => Number(!!a.erledigt_am) - Number(!!b.erledigt_am) || (a.faellig_am ?? "9999").localeCompare(b.faellig_am ?? "9999"));
const offen = eigeneAufgaben.filter((a) => !a.erledigt_am).length;
const seite = inhalt.querySelector<HTMLElement>(".projekt-aufgaben")!;
seite.innerHTML = `<div class="aufgaben-kopf"><h2>Offene Aufgaben <small>${offen}</small></h2><button class="haupt" data-a="aufgabe-neu">+ Aufgabe</button></div>
<div class="aufgaben-filter"><select id="pa-kategorie" aria-label="Kategorie">${optionenHtml([["", "Alle Kategorien"], ["ohne", "Ohne Kategorie"], ...kategorieOptionen(aufgabenDat.kategorien).slice(1)], f.kategorie)}</select>
<label class="schalter"><input type="checkbox" id="pa-erledigte"${f.erledigte ? " checked" : ""}> Erledigte</label></div>
${liste.length ? `<ul class="aufgaben-liste">${liste.map((a) => {
const ueber = !a.erledigt_am && a.faellig_am && a.faellig_am < heute();
return `<li class="${a.erledigt_am ? "erledigt" : ""}"><input type="checkbox" data-erledigt="${a.id}" aria-label="Erledigt"${a.erledigt_am ? " checked" : ""}>
<button class="aufgabe" data-aufgabe="${a.id}"><span class="text">${esc(a.text)}</span><span class="meta">${a.kategorie_id ? `<span class="kategorie">${esc(aufgabenDat.namen.kategorie[a.kategorie_id] ?? "")}</span>` : ""}${a.faellig_am ? `<span class="${ueber ? "fehler" : ""}">${ueber ? "überfällig seit " : "fällig "}${dat(a.faellig_am)}</span>` : ""}</span></button></li>`;
}).join("")}</ul>` : `<p class="hinweis leer">${offen ? "Keine Aufgabe in dieser Auswahl." : "Keine offenen Aufgaben zu diesem Projekt."}</p>`}`;
seite.querySelector<HTMLSelectElement>("#pa-kategorie")!.onchange = (ev) => { f.kategorie = (ev.target as HTMLSelectElement).value; zeigeAufgaben(); };
seite.querySelector<HTMLInputElement>("#pa-erledigte")!.onchange = (ev) => { f.erledigte = (ev.target as HTMLInputElement).checked; zeigeAufgaben(); };
};
zeigeOben();
zeigeTeil();
zeigeAufgaben();
inhalt.addEventListener("click", async function klick(ev) {
if (!document.body.contains(unten)) return inhalt.removeEventListener("click", klick);
const ziel = ev.target as HTMLElement;
const o = ziel.closest<HTMLElement>("[data-oben]")?.dataset.oben;
if (o) { projektOben = o; zeigeOben(); return; }
const t = ziel.closest<HTMLElement>("[data-teil]")?.dataset.teil;
if (t) { projektTeil = t; zeigeTeil(); return; }
const ordner = ziel.closest<HTMLElement>("[data-ablage]");
if (ordner) { ablagePfad = ordner.dataset.ablage!; void zeigeAblage(); return; }
const zid = ziel.closest<HTMLElement>("[data-zahlung]")?.dataset.zahlung;
if (zid) { projektTeil = "zahlungen"; zeigeTeil(); return; }
const erledigt = (ziel as HTMLInputElement).dataset?.erledigt;
if (erledigt) {
await api(`aufgaben/${erledigt}`, "PATCH", { erledigt_am: (ziel as HTMLInputElement).checked ? new Date().toISOString() : null });
return neuLaden();
}
const aid = ziel.closest<HTMLElement>("[data-aufgabe]")?.dataset.aufgabe;
if (aid) return (await bearbeiten("aufgaben", "Aufgabe bearbeiten", aufgabenDat.felder, eigeneAufgaben.find((a) => a.id === aid)!)) && neuLaden();
const a = ziel.closest<HTMLElement>("[data-a]")?.dataset.a;
if (a === "aufgabe-neu") return (await bearbeiten("aufgaben", "Neue Aufgabe", aufgabenDat.felder, null, { projekt_id: id, kontakt_id: p.bauherr_id ?? null })) && neuLaden();
if (a === "bearbeiten") {
const e = await dialog("Projekt bearbeiten", await projektFelder(), p, true);
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) hinweis.text = r.ordner_fehler;
return neuLaden();
}
if (a === "zahlungsplan") {
try { await api(`projekte/${id}/zahlungsplan`, "POST"); neuLaden(); } catch (err) { teil.querySelector(".fehler")!.textContent = (err as Error).message; }
return;
}
if (a === "beschreibung") {
const feld = ziel.closest<HTMLElement>("[data-a]")!;
if (feld.querySelector("textarea")) return;
feld.innerHTML = `<textarea rows="5" aria-label="Beschreibung">${esc(p.notiz ?? "")}</textarea><p><button class="haupt" data-a="beschreibung-sichern">Speichern</button> <button class="neben" data-a="beschreibung-weg">Abbrechen</button></p>`;
feld.querySelector("textarea")!.focus();
return;
}
if (a === "beschreibung-sichern") {
const text = inhalt.querySelector<HTMLTextAreaElement>(".beschreibung textarea")!.value.trim() || null;
await api(`projekte/${id}`, "PATCH", { notiz: text });
p.notiz = text;
return zeigeOben();
}
if (a === "beschreibung-weg") return zeigeOben();
});
(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) hinweis.text = r.ordner_fehler;
neuLaden();
};
}
async function terminplan(): Promise<void> {
await terminplanSeite({ api, dialog, esc, seite: (t) => seite(t), inhalt });
}
// Liquidität (Henning, 20.10.2026): oben die Lage in Zahlen und als Kontostandverlauf, darunter je Woche
// oder Monat jede einzelne Zahlung mit Datum, Projekt und Betrag zum Aufklappen
let liquiOffen = new Set<string>();
async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {
const leiste = seite("Liquidität");
leiste.innerHTML = `<select id="l-ansicht" aria-label="Zeitraster"><option value="woche">Wochen</option><option value="monat">Monate</option></select>
<select id="l-anzahl" aria-label="Anzahl">${[4, 8, 12, 26, 52].map((n) => `<option>${n}</option>`).join("")}</select>
<button class="neben" id="l-alle">Alle Zahlungen aufklappen</button>`;
const a = leiste.querySelector("#l-ansicht") as HTMLSelectElement;
const n = leiste.querySelector("#l-anzahl") as HTMLSelectElement;
a.value = ansicht;
n.value = String(anzahl);
a.onchange = n.onchange = () => liquiditaetSeite(a.value, Number(n.value));
const [perioden, projekte, einst] = await Promise.all([
api<Zeile[]>(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`), api<Zeile[]>("projekte"), api<Zeile>("einstellungen"),
]);
const projektName = new Map(projekte.map((p) => [p.nummer, p.bezeichnung]));
const zeitraum = (p: Zeile) => (ansicht === "woche" ? `KW ${kalenderwoche(p.von)} · ${dat(p.von).slice(0, 6)} – ${dat(p.bis).slice(0, 6)}` : `${MONATSNAMEN[Number(p.von.slice(5, 7)) - 1]} ${p.von.slice(0, 4)}`);
// Kennzahlen
const tief = perioden.reduce((m, p) => (p.kontostand < m.kontostand ? p : m), perioden[0] ?? { kontostand: 0 });
const summeEin = perioden.reduce((s, p) => s + p.einnahmen, 0), summeAus = perioden.reduce((s, p) => s + p.ausgaben, 0);
const ende = perioden.at(-1);
const kachel = (titel: string, wert: string, unter: string, rot = false) =>
`<div class="kachel liqui-zahl"><h3>${esc(titel)}</h3><p class="gross${rot ? " fehler" : ""}">${wert}</p><p class="hinweis">${unter}</p></div>`;
const startsaldo = Number(einst.startsaldo ?? 0);
inhalt.insertAdjacentHTML("beforeend", `<div class="kacheln liqui-kacheln">
${kachel("Kontostand", euro(startsaldo), einst.startsaldoDatum ? `eingetragen am ${dat(einst.startsaldoDatum)} · <a href="#daten">ändern</a>` : '<a href="#daten">unter Daten eintragen</a>')}
${kachel("Tiefster Stand", tief ? euro(tief.kontostand) : "–", tief ? esc(zeitraum(tief)) : "", (tief?.kontostand ?? 0) < 0)}
${kachel("Einnahmen / Ausgaben", `<span class="ein">${euro(summeEin)}</span><br>${euro(summeAus)}`, `im angezeigten Zeitraum, Saldo ${euro(summeEin + summeAus)}`)}
${kachel(`Stand am ${ende ? dat(ende.bis) : ""}`, ende ? euro(ende.kontostand) : "–", "Ende des angezeigten Zeitraums", (ende?.kontostand ?? 0) < 0)}
</div>`);
// Verlauf: Kontostand je Zeitraum als Säulen, unter null rot
if (perioden.length) {
const werte = perioden.map((p) => p.kontostand as number);
const hoch = Math.max(0, ...werte), tiefst = Math.min(0, ...werte), spanne = hoch - tiefst || 1;
const nullAb = (hoch / spanne) * 100;
const jede = Math.ceil(perioden.length / 13);
inhalt.insertAdjacentHTML("beforeend", `<section class="karte liqui-verlauf"><h2>Kontostand am Ende ${ansicht === "woche" ? "der Woche" : "des Monats"}</h2>
<div class="saeulen" style="--null:${nullAb}%">${perioden.map((p, i) => {
const v = p.kontostand as number, h = (Math.abs(v) / spanne) * 100;
return `<div class="saeule" title="${esc(zeitraum(p))}: ${euro(v)}"><div class="flaeche"><i class="${v < 0 ? "minus" : "plus"}" style="height:${h}%"></i></div>
<small>${i % jede === 0 ? (ansicht === "woche" ? `KW ${kalenderwoche(p.von)}` : MONATSNAMEN[Number(p.von.slice(5, 7)) - 1]!.slice(0, 3)) : ""}</small></div>`;
}).join("")}</div></section>`);
}
// Tabelle: je Zeitraum eine Zeile, aufgeklappt jede Zahlung mit Datum
const heuteD = heute();
const zeile = (x: Zeile) => {
const projekt = x.projekt ? `${esc(x.projekt)}${projektName.get(x.projekt) ? ` ${esc(projektName.get(x.projekt))}` : ""}` : "";
return `<tr class="posten${x.datum < heuteD ? " vorbei" : ""}"><td>${dat(x.datum)}</td><td>${esc(x.bezeichnung)}<span class="unter">${esc(x.gruppe)}</span></td>
<td class="optional">${projekt}</td><td class="zahl ${x.betrag < 0 ? "aus" : "ein"}">${euro(x.betrag)}</td></tr>`;
};
const tab = document.createElement("table");
tab.className = "liqui-tabelle";
tab.innerHTML = `<thead><tr><th>${ansicht === "woche" ? "Woche" : "Monat"}</th><th class="zahl">Einnahmen</th><th class="zahl">Ausgaben</th><th class="zahl optional">Saldo</th><th class="zahl">Kontostand</th></tr></thead>
${perioden.map((p) => {
const offen = liquiOffen.has(p.von);
const posten = [...p.posten].sort((x: Zeile, y: Zeile) => (x.datum < y.datum ? -1 : x.datum > y.datum ? 1 : x.betrag - y.betrag));
return `<tbody><tr class="klickbar periode${offen ? " offen" : ""}" data-von="${p.von}"><td><span class="pfeil">${offen ? "▾" : "▸"}</span> ${esc(zeitraum(p))} <small class="hinweis">${posten.length} ${posten.length === 1 ? "Zahlung" : "Zahlungen"}</small></td>
<td class="zahl ein">${p.einnahmen ? euro(p.einnahmen) : "–"}</td><td class="zahl aus">${p.ausgaben ? euro(p.ausgaben) : "–"}</td><td class="zahl optional">${euro(p.saldo)}</td>
<td class="zahl"><b class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</b></td></tr>
${offen ? `<tr class="details"><td colspan="5">${posten.length ? `<table class="posten-tabelle"><thead><tr><th>Fällig am</th><th>Was</th><th class="optional">Projekt</th><th class="zahl">Betrag</th></tr></thead><tbody>${posten.map(zeile).join("")}</tbody></table>` : '<p class="hinweis">Keine Zahlungen in diesem Zeitraum.</p>'}</td></tr>` : ""}</tbody>`;
}).join("")}`;
tab.addEventListener("click", (ev) => {
const tr = (ev.target as HTMLElement).closest<HTMLElement>("tr.periode");
if (!tr) return;
const von = tr.dataset.von!;
liquiOffen.has(von) ? liquiOffen.delete(von) : liquiOffen.add(von);
liquiditaetSeite(ansicht, anzahl);
});
const alleOffen = perioden.every((p) => liquiOffen.has(p.von));
const alleKnopf = leiste.querySelector<HTMLButtonElement>("#l-alle")!;
alleKnopf.textContent = alleOffen ? "Alle zuklappen" : "Alle Zahlungen aufklappen";
alleKnopf.onclick = () => { liquiOffen = alleOffen ? new Set() : new Set(perioden.map((p) => p.von)); liquiditaetSeite(ansicht, anzahl); };
inhalt.append(tab);
}
const RHYTHMEN: [string, string][] = [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"], ["jaehrlich", "jährlich"], ["einmalig", "einmalig"]];
const LK_FELDER: Feld[] = [
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "kategorie", titel: "Kategorie" },
{ name: "betrag", titel: "Betrag", art: "euro", pflicht: true }, { name: "rhythmus", titel: "Rhythmus", art: "auswahl", optionen: RHYTHMEN },
{ name: "start", titel: "Erste Zahlung", art: "datum", pflicht: true }, { name: "ende", titel: "Endet am", art: "datum" },
];
async function laufendeKosten(): Promise<void> {
const neu = async () => (await bearbeiten("laufende-kosten", "Neue laufende Kosten", LK_FELDER, null, { start: heute(), rhythmus: "monatlich" })) && laufendeKosten();
seite("Laufende Kosten", { text: "Neue Position", aktion: neu });
const zeilen = await api<Zeile[]>("laufende-kosten");
const r = Object.fromEntries(RHYTHMEN);
inhalt.appendChild(tabelle([
{ titel: "Kategorie", wert: (z) => esc(z.kategorie) }, { titel: "Bezeichnung", wert: (z) => esc(z.bezeichnung) },
{ titel: "Rhythmus", wert: (z) => esc(r[z.rhythmus]) }, { titel: "Ab", wert: (z) => dat(z.start), klasse: "optional" },
{ titel: "Betrag", wert: (z) => euro(z.betrag), klasse: "zahl" },
], zeilen, async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && laufendeKosten()));
const monat = zeilen.filter((z) => z.rhythmus === "monatlich" && (!z.ende || z.ende >= heute())).reduce((s, z) => s + z.betrag, 0);
inhalt.insertAdjacentHTML("beforeend", `<p>Monatlich: <strong>${euro(monat)}</strong></p>`);
}
// G4: Kategorien für Aufgaben, im Auswahlmenü über „Kategorien bearbeiten …“ pflegbar
const KATEGORIEN_BEARBEITEN = { text: "Kategorien bearbeiten …", aktion: kategorienBearbeiten };
const kategorieOptionen = (liste: Zeile[], leer = "–"): [string, string][] => [["", leer], ...liste.map((k): [string, string] => [k.id, k.name])];
/** Kleiner Editor über allem anderen; liefert danach die Optionen für ein Auswahlfeld. */
function kategorienBearbeiten(): Promise<[string, string][]> {
return new Promise((fertig) => {
const warSichtbar = !huelle.hidden;
huelle.hidden = false;
const box = document.createElement("div");
box.className = "dialog kategorien";
box.style.position = "fixed";
huelle.appendChild(box);
let liste: Zeile[] = [];
const zeichne = async (fehler = "") => {
liste = await api<Zeile[]>("aufgaben-kategorien");
box.innerHTML = `<h2>Kategorien</h2>
<ul>${liste.map((k) => `<li><input id="kat-${k.id}" data-id="${k.id}" value="${esc(k.name)}" aria-label="Kategorie"><button type="button" class="neben" data-weg="${k.id}" title="Löschen">✕</button></li>`).join("")}</ul>
${liste.length ? "" : '<p class="hinweis">Noch keine Kategorien.</p>'}
<form class="neu"><input id="kat-neu" placeholder="Neue Kategorie" aria-label="Neue Kategorie"><button class="neben">Hinzufügen</button></form>
<p class="fehler">${esc(fehler)}</p>
<p class="hinweis">Gelöschte Kategorien verschwinden aus den Aufgaben, die Aufgaben bleiben.</p>
<div class="knoepfe"><button type="button" class="haupt" data-a="fertig">Fertig</button></div>`;
(box.querySelector("#kat-neu") as HTMLInputElement).focus();
};
const versuche = async (fn: () => Promise<unknown>) => {
try { await fn(); await zeichne(); } catch (e) { await zeichne((e as Error).message); }
};
box.addEventListener("submit", (ev) => {
ev.preventDefault();
const name = (box.querySelector("#kat-neu") as HTMLInputElement).value.trim();
if (name) versuche(() => api("aufgaben-kategorien", "POST", { name }));
});
box.addEventListener("change", (ev) => {
const feld = ev.target as HTMLInputElement;
const k = liste.find((x) => x.id === feld.dataset.id);
if (k && feld.value.trim() && feld.value.trim() !== k.name) versuche(() => api(`aufgaben-kategorien/${k.id}`, "PATCH", { name: feld.value.trim() }));
});
box.addEventListener("click", async (ev) => {
const b = ev.target as HTMLElement;
if (b.dataset.weg) versuche(() => api(`aufgaben-kategorien/${b.dataset.weg}`, "DELETE"));
if (b.dataset.a === "fertig") {
box.remove();
huelle.hidden = !warSichtbar;
fertig(kategorieOptionen(await api<Zeile[]>("aufgaben-kategorien")));
}
});
zeichne();
});
}
interface AufgabenNamen { projekt: Record<string, string>; kontakt: Record<string, string>; kategorie: Record<string, string> }
/** Felder für eine Aufgabe und die Namen für die Anzeige, jeweils frisch geladen */
async function aufgabenDaten(): Promise<{ felder: Feld[]; namen: AufgabenNamen; kategorien: Zeile[]; projekte: Zeile[] }> {
const [kategorien, projekte, kontakte] = await Promise.all([api<Zeile[]>("aufgaben-kategorien"), api<Zeile[]>("projekte"), api<Zeile[]>("kontakte")]);
// Kunden (Bauherren) zuerst, dann alle anderen Kontakte
const sortiert = [...kontakte].sort((a, b) => Number(b.rolle === "bauherr") - Number(a.rolle === "bauherr") || a.name.localeCompare(b.name, "de"));
return {
felder: [
{ name: "text", titel: "Aufgabe", pflicht: true }, { name: "faellig_am", titel: "Fällig am", art: "datum" },
{ name: "kategorie_id", titel: "Kategorie", art: "auswahl", optionen: kategorieOptionen(kategorien), bearbeiten: KATEGORIEN_BEARBEITEN },
{ name: "projekt_id", titel: "Projekt", art: "auswahl", optionen: [["", "–"], ...projekte.map((p): [string, string] => [p.id, `${p.nummer} ${p.bezeichnung}`])] },
{ name: "kontakt_id", titel: "Kunde / Kontakt", art: "auswahl", optionen: [["", "–"], ...sortiert.map((k): [string, string] => [k.id, k.firma ? `${k.name} (${k.firma})` : k.name])] },
],
namen: {
projekt: Object.fromEntries(projekte.map((p) => [p.id, `${p.nummer} ${p.bezeichnung}`])),
kontakt: Object.fromEntries(kontakte.map((k) => [k.id, k.name])),
kategorie: Object.fromEntries(kategorien.map((k) => [k.id, k.name])),
},
kategorien,
projekte,
};
}
async function neueAufgabe(vorgaben: Zeile = {}): Promise<boolean> {
return bearbeiten("aufgaben", "Neue Aufgabe", (await aufgabenDaten()).felder, null, vorgaben);
}
function aufgabenTabelle(zeilen: Zeile[], namen: AufgabenNamen, felder: Feld[], neuLaden: () => void, ohneProjekt = false): HTMLTableElement {
const zuordnung = (z: Zeile) => [ohneProjekt ? "" : namen.projekt[z.projekt_id], namen.kontakt[z.kontakt_id]].filter(Boolean).map(esc).join(" · ");
const t = tabelle([
{ titel: "", wert: (z) => `<input type="checkbox" data-id="${z.id}" aria-label="Erledigt"${z.erledigt_am ? " checked" : ""}>` },
{ titel: "Aufgabe", wert: (z) => `${z.erledigt_am ? `<s>${esc(z.text)}</s>` : esc(z.text)}${zuordnung(z) ? `<span class="unter">${zuordnung(z)}</span>` : ""}` },
{ titel: "Kategorie", wert: (z) => (z.kategorie_id ? `<span class="kategorie">${esc(namen.kategorie[z.kategorie_id])}</span>` : "") },
{ titel: "Fällig", wert: (z) => `<span class="${!z.erledigt_am && z.faellig_am && z.faellig_am < heute() ? "fehler" : ""}">${dat(z.faellig_am)}</span>` },
], zeilen, async (z) => (await bearbeiten("aufgaben", "Aufgabe bearbeiten", felder, z)) && neuLaden());
t.classList.add("aufgaben-tabelle");
t.addEventListener("click", async (ev) => {
const box = ev.target as HTMLInputElement;
if (box.type !== "checkbox") return;
ev.stopPropagation();
await api(`aufgaben/${box.dataset.id}`, "PATCH", { erledigt_am: box.checked ? new Date().toISOString() : null });
neuLaden();
}, true);
return t;
}
// Filter der Aufgabenliste bleiben beim Wechsel zwischen den Reitern erhalten
const aufgabenFilter = { kategorie: "", projekt: "", erledigte: false };
async function aufgaben(): Promise<void> {
const leiste = seite("Aufgaben", { text: "Neue Aufgabe", aktion: async () => (await neueAufgabe()) && aufgaben() });
const [d, alle] = await Promise.all([aufgabenDaten(), api<Zeile[]>("aufgaben")]);
const f = aufgabenFilter;
if (f.kategorie && f.kategorie !== "ohne" && !d.namen.kategorie[f.kategorie]) f.kategorie = "";
leiste.innerHTML = `<select id="a-kategorie" aria-label="Kategorie">${optionenHtml([["", "Alle Kategorien"], ["ohne", "Ohne Kategorie"], ...kategorieOptionen(d.kategorien).slice(1)], f.kategorie, KATEGORIEN_BEARBEITEN)}</select>
<select id="a-projekt" aria-label="Projekt">${optionenHtml([["", "Alle Projekte"], ["ohne", "Ohne Projekt"], ...d.projekte.map((p): [string, string] => [p.id, `${p.nummer} ${p.bezeichnung}`])], f.projekt)}</select>
<label class="schalter"><input type="checkbox" id="a-erledigte"${f.erledigte ? " checked" : ""}> Erledigte zeigen</label>`;
const kat = leiste.querySelector("#a-kategorie") as HTMLSelectElement;
bearbeitbareAuswahl(kat, KATEGORIEN_BEARBEITEN, () => { f.kategorie = kat.value; aufgaben(); });
(leiste.querySelector("#a-projekt") as HTMLSelectElement).onchange = (ev) => { f.projekt = (ev.target as HTMLSelectElement).value; aufgaben(); };
(leiste.querySelector("#a-erledigte") as HTMLInputElement).onchange = (ev) => { f.erledigte = (ev.target as HTMLInputElement).checked; aufgaben(); };
const passt = (wert: string | null, filter: string) => !filter || (filter === "ohne" ? !wert : wert === filter);
const zeilen = alle.filter((a) => (f.erledigte || !a.erledigt_am) && passt(a.kategorie_id, f.kategorie) && passt(a.projekt_id, f.projekt));
inhalt.appendChild(aufgabenTabelle(zeilen, d.namen, d.felder, aufgaben));
inhalt.insertAdjacentHTML("beforeend", `<p class="anzahl">${zeilen.length} von ${alle.length} Aufgaben</p>`);
}
const WOCHENTAG = ["", "Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"];
const WOCHENTAG_LANG = ["", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"];
const wtag = (d: string) => new Date(`${d}T00:00:00Z`).getUTCDay() || 7;
// Startseite in der Reihenfolge, die Henning festgelegt hat: Aufgaben und Warnungen gleichrangig
// nebeneinander, darunter wer was wann wo macht, dann die Liquidität
async function uebersicht(): Promise<void> {
const u = await api<Zeile>(`uebersicht?heute=${heute()}`);
seite("Übersicht");
inhalt.querySelector(".kopf h1")!.insertAdjacentHTML("beforeend", ` <small class="datum">${WOCHENTAG_LANG[wtag(u.heute)]}, ${dat(u.heute)}</small>`);
const aufgabeLi = (a: Zeile) => `<li><label><input type="checkbox" data-erledigt="${a.id}"> <span>${esc(a.text)}</span></label>
<small>${a.faellig_am ? `${WOCHENTAG[wtag(a.faellig_am)]} ${dat(a.faellig_am).slice(0, 6)}` : "ohne Datum"}${a.projekt_nummer ? ` · ${esc(a.projekt_nummer)}` : ""}${a.kontakt_name ? ` · ${esc(a.kontakt_name)}` : ""}</small>${a.kategorie ? `<span class="kategorie">${esc(a.kategorie)}</span>` : ""}</li>`;
const gruppe = (titel: string, liste: Zeile[], leer: string, warn = false) => `<div class="gruppe${warn && liste.length ? " warn" : ""}">
<h3>${titel} <b>${liste.length}</b></h3>${liste.length ? `<ul class="aufgaben">${liste.map(aufgabeLi).join("")}</ul>` : `<p class="hinweis">${leer}</p>`}</div>`;
const SYMBOL: Record<string, string> = { ueberschneidung: "⚠", unbesetzt: "👤", freigabe: "✋", aufgabe: "⏰", kontostand: "€" };
const raster = document.createElement("div");
raster.className = "start";
raster.innerHTML = `
<section class="karte"><div class="karte-kopf"><h2>Aufgaben</h2><button class="neben" data-a="neue-aufgabe">+ Aufgabe</button></div>
${gruppe("Noch nicht abgearbeitet", u.aufgaben.ueberfaellig, "Nichts liegen geblieben.", true)}
${gruppe(`Diese Woche`, u.aufgaben.dieseWoche, "Keine Aufgaben mehr in dieser Woche.")}
${gruppe("Langfristig", u.aufgaben.langfristig, "Keine langfristigen Aufgaben.")}</section>
<section class="karte"><div class="karte-kopf"><h2>Warnungen</h2></div>
${u.warnungen.length ? `<ul class="warnungen">${u.warnungen.map((w: Zeile) => `<li class="${w.art}"><a href="#${w.ziel}"><span class="symbol">${SYMBOL[w.art] ?? "!"}</span>${esc(w.text)}</a></li>`).join("")}</ul>`
: '<p class="hinweis">Alles im grünen Bereich.</p>'}</section>
<section class="karte breit"><div class="karte-kopf"><h2>Wer macht was</h2><a class="neben" href="#terminplan">Terminplan</a></div>${einsatzHtml(u.einsatz)}</section>
<section class="karte breit"><div class="karte-kopf"><h2>Liquidität 4 Wochen</h2><a class="neben" href="#liquiditaet">Details</a></div>
<div class="liqui">${u.liquiditaet.map((p: Zeile) => `<div><small>ab ${dat(p.von).slice(0, 6)}</small><b class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</b><small>Saldo ${euro(p.saldo)}</small></div>`).join("")}</div></section>`;
inhalt.appendChild(raster);
raster.addEventListener("change", async (ev) => {
const box = ev.target as HTMLInputElement;
if (!box.dataset.erledigt) return;
await api(`aufgaben/${box.dataset.erledigt}`, "PATCH", { erledigt_am: box.checked ? new Date().toISOString() : null });
uebersicht();
});
raster.querySelector<HTMLElement>('[data-a="neue-aufgabe"]')!.onclick = async () => {
if (await neueAufgabe()) uebersicht();
};
}
function einsatzHtml(e: Zeile): string {
if (!e.zeilen.length && e.ohne.tage.every((t: Zeile[]) => !t.length)) return '<p class="hinweis">In den nächsten zwei Wochen ist nichts eingeplant.</p>';
const zeilen = [...e.zeilen, ...(e.ohne.tage.some((t: Zeile[]) => t.length) ? [e.ohne] : [])];
const kopf = e.tage.map((d: string, i: number) => `<th class="${i > 0 && wtag(d) < wtag(e.tage[i - 1]) ? "neue-woche" : ""}">${WOCHENTAG[wtag(d)]} ${dat(d).slice(0, 6)}</th>`).join("");
const zelle = (eintraege: Zeile[], d: string, i: number) => `<td class="${i > 0 && wtag(d) < wtag(e.tage[i - 1]) ? "neue-woche" : ""}">${eintraege.map((x) =>
`<span class="einsatz${x.vorgemerkt ? " vorgemerkt" : ""}" title="${esc(x.projekt)}: ${esc(x.name)}${x.vorgemerkt ? " (vorgemerkt)" : ""}">${esc(x.projekt.split(" ")[0])} ${esc(x.name)}</span>`).join("")}</td>`;
const tabelle = `<div class="einsatz-tabelle"><table><thead><tr><th>Wer</th>${kopf}</tr></thead><tbody>${zeilen.map((z: Zeile) =>
`<tr class="${z.wer ? "" : "ohne"}"><th>${esc(z.anzeige)}</th>${z.tage.map((t: Zeile[], i: number) => zelle(t, e.tage[i], i)).join("")}</tr>`).join("")}</tbody></table></div>`;
// am Handy: je Tag eine Liste
const liste = `<div class="einsatz-liste">${e.tage.map((d: string, i: number) => {
const eintraege = zeilen.flatMap((z: Zeile) => z.tage[i].map((x: Zeile) => ({ ...x, wer: z.anzeige })));
return eintraege.length ? `<h3>${WOCHENTAG_LANG[wtag(d)]}, ${dat(d)}</h3><ul>${eintraege.map((x: Zeile) =>
`<li><b>${esc(x.wer)}</b> ${esc(x.projekt)} · ${esc(x.name)}${x.vorgemerkt ? " <i>(vorgemerkt)</i>" : ""}</li>`).join("")}</ul>` : "";
}).join("")}</div>`;
return tabelle + liste;
}
// T11: Kalender-Abos für Outlook classic (nur lesen, Outlook holt Änderungen selbst ab)
function kalenderLinks(token: string | null): void {
const ziel = document.getElementById("kalender")!;
const neu = async () => {
if (token && !(await bestaetigen("Neue Links erzeugen? Die bisherigen Abos in Outlook funktionieren dann nicht mehr."))) return;
kalenderLinks((await api<{ kalenderToken: string }>("kalender/neu", "POST")).kalenderToken);
};
if (!token) {
ziel.innerHTML = `<p class="hinweis">Die Vorgänge aus dem Terminplan und fällige Aufgaben lassen sich als Internetkalender in Outlook einbinden.</p>
<p><button class="haupt">Kalender-Links erzeugen</button></p>`;
ziel.querySelector("button")!.onclick = neu;
return;
}
const link = (name: string) => `${location.origin}/kalender/${token}/${name}`;
ziel.innerHTML = `${[["Baustellen", "baustellen.ics"], ["Aufgaben", "aufgaben.ics"]].map(([titel, datei]) =>
`<div class="kalender-link"><b>${titel}</b><input readonly value="${esc(link(datei!))}"><button class="neben" data-kopie="${esc(link(datei!))}">Kopieren</button></div>`).join("")}
<p class="hinweis">In Outlook: Datei → Kontoeinstellungen → Kontoeinstellungen → Internetkalender → Neu, Link einfügen, Name „Baustellen“ bzw. „Aufgaben“.
Outlook holt Änderungen etwa stündlich ab. Wer den Link hat, kann die Termine lesen; gib ihn deshalb nicht weiter.</p>
<p><button class="neben" data-a="neu">Neue Links erzeugen</button></p>`;
ziel.onclick = async (ev) => {
const b = ev.target as HTMLElement;
if (b.dataset.kopie) {
try { await navigator.clipboard.writeText(b.dataset.kopie); b.textContent = "Kopiert"; } catch { (b.previousElementSibling as HTMLInputElement).select(); }
}
if (b.dataset.a === "neu") neu();
};
}
/** Testversion im Browser (demo/): speichert anders und kennt keine Kalender-Abos */
const testversion = (globalThis as { betriebTestversion?: { sichern(): Promise<string> } }).betriebTestversion;
async function daten(): Promise<void> {
seite("Daten und Einstellungen");
const e = await api<Zeile>("einstellungen");
inhalt.insertAdjacentHTML("beforeend", `
${testversion
? `<p><button class="neben" id="sichern">Kompletten Stand als Datei sichern</button> <span id="sichern-ergebnis"></span></p>
<p class="hinweis">Testversion: Deine Eingaben werden mit diesem Link gespeichert. Mit der Sicherungsdatei ziehen sie später auf den Server um.</p>`
: `<p><a class="neben" href="/api/export" download>Kompletten Stand als JSON sichern</a></p>
<p class="hinweis">Die Datenbank wird jede Nacht gesichert und in die Nextcloud kopiert.</p>`}
<h2>Sicherung einspielen</h2>
<p class="hinweis">Sicherungsdatei aus diesem Programm wählen (betrieb-….json), zum Beispiel aus der Testversion. Geht nur, solange noch nichts erfasst ist.</p>
<p><input type="file" id="stand-datei" accept=".json,application/json"></p>
<div id="stand-ergebnis"></div>
<h2>Übernahme aus dem Projektplaner V70</h2>
<p class="hinweis">Sicherungsdatei aus V70 wählen (projektplaner-sicherung-….json). Geht nur, solange noch nichts erfasst ist.</p>
<p><input type="file" id="v70-datei" accept=".json,application/json"></p>
<div id="v70-ergebnis"></div>
<h2>Kalender in Outlook</h2>
<div id="kalender"></div>
<h2>Einstellungen</h2>`);
if (testversion) {
document.getElementById("kalender")!.innerHTML = `<p class="hinweis">Die Kalender-Abos für Outlook funktionieren erst auf dem Server.</p>`;
const knopf = document.getElementById("sichern")!, ergebnis = document.getElementById("sichern-ergebnis")!;
knopf.onclick = async () => {
try { ergebnis.textContent = await testversion.sichern(); } catch (err) { ergebnis.textContent = (err as Error).message; }
};
} else kalenderLinks(e.kalenderToken);
const stand = document.getElementById("stand-datei") as HTMLInputElement;
stand.onchange = async () => {
const f = stand.files?.[0];
const ziel = document.getElementById("stand-ergebnis")!;
if (!f) return;
try {
const r = await api<{ anzahl: Record<string, number> }>("import/stand", "POST", JSON.parse(await f.text()));
ziel.innerHTML = `<p>Eingespielt: ${r.anzahl.projekte} Projekte, ${r.anzahl.vorgaenge} Vorgänge, ${r.anzahl.aufgaben} Aufgaben, ${r.anzahl.kontakte} Kontakte.</p>`;
} catch (e) {
ziel.innerHTML = `<p class="fehler">${esc((e as Error).message)}</p>`;
}
stand.value = "";
};
const datei = document.getElementById("v70-datei") as HTMLInputElement;
datei.onchange = async () => {
const f = datei.files?.[0];
const ziel = document.getElementById("v70-ergebnis")!;
if (!f) return;
try {
const r = await api<{ anzahl: Record<string, number>; hinweise: string[] }>("import/v70", "POST", JSON.parse(await f.text()));
ziel.innerHTML = `<p>Übernommen: ${r.anzahl.projekte} Projekte, ${r.anzahl.vorgaenge} Vorgänge, ${r.anzahl.zahlungen} Abschläge, ${r.anzahl.kosten} Kosten, ${r.anzahl.laufendeKosten} laufende Kosten, ${r.anzahl.kontakte} Kontakte.</p>`
+ (r.hinweise.length ? `<p>Bitte prüfen:</p><ul>${r.hinweise.map((h) => `<li>${esc(h)}</li>`).join("")}</ul>` : "");
} catch (e) {
ziel.innerHTML = `<p class="fehler">${esc((e as Error).message)}</p>`;
}
datei.value = "";
};
const felder: Feld[] = [
{ name: "startsaldo", titel: "Kontostand (Startsaldo)", art: "euro" },
{ name: "kundenTage", titel: "Zahlungsziel Kunden (Tage)", art: "zahl" },
{ name: "materialTage", titel: "Zahlungsziel Material (Tage)", art: "zahl" },
{ name: "fremdTage", titel: "Zahlungsziel Subunternehmer (Tage)", art: "zahl" },
{ name: "versteuerung", titel: "Umsatzsteuer nach", art: "auswahl", optionen: [["soll", "Soll (vereinbarte Entgelte)"], ["ist", "Ist (vereinnahmte Entgelte)"]] },
{ name: "voranmeldung", titel: "Voranmeldung", art: "auswahl", optionen: [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"]] },
{ name: "stundenProTag", titel: "Stunden pro Arbeitstag", art: "zahl" },
];
const knopf = document.createElement("button");
knopf.className = "neben";
knopf.textContent = "Einstellungen bearbeiten";
knopf.onclick = async () => {
const r = await dialog("Einstellungen", felder, { ...e, ...e.zahlungsziele, ...e.ust }, false);
if (r?.aktion !== "speichern") return;
const d = r.daten;
await api("einstellungen", "PUT", {
...e, startsaldo: d.startsaldo ?? 0, stundenProTag: d.stundenProTag ?? e.stundenProTag,
// Datum merken, damit die Startseite weiß, dass der Kontostand eingetragen ist
startsaldoDatum: (d.startsaldo ?? 0) !== e.startsaldo ? heute() : e.startsaldoDatum,
zahlungsziele: { ...e.zahlungsziele, kundenTage: d.kundenTage ?? 0, materialTage: d.materialTage ?? 0, fremdTage: d.fremdTage ?? 0 },
ust: { ...e.ust, versteuerung: d.versteuerung, voranmeldung: d.voranmeldung },
});
daten();
};
inhalt.appendChild(knopf);
}
// 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> = {
uebersicht: '<path d="M3 11l9-7 9 7"/><path d="M5 10v10h14V10"/>',
aufgaben: '<path d="M9 11l3 3 8-8"/><path d="M20 12v7a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h11"/>',
projekte: '<path d="M3 6a1 1 0 0 1 1-1h5l2 2h9a1 1 0 0 1 1 1v10a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1z"/>',
terminplan: '<rect x="3" y="5" width="18" height="16" rx="1"/><path d="M3 10h18M8 3v4M16 3v4"/>',
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")!;
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) || 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 (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("unhandledrejection", (ev) => {
inhalt.insertAdjacentHTML("afterbegin", `<p class="fehler">${esc(ev.reason?.message ?? ev.reason)}</p>`);
});
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(() => {});