Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
447 lines
26 KiB
TypeScript
447 lines
26 KiB
TypeScript
// 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) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" })[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(() => {});
|