Files
Betriebsf-hrungssoftware/src/web/app.ts

447 lines
26 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 Stufe 0. Die Reiter folgen V70; Terminplan und Projektdetails
// kommen mit der Übernahme der V70-Oberfläche.
import { formatEuro, parseEuro } from "../domain/geld.js";
import { formatDatum } from "../domain/datum.js";
import { terminplanSeite } from "./gantt.js";
type Zeile = Record<string, any>;
// ---------- Hilfen ----------
function esc(v: unknown): string {
return String(v ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]!);
}
async function api<T = any>(pfad: string, methode = "GET", body?: unknown): Promise<T> {
const r = await fetch(`/api/${pfad}`, {
method: methode,
headers: body === undefined ? {} : { "content-type": "application/json" },
body: body === undefined ? undefined : JSON.stringify(body),
});
if (r.status === 204) return undefined as T;
const j = await r.json().catch(() => ({}));
if (!r.ok) throw new Error([j.fehler ?? `Fehler ${r.status}`, ...(j.details ?? [])].join("\n"));
return j as T;
}
const inhalt = document.getElementById("inhalt")!;
const huelle = document.getElementById("dialog-huelle")!;
const heute = () => new Date().toISOString().slice(0, 10);
const euro = (c: number | null | undefined) => (c == null ? "" : formatEuro(c));
const dat = (d: string | null | undefined) => (d ? formatDatum(d) : "");
// ---------- Eigene Dialoge (keine Browser-Abfragen) ----------
interface Feld {
name: string;
titel: string;
art?: "text" | "euro" | "datum" | "auswahl" | "zahl" | "langtext";
optionen?: [string, string][];
pflicht?: boolean;
}
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}">${f.optionen!.map(([w, t]) => `<option value="${esc(w)}"${w === (v ?? "") ? " selected" : ""}>${esc(t)}</option>`).join("")}</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();
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;
if (e.aktion === "loeschen") await api(`${pfad}/${zeile!.id}`, "DELETE");
else if (zeile) await api(`${pfad}/${zeile.id}`, "PATCH", e.daten);
else await api(pfad, "POST", { ...vorgaben, ...e.daten });
return true;
}
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>`;
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 ----------
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>`;
async function projekte(): Promise<void> {
const kontaktListe = await api<Zeile[]>("kontakte");
const felder: Feld[] = [
{ name: "nummer", titel: "Nummer", pflicht: true }, { name: "bezeichnung", titel: "Baustelle", pflicht: true },
{ name: "status", titel: "Status", art: "auswahl", optionen: STATUS },
{ name: "bauherr_id", titel: "Bauherr", art: "auswahl", optionen: [["", "–"], ...kontaktListe.map((k): [string, string] => [k.id, k.name])] },
{ 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" },
];
const ohneNull = (z: Zeile | null) => z && { ...z, ...Object.fromEntries(["umsatz_netto", "material_kosten", "fremd_kosten", "sonstige_kosten"].map((k) => [k, z[k] ?? 0])) };
const speichern = async (z: Zeile | null) => {
if (await bearbeiten("projekte", z ? "Projekt bearbeiten" : "Neues Projekt", felder, z)) projekte();
};
seite("Projekte", { text: "Neues Projekt", aktion: () => speichern(null) });
const zeilen = await api<Zeile[]>("projekte");
const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name]));
const kostenSumme = (z: Zeile) => z.material_kosten + z.fremd_kosten + z.sonstige_kosten;
inhalt.appendChild(tabelle([
{ titel: "Name", wert: (z) => `<strong>${esc(z.bezeichnung)}</strong><span class="unter"><span class="nur-schmal">${esc(z.nummer)} · </span>${esc(name[z.bauherr_id] ?? "–")}</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) => speichern(ohneNull(z))));
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>
<p class="hinweis">Projektdetailseite, Einzelposten und Zahlungsplan folgen mit der V70-Übernahme.</p>`);
}
async function terminplan(): Promise<void> {
await terminplanSeite({ api, dialog, esc, seite: (t) => seite(t), inhalt });
}
async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {
const leiste = seite("Liquidität");
leiste.innerHTML = `<select id="l-ansicht"><option value="woche">Wochen</option><option value="monat">Monate</option></select>
<select id="l-anzahl">${[4, 8, 12, 26, 52].map((n) => `<option>${n}</option>`).join("")}</select>`;
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 = await api<Zeile[]>(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`);
inhalt.appendChild(tabelle([
{ titel: ansicht === "woche" ? "Woche ab" : "Monat", wert: (p) => (ansicht === "woche" ? dat(p.von) : esc(p.von.slice(5, 7) + "/" + p.von.slice(0, 4))) },
{ titel: "Einnahmen", wert: (p) => euro(p.einnahmen), klasse: "zahl" },
{ titel: "Ausgaben", wert: (p) => euro(p.ausgaben), klasse: "zahl" },
{ titel: "Saldo", wert: (p) => euro(p.saldo), klasse: "zahl optional" },
{ titel: "Kontostand", wert: (p) => `<span class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</span>`, klasse: "zahl" },
], perioden, (p) => {
const text = p.posten.map((x: Zeile) => `${dat(x.datum)} ${x.gruppe} ${x.projekt ?? ""} ${x.bezeichnung}: ${formatEuro(x.betrag)}`).join("\n") || "Keine Bewegungen";
dialog(`${dat(p.von)} bis ${dat(p.bis)}`, [{ name: "t", titel: "Bewegungen", art: "langtext" }], { t: text }, false);
}));
}
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>`);
}
const AUFGABE_FELDER: Feld[] = [
{ name: "text", titel: "Aufgabe", pflicht: true }, { name: "faellig_am", titel: "Fällig am", art: "datum" },
];
function aufgabenTabelle(zeilen: Zeile[], neuLaden: () => void): HTMLTableElement {
const t = tabelle([
{ titel: "", wert: (z) => `<input type="checkbox" data-id="${z.id}"${z.erledigt_am ? " checked" : ""}>` },
{ titel: "Aufgabe", wert: (z) => (z.erledigt_am ? `<s>${esc(z.text)}</s>` : esc(z.text)) },
{ 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", AUFGABE_FELDER, z)) && neuLaden());
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;
}
async function aufgaben(): Promise<void> {
const neu = async () => (await bearbeiten("aufgaben", "Neue Aufgabe", AUFGABE_FELDER, null)) && aufgaben();
seite("Aufgaben", { text: "Neue Aufgabe", aktion: neu });
inhalt.appendChild(aufgabenTabelle(await api<Zeile[]>("aufgaben"), aufgaben));
}
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)}` : ""}</small></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 bearbeiten("aufgaben", "Neue Aufgabe", AUFGABE_FELDER, null)) 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;
}
async function daten(): Promise<void> {
seite("Daten und Einstellungen");
const e = await api<Zeile>("einstellungen");
inhalt.insertAdjacentHTML("beforeend", `
<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>Ü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>Einstellungen</h2>`);
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); 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],
];
// 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"/>',
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("");
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";
const reiter = REITER.find(([r]) => r === id) ?? REITER[0]!;
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0]));
try {
await 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();
api("status").then((s) => (document.getElementById("version")!.textContent = `Version ${s.version}`)).catch(() => {});