// Liquidität (Henning, 21.10.2026, Entwurf liquiditaet/entwurf): drei Reiter. „Lage“ zeigt frei verfügbar heute, Ampel // und einen Satz, wann es am knappsten wird, die Kurve je Woche und was reinkommt und rausgeht. „Monatsplan“ ist die // Tabelle je Monat (oder Woche) zum Aufklappen, „Alle Zahlungen“ jede Zahlung als Zeile. Der Zeitraum gilt für alle drei. import { type Zeile, MONATSNAMEN, api, dat, esc, euro, heute, inhalt, lies, merke, seite } from "./ui.js"; import { kalenderwoche } from "./gantt.js"; import { AUGE, AUGE_ZU, ansichtMerken, gespeicherteAnsicht, liste } from "./liste.js"; import { flussJeWoche, lage } from "../domain/lage.js"; import type { Periode } from "../domain/liquiditaet.js"; import { tageZwischen } from "../domain/datum.js"; import { formatEuro, parseEuro } from "../domain/geld.js"; type Reiter = "lage" | "monat" | "alle"; type Zeitraum = "4w" | "6w" | "3m"; const WOCHEN: Record = { "4w": 4, "6w": 6, "3m": 13 }; const MONATE: Record = { "4w": 2, "6w": 2, "3m": 3 }; const ZEIT_TEXT: Record = { "4w": "4 Wochen", "6w": "6 Wochen", "3m": "3 Monaten" }; const ZEIT_KNOPF: Record = { "4w": "4 Wochen", "6w": "6 Wochen", "3m": "3 Monate" }; /** so viele Zeilen je Liste, der Rest hinter „weitere anzeigen“ */ const SICHTBAR = 4; const gespeichert = (schluessel: string, erlaubt: readonly T[], vorgabe: T): T => { const w = lies(schluessel); return erlaubt.includes(w as T) ? (w as T) : vorgabe; }; let reiter: Reiter = gespeichert("liqui-reiter", ["lage", "monat", "alle"] as const, "lage"); let zeitraum: Zeitraum = gespeichert("liqui-zeitraum", ["4w", "6w", "3m"] as const, "3m"); let raster: "monat" | "woche" = "monat"; let liquiOffen = new Set(); let gewaehlt: string | null = null; const mehr = { ein: false, aus: false }; export async function liquiditaetSeite(): Promise { const leiste = seite("Liquidität"); leiste.classList.add("liqui-leiste"); leiste.innerHTML = `
Zeitraum:${(Object.keys(WOCHEN) as Zeitraum[]).map((z) => ``).join("")}
${([["lage", "Lage"], ["monat", "Monatsplan"], ["alle", "Alle Zahlungen"]] as [Reiter, string][]).map(([r, t]) => ``).join("")}
`; leiste.onclick = (ev) => { const b = (ev.target as HTMLElement).closest("[data-zeitraum], [data-reiter]"); if (!b) return; if (b.dataset.zeitraum) { zeitraum = b.dataset.zeitraum as Zeitraum; merke("liqui-zeitraum", zeitraum); gewaehlt = null; } if (b.dataset.reiter) { reiter = b.dataset.reiter as Reiter; merke("liqui-reiter", reiter); } void liquiditaetSeite(); }; if (reiter === "lage") await lageZeigen(); else if (reiter === "monat") await planZeigen(); else await alleZeigen(); } // ---------- Lage ---------- const kw = (d: string) => `KW ${kalenderwoche(d)}`; /** auf der Lage in ganzen Euro wie im Entwurf */ const glatt = (c: number) => formatEuro(Math.sign(c) * Math.round(Math.abs(c) / 100) * 100).replace(",00 €", " €"); const postenText = (p: Zeile, namen?: Map) => `${esc(p.bezeichnung)}${p.projekt ? ` · ${esc(p.projekt)}${namen?.get(p.projekt) ? ` ${esc(namen.get(p.projekt))}` : ""}` : ""}`; const FLUSS_GRUPPEN = new Set(["Projekteinnahmen", "Projektkosten", "Laufende Kosten", "Umsatzsteuer"]); /** Karte oben ohne Kontostand: Summen des Zeitraums und Überschuss */ function flussKopfHtml(wochen: Zeile[]): string { return `
${flussKachelnHtml(flussJeWoche(wochen as Periode[]), ZEIT_KNOPF[zeitraum], true)}

Ohne Kontostand gerechnet: Einnahmen, Projektkosten, laufende Kosten und Umsatzsteuer (monatlich, fällig am 10. des übernächsten Monats).

`; } /** Karte oben: frei verfügbar, Ampel, Satz und Grund. Auch auf der Startseite (Block 3) */ export function lageKopfHtml(d: Zeile, zeitText: string): string { const l = d.lage; const chip = l.ampel === "rot" ? ["rot", "Achtung: Konto im Minus"] : l.ampel === "gelb" ? ["gelb", "Knapp: unter der Mindestgrenze"] : ["gruen", "Alles im grünen Bereich"]; const mg = d.mindestgrenze as number; let satz = "Im Zeitraum ist keine Zahlung geplant."; if (l.tief) { const wann = l.tief.von <= heute() ? `diese Woche (${kw(l.tief.von)})` : kw(l.tief.von); const vergleich = mg > 0 || l.abstand < 0 ? `, also ${glatt(Math.abs(l.abstand))} ${l.abstand >= 0 ? "über" : "unter"} deiner Mindestgrenze von ${glatt(mg)}` : ""; satz = `In den nächsten ${esc(zeitText)} wird es am knappsten ${l.tief.von <= heute() ? "" : "in "}${wann} mit ${glatt(l.tief.kontostand)}${vergleich}.`; } const grund = (l.grund as Zeile[]).length ? `Grund: ${(l.grund as Zeile[]).map((p) => `${postenText(p)} ${glatt(-p.betrag)}`).join(" und ")}${l.danach ? `, bevor ${postenText(l.danach)} kommt` : ""}.` : ""; const stand = d.kontostandDatum ? `Kontostand vom ${dat(d.kontostandDatum)}` : 'Kontostand noch nicht eingetragen'; return `
Frei verfügbar heute${glatt(l.frei)} Kontostand ${glatt(d.kontostand)} − Mindestgrenze ${glatt(mg)} · ${stand}
${chip[1]}

${satz}

${grund ? `

${grund}

` : ""}
`; } /** Liniendiagramm je Woche: Kontostand als Fläche, Einnahmen und Ausgaben je Woche, Mindestgrenze, tiefster Punkt */ // Geldfluss ohne Kontostand (Henning, 23.10.2026): je Woche Einnahmen, Projektkosten, laufende Kosten und auf Wunsch die Umsatzsteuer const FLUSS: [string, string, string][] = [["einnahmen", "fl-ein", "Einnahmen"], ["projektkosten", "fl-pk", "Projektkosten"], ["laufend", "fl-lk", "Laufende Kosten"], ["ust", "fl-ust", "Umsatzsteuer"]]; /** Kacheln mit den Summen des Zeitraums und dem Überschuss */ export function flussKachelnHtml(fluss: Zeile[], zeitText: string, mitUst: boolean): string { const s = (k: string) => fluss.reduce((x, w) => x + Number(w[k] ?? 0), 0); const ueber = s("einnahmen") - s("projektkosten") - s("laufend") - (mitUst ? s("ust") : 0); return `
Einnahmen${glatt(s("einnahmen"))}
Projektkosten${glatt(-s("projektkosten"))}
Laufende Kosten${glatt(-s("laufend"))}
${mitUst ? `
Umsatzsteuer (Schätzung)${glatt(-s("ust"))}
` : ""}
Überschuss ${zeitText}${glatt(ueber)}
`; } /** Linien je Woche; Kosten als positive Beträge, Umsatzsteuer: Zahllast positiv, Erstattung negativ */ export function flussSvg(fluss: Zeile[], platz: number, mitUst: boolean, wahl?: { gewaehlt: string | null }): string { if (!fluss.length) return '

Keine Wochen im Zeitraum.

'; const reihen = FLUSS.filter(([k]) => mitUst || k !== "ust"); const B = Math.max(340, Math.round(platz)), H = B < 600 ? 200 : 230, L = 56, R = 16, O = 14, U = 28; const alle = fluss.flatMap((w) => reihen.map(([k]) => Number(w[k] ?? 0))); const roh = { min: Math.min(0, ...alle), max: Math.max(1, ...alle) }; const grob = (roh.max - roh.min) / 4; const p10 = 10 ** Math.floor(Math.log10(grob)); const schritt = [1, 2, 5, 10].map((f) => f * p10).find((s) => s >= grob)!; const ymin = Math.floor(roh.min / schritt) * schritt, ymax = Math.ceil(roh.max / schritt) * schritt; const n = fluss.length; const x = (i: number) => L + (n === 1 ? (B - L - R) / 2 : (i * (B - L - R)) / (n - 1)); const y = (v: number) => O + ((ymax - v) * (H - O - U)) / (ymax - ymin || 1); const linien: string[] = []; for (let v = ymin; v <= ymax + 1; v += schritt) { linien.push(`${glatt(v).replace(" €", "")}`); } const jede = Math.max(1, Math.ceil(n / Math.max(2, Math.floor(B / 90)))); const beschriftung = fluss.map((w, i) => (i % jede === 0 || i === n - 1 ? `${kw(w.von)}` : "")).join(""); const kurven = reihen.map(([k, kl]) => ` ${fluss.map((w, i) => `${kw(w.von)} · ${dat(w.von).slice(0, 6)} – ${dat(w.bis).slice(0, 6)} ${reihen.map(([k2, , t]) => `${t}: ${glatt(Number(w[k2] ?? 0))}`).join("\n")}`).join("")}`).join(""); // Woche anklicken: Zahlungen dieser Woche (Liquiditätsseite) const breite = n > 1 ? (B - L - R) / (n - 1) : B - L - R; const ziele = wahl ? fluss.map((w, i) => `${kw(w.von)} · ${dat(w.von).slice(0, 6)} – ${dat(w.bis).slice(0, 6)} ${reihen.map(([k2, , t]) => `${t}: ${glatt(Number(w[k2] ?? 0))}`).join("\n")}`).join("") : ""; return `${linien.join("")}${kurven}${beschriftung}${ziele}
${reihen.map(([, kl, t]) => `${t} je Woche`).join("")}${mitUst ? "Umsatzsteuer unter 0 = Erstattung" : ""}
`; } function kurveSvg(d: Zeile, platz: number, was?: Zeile[]): string { const wochen = d.wochen as Zeile[]; if (!wochen.length) return '

Keine Wochen im Zeitraum.

'; // so breit wie die Karte, damit die Schrift überall gleich groß bleibt const B = Math.max(340, Math.round(platz)), H = B < 600 ? 220 : 260, L = 56, R = 12, O = 22, U = 30; const stand = [d.kontostand as number, ...wochen.map((w) => w.kontostand as number)]; const ein = wochen.map((w) => w.einnahmen as number), aus = wochen.map((w) => -(w.ausgaben as number)); const mg = d.mindestgrenze as number; // Was wäre, wenn: Kontostand der Variante als zweite, gestrichelte Linie const wasStand = was ? [d.kontostand as number, ...was.map((w) => w.kontostand as number)] : []; const roh = { min: Math.min(0, ...stand, ...wasStand), max: Math.max(1, mg, ...stand, ...wasStand, ...ein, ...aus) }; // runde Schritte: 1, 2 oder 5 mal Zehnerpotenz, etwa vier Linien const grob = (roh.max - roh.min) / 4; const p10 = 10 ** Math.floor(Math.log10(grob)); const schritt = [1, 2, 5, 10].map((f) => f * p10).find((s) => s >= grob)!; const ymin = Math.floor(roh.min / schritt) * schritt, ymax = Math.ceil(roh.max / schritt) * schritt; const n = wochen.length; const x = (i: number) => L + (i * (B - L - R)) / n; const y = (v: number) => O + ((ymax - v) * (H - O - U)) / (ymax - ymin || 1); const linien: string[] = []; for (let v = ymin; v <= ymax + 1; v += schritt) { linien.push(`${glatt(v).replace(" €", "")}`); } const pfad = (werte: number[], ab: number) => werte.map((v, i) => `${x(i + ab).toFixed(1)},${y(v).toFixed(1)}`).join(" "); const standPkt = pfad(stand, 0); const basis = y(Math.max(ymin, 0)); let ti = 1; stand.forEach((v, i) => { if (i > 0 && v < stand[ti]!) ti = i; }); const jede = Math.max(1, Math.ceil(n / Math.max(2, Math.floor(B / 140)))); const breite = (B - L - R) / n; const spalten = wochen.map((w, i) => `${kw(w.von)} · ${dat(w.von).slice(0, 6)} – ${dat(w.bis).slice(0, 6)} Kontostand am Ende: ${glatt(w.kontostand)} Einnahmen: ${glatt(w.einnahmen)} · Ausgaben: ${glatt(-w.ausgaben)}`).join(""); const beschriftung = wochen.map((w, i) => ((i + 1) % jede === 0 || i === n - 1 ? `${kw(w.von)}` : "")).join(""); const tx = x(ti), ty = y(stand[ti]!); const rechtsBuendig = tx > B - 170; return ` ${linien.join("")} ${mg > 0 ? ` Mindestgrenze ${glatt(mg)}` : ""} ${was ? `` : ""} ${stand.slice(1).map((v, i) => ``).join("")} heute tiefster Punkt ${glatt(stand[ti]!)} ${beschriftung}${spalten}`; } /** Zahlungen der angeklickten Woche unter der Kurve */ function wocheHtml(w: Zeile | undefined, namen: Map, ohne = false): string { if (!w) return ""; const posten = [...(w.posten as Zeile[])].sort((a, b) => (a.datum < b.datum ? -1 : a.datum > b.datum ? 1 : a.betrag - b.betrag)); return `

${kw(w.von)} · ${dat(w.von).slice(0, 6)} – ${dat(w.bis)}

${posten.length ? `${posten.map((p) => ``).join("")}
${dat(p.datum).slice(0, 6)}${postenText(p, namen)} ${glatt(p.betrag)}
Saldo der Woche${ohne ? "" : ` · Kontostand danach ${glatt(w.kontostand)}`}${glatt(ohne ? posten.reduce((x, p) => x + p.betrag, 0) : w.saldo)}
` : '

In dieser Woche ist keine Zahlung geplant.

'}
`; } async function lageZeigen(): Promise { const n = WOCHEN[zeitraum]; const [d, projekte] = await Promise.all([api(`liquiditaet/lage?wochen=${n}&heute=${heute()}`), api("projekte")]); const namen = new Map(projekte.map((p) => [p.nummer as string, p.bezeichnung as string])); // vorerst ohne Kontostand (Henning, 23.10.2026): nur Einnahmen, Projektkosten, laufende Kosten und Umsatzsteuer const ohne = !d.mitKontostand; if (ohne) d.wochen = (d.wochen as Zeile[]).map((w) => ({ ...w, posten: (w.posten as Zeile[]).filter((p) => FLUSS_GRUPPEN.has(p.gruppe)) })); const wochen = d.wochen as Zeile[]; const bereich = document.createElement("div"); bereich.className = "liqui-seite"; inhalt.append(bereich); let ansicht = gespeicherteAnsicht(AUS_SCHLUESSEL); const zeichne = () => { const ausSet = new Set(ansicht.aus); const zeilen = { ein: zeilenVon("ein", wochen), aus: zeilenVon("aus", wochen) }; const v = variante(d); bereich.innerHTML = (v ? probeBand(d, v, zeilen, ohne) : "") + (ohne ? flussKopfHtml(wochen) : lageKopfHtml(d, ZEIT_TEXT[zeitraum])) + (ohne ? `

Einnahmen, Projektkosten, laufende Kosten und Umsatzsteuer · nächste ${ZEIT_KNOPF[zeitraum]}

${flussSvg(flussJeWoche((v?.wochen ?? wochen) as Periode[]), bereich.clientWidth - 34, true, { gewaehlt })}

Woche anklicken: Zahlungen dieser Woche.${v ? " Das Diagramm zeigt die probeweisen Änderungen." : ""}

${wocheHtml(wochen.find((w) => w.von === gewaehlt), namen, true)}
` : `

Kontostand, Einnahmen und Ausgaben · nächste ${ZEIT_KNOPF[zeitraum]}

${kurveSvg(d, bereich.clientWidth - 34, v?.wochen)}
KontostandEinnahmen je WocheAusgaben je WocheMindestgrenze${v ? 'Was wäre, wenn' : ""}

Woche anklicken: Zahlungen dieser Woche. Mindestgrenze: ${d.mindestgrenzeArt === "fest" ? `fester Betrag ${glatt(d.mindestgrenze)}` : `1 Monat laufende Kosten (${glatt(d.laufendMonat)})`}.

${planHinweis(d)}

${wocheHtml(wochen.find((w) => w.von === gewaehlt), namen)}
`) + `
Modus: ${modus === "was" ? "Haken weg = probeweise ohne diesen Posten. Datum anklicken = probeweise verschieben. Nichts wird gespeichert." : "Das Auge blendet eine Zeile nur aus der Liste aus; Kurve und Satz rechnen weiter mit."}
${listeHtml("ein", zeilen.ein, namen, ausSet, d)}${listeHtml("aus", zeilen.aus, namen, ausSet, d)}
`; }; zeichne(); bereich.onclick = (ev) => { const t = ev.target as HTMLElement; const w = t.closest("[data-woche]"); if (w) { gewaehlt = gewaehlt === w.dataset.woche ? null : w.dataset.woche!; return zeichne(); } const m = t.closest("[data-mehr]"); if (m) { const k = m.dataset.mehr as "ein" | "aus"; mehr[k] = !mehr[k]; return zeichne(); } const pv = t.closest("[data-plan-vorschau]"); if (pv) { void (async () => { const e = await api("einstellungen"); await api("einstellungen", "PUT", { ...e, jahresplanVorschau: pv.dataset.planVorschau === "an" }); void liquiditaetSeite(); })(); return; } const knopf = t.closest("[data-modus], [data-ausblenden], [data-zeige-aus], [data-alle-ein], [data-a=probe-weg], [data-verschieben]"); if (knopf?.dataset.modus) { modus = knopf.dataset.modus as "aus" | "was"; return zeichne(); } if (knopf?.dataset.ausblenden) { const k = knopf.dataset.ausblenden; ansicht = { ...ansicht, aus: ansicht.aus.includes(k) ? ansicht.aus.filter((x) => x !== k) : [...ansicht.aus, k] }; ansichtMerken(AUS_SCHLUESSEL, ansicht); return zeichne(); } if (knopf?.dataset.zeigeAus) { const k = knopf.dataset.zeigeAus as "ein" | "aus"; zeigeAus[k] = !zeigeAus[k]; return zeichne(); } if (knopf?.dataset.alleEin) { const art = knopf.dataset.alleEin as "ein" | "aus"; const keys = new Set(zeilenVon(art, wochen).map((z) => z.key)); ansicht = { ...ansicht, aus: ansicht.aus.filter((x) => !keys.has(x)) }; ansichtMerken(AUS_SCHLUESSEL, ansicht); zeigeAus[art] = false; return zeichne(); } if (knopf?.dataset.a === "probe-weg") { probe.clear(); return zeichne(); } if (knopf?.dataset.verschieben) { // Datum probeweise verschieben: kleines Datumsfeld an Ort und Stelle const k = knopf.dataset.verschieben; const alt = knopf.dataset.datum!; const feld = document.createElement("input"); feld.type = "date"; feld.className = "liqui-datum"; feld.value = probe.get(k)?.datum ?? alt; feld.setAttribute("aria-label", "Probeweise verschieben auf"); knopf.replaceWith(feld); feld.focus(); try { feld.showPicker?.(); } catch { /* nicht überall erlaubt */ } const fertig = () => { const p = { ...(probe.get(k) ?? {}) }; if (feld.value && feld.value !== alt) p.datum = feld.value; else delete p.datum; if (p.weg || p.datum) probe.set(k, p); else probe.delete(k); zeichne(); }; feld.addEventListener("change", fertig); feld.addEventListener("blur", fertig); return; } if (t.closest("[data-a=woche-zu]")) { gewaehlt = null; return zeichne(); } const ks = t.closest("[data-kontostand]"); if (ks) { void (async () => { const e = await api("einstellungen"); await api("einstellungen", "PUT", { ...e, liquiditaetMitKontostand: ks.dataset.kontostand === "an" }); void liquiditaetSeite(); })(); return; } if (t.closest("[data-a=grenze]")) grenzeBearbeiten(bereich.querySelector("#l-grenze")!, d); }; bereich.onchange = (ev) => { const el = ev.target as HTMLInputElement; if (el.dataset.probe === undefined) return; const k = el.dataset.probe; const p = { ...(probe.get(k) ?? {}) }; if (el.checked) delete p.weg; else p.weg = true; if (p.weg || p.datum) probe.set(k, p); else probe.delete(k); zeichne(); }; bereich.onkeydown = (ev) => { const w = (ev.target as Element).closest?.("[data-woche]"); if (w && (ev.key === "Enter" || ev.key === " ")) { ev.preventDefault(); gewaehlt = w.dataset.woche!; zeichne(); } }; } // ---------- Ausblenden und „Was wäre, wenn“ (Henning, 21.10.2026) ---------- const AUS_SCHLUESSEL = "liquiditaet-lage"; /** Modus der Listen und die probeweisen Änderungen; nichts davon wird gespeichert, beim Verlassen der Seite ist es weg */ let modus: "aus" | "was" = "aus"; const probe = new Map(); const zeigeAus = { ein: false, aus: false }; addEventListener("hashchange", () => { if (!location.hash.startsWith("#liquiditaet")) { probe.clear(); modus = "aus"; } }); interface ListenZeile { key: string; datum: string; ueberfaelligSeit?: string; gestellt?: boolean; bezeichnung: string; projekt?: string; betrag: number; anzahl: number; einzeln?: string[] } /** Schlüssel einer Zahlung, bleibt über Neuladen gleich; laufende Kosten eines Monats sind eine Zeile */ const postenKey = (p: Zeile): string => (p.gruppe === "Laufende Kosten" && p.betrag < 0 ? `lk|${String(p.datum).slice(0, 7)}` : `${p.gruppe}|${p.projekt ?? ""}|${p.bezeichnung}|${p.ueberfaelligSeit ?? p.datum}`); /** Zeilen für „Kommt rein“ oder „Geht raus“: Überfälliges oben, dann nach Datum; laufende Kosten je Monat in einer Zeile */ function zeilenVon(art: "ein" | "aus", wochen: Zeile[]): ListenZeile[] { const h = heute(); const posten = wochen.flatMap((w) => w.posten as Zeile[]).filter((p) => (art === "ein" ? p.betrag > 0 : p.betrag < 0) && !(p.bezahlt && p.datum < h)); const nachKey = new Map(); for (const p of posten) { const key = postenKey(p); const z = nachKey.get(key); if (z) { z.betrag += p.betrag; z.anzahl++; z.einzeln?.push(p.bezeichnung); continue; } const lk = key.startsWith("lk|"); nachKey.set(key, { key, datum: p.datum, ueberfaelligSeit: p.ueberfaelligSeit, gestellt: p.gestellt, projekt: p.projekt, betrag: p.betrag, anzahl: 1, bezeichnung: lk ? `Laufende Kosten ${MONATSNAMEN[Number(String(p.datum).slice(5, 7)) - 1]}` : p.bezeichnung, ...(lk ? { einzeln: [p.bezeichnung] } : {}) }); } return [...nachKey.values()].sort((a, b) => (a.ueberfaelligSeit ? 0 : 1) - (b.ueberfaelligSeit ? 0 : 1) || (a.ueberfaelligSeit ?? a.datum).localeCompare(b.ueberfaelligSeit ?? b.datum) || a.betrag - b.betrag); } /** Die Wochen noch einmal mit den probeweisen Änderungen gerechnet: weggelassen, verschoben (vor dem Zeitraum = erste Woche, danach = raus) */ function variante(d: Zeile): { wochen: Zeile[]; lage: Zeile } | null { if (!probe.size) return null; const wochen = d.wochen as Zeile[]; if (!wochen.length) return null; const alle: Zeile[] = []; for (const w of wochen) for (const p of w.posten as Zeile[]) { const x = probe.get(postenKey(p)); if (x?.weg) continue; alle.push(x?.datum ? { ...p, datum: x.datum } : p); } let stand = d.kontostand as number; const neu = wochen.map((w, i) => { const posten = alle.filter((p) => p.datum <= w.bis); for (const p of posten) alle.splice(alle.indexOf(p), 1); const einnahmen = posten.filter((p) => p.betrag > 0).reduce((s, p) => s + p.betrag, 0); const ausgaben = posten.filter((p) => p.betrag < 0).reduce((s, p) => s + p.betrag, 0); stand += einnahmen + ausgaben; return { ...w, posten, einnahmen, ausgaben, saldo: einnahmen + ausgaben, kontostand: stand }; }); return { wochen: neu, lage: lage(neu as Periode[], d.kontostand, d.mindestgrenze) }; } /** Gelbes Band oben: was probeweise geändert ist und wo der tiefste Punkt dann liegt */ function probeBand(d: Zeile, v: { lage: Zeile; wochen: Zeile[] }, zeilen: { ein: ListenZeile[]; aus: ListenZeile[] }, ohne = false): string { const alle = [...zeilen.ein, ...zeilen.aus]; const teile = [...probe.entries()].map(([k, x]) => { const z = alle.find((y) => y.key === k); if (!z) return ""; const name = `${esc(z.bezeichnung)} ${glatt(Math.abs(z.betrag))}`; return x.weg ? `${name} rausgenommen` : `${name} auf ${dat(x.datum!).slice(0, 6)} verschoben`; }).filter(Boolean); const t = v.lage.tief, alt = d.lage.tief; const ueberschuss = (w: Zeile[]) => flussJeWoche(w as Periode[]).reduce((s, x) => s + x.einnahmen - x.projektkosten - x.laufend - x.ust, 0); const satz = ohne ? `Überschuss dann ${glatt(ueberschuss(v.wochen))} statt ${glatt(ueberschuss(d.wochen))}.` : t ? `Tiefster Punkt dann ${kw(t.von)} mit ${glatt(t.kontostand)}${alt ? ` statt ${glatt(alt.kontostand)}` : ""}.` : ""; return `
Was wäre, wenn ist an: ${teile.join(", ") || "keine Änderung"}.
${satz} Nichts davon ist gespeichert.
`; } /** „Kommt rein“ oder „Geht raus“ mit Auge (Ausblenden) oder Haken und Datum (Was wäre, wenn) */ function listeHtml(art: "ein" | "aus", alle: ListenZeile[], namen: Map, ausSet: Set, d: Zeile): string { const h = heute(); const was = modus === "was"; const versteckt = alle.filter((z) => ausSet.has(z.key)); const posten = alle.filter((z) => !ausSet.has(z.key) || zeigeAus[art]); const ueber = posten.filter((p) => p.ueberfaelligSeit).length; const sichtbar = mehr[art] ? posten.length : Math.max(SICHTBAR, ueber); const summe = (l: ListenZeile[]) => l.reduce((s, p) => s + p.betrag, 0); const wochen = d.wochen as Zeile[]; const ende = wochen.at(-1)?.bis ?? h; const probeSumme = alle.reduce((s, z) => { const x = probe.get(z.key); return s + (x?.weg || (x?.datum && x.datum > ende) ? 0 : z.betrag); }, 0); const zeile = (p: ListenZeile) => { const seit = p.ueberfaelligSeit; const tage = seit ? tageZwischen(seit, h) : 0; const tag = seit ? ` ${p.gestellt ? `${tage} ${tage === 1 ? "Tag" : "Tage"} überfällig` : "Rechnung fehlt"}` : ""; const titel = p.einzeln ? ` title="${esc(p.einzeln.join(", "))}"` : ""; const x = probe.get(p.key), weg = ausSet.has(p.key); const datumText = seit ? `seit ${dat(seit).slice(0, 6)}` : dat(p.datum).slice(0, 6); const datum = was ? `${x?.datum ? ` → ${dat(x.datum).slice(0, 6)}` : ""}` : datumText; const vorne = was ? `` : ``; return `${vorne}${datum} ${postenText(p, namen)}${p.anzahl > 1 ? ` (${p.anzahl})` : ""}${tag}${glatt(p.betrag)}`; }; const rest = posten.slice(sichtbar); const probeText = probe.size && probeSumme !== summe(alle) ? ` (probeweise ${glatt(probeSumme)})` : ""; return `

${art === "ein" ? "Kommt rein" : "Geht raus"} · nächste ${ZEIT_KNOPF[zeitraum]}

${alle.length ? `${posten.slice(0, sichtbar).map(zeile).join("")} ${rest.length || (mehr[art] && posten.length > SICHTBAR) ? `` : ""} ${versteckt.length ? `` : ""}
${versteckt.length} ${versteckt.length === 1 ? "Zeile" : "Zeilen"} ausgeblendet · ${zeigeAus[art] ? ` · ` : ""} (zählt weiter mit)
Summe aller ${alle.length}${probeText}${glatt(summe(alle))}
` : `

${art === "ein" ? "Im Zeitraum kommt nichts rein." : "Im Zeitraum geht nichts raus."}

`}
`; } /** Stufe 5: Posten aus dem Jahresplan zählen als Vorschau; hier ein- und ausschalten */ function planHinweis(d: Zeile): string { const plan = (d.wochen as Zeile[]).flatMap((w) => w.posten as Zeile[]).filter((p) => p.gruppe === "Jahresplan"); if (d.jahresplanVorschau && !plan.length) return ""; return `

${d.jahresplanVorschau ? `Ab ${MONATSNAMEN[Number(plan[0]!.datum.slice(5, 7)) - 1]} ${plan[0]!.datum.slice(0, 4)} rechnet die Liquidität mit dem Jahresplan, soweit echte Zahlungen fehlen (Posten „Plan: …“). ` : `Die Vorschau aus dem Jahresplan ist ausgeschaltet. `}

`; } /** Zahnrad: Mindestgrenze automatisch (1 Monat laufende Kosten) oder fester Betrag */ function grenzeBearbeiten(ziel: HTMLElement, d: Zeile): void { if (!ziel.hidden) { ziel.hidden = true; return; } const fest = d.mindestgrenzeArt === "fest"; ziel.hidden = false; ziel.innerHTML = `

Später kommen die Töpfe dazu (Stufe 5), dann ist das Ziel 6 Monate laufende Kosten.

`; const f = ziel.querySelector("form")!; f.querySelector("[name=betrag]")!.onfocus = () => { f.querySelector("[value=fest]")!.checked = true; }; f.querySelector("[data-a=grenze-zu]")!.onclick = (ev) => { ev.stopPropagation(); ziel.hidden = true; }; f.onsubmit = async (ev) => { ev.preventDefault(); const art = (f.querySelector("[name=art]:checked")?.value ?? "auto") as "auto" | "fest"; let betrag = d.festerBetrag as number; try { if (art === "fest") betrag = parseEuro(f.querySelector("[name=betrag]")!.value); if (betrag < 0) throw new Error("Bitte einen Betrag ab 0 € eingeben."); const e = await api("einstellungen"); await api("einstellungen", "PUT", { ...e, mindestgrenzeArt: art, mindestreserve: betrag }); void liquiditaetSeite(); } catch (err) { f.querySelector("#l-grenze-fehler")!.textContent = (err as Error).message === "Leerer Betrag" ? "Bitte einen Betrag eingeben." : (err as Error).message; } }; } // ---------- Monatsplan und alle Zahlungen ---------- async function planZeigen(): Promise { const anzahl = raster === "monat" ? MONATE[zeitraum] : WOCHEN[zeitraum]; const [roh, projekte, einst] = await Promise.all([ api(`liquiditaet?ansicht=${raster}&anzahl=${anzahl}&start=${heute()}&offene=1`), api("projekte"), api("einstellungen"), ]); // ohne Kontostand: nur die vier Gruppen, Spalten je Gruppe und Überschuss statt Kontostand const ohne = !einst.liquiditaetMitKontostand; const perioden: Zeile[] = ohne ? roh.map((p) => ({ ...p, posten: (p.posten as Zeile[]).filter((x) => FLUSS_GRUPPEN.has(x.gruppe)) })) : roh; const flussVon = (p: Zeile) => flussJeWoche([p as Periode])[0]!; const namen = new Map(projekte.map((p) => [p.nummer as string, p.bezeichnung as string])); const zeitText = (p: Zeile) => (raster === "woche" ? `${kw(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)}`); const h = heute(); const kopf = document.createElement("div"); kopf.className = "liqui-plan-kopf"; const alleOffen = perioden.length > 0 && perioden.every((p) => liquiOffen.has(p.von)); kopf.innerHTML = `
`; kopf.onclick = (ev) => { const b = ev.target as HTMLElement; if (b.dataset.raster) { raster = b.dataset.raster as "monat" | "woche"; void liquiditaetSeite(); } if (b.dataset.a === "alle") { liquiOffen = alleOffen ? new Set() : new Set(perioden.map((p) => p.von)); void liquiditaetSeite(); } }; const zeile = (x: Zeile) => `${x.ueberfaelligSeit ? `seit ${dat(x.ueberfaelligSeit)}` : dat(x.datum)} ${esc(x.bezeichnung)}${x.ueberfaelligSeit ? ` ${x.gestellt ? "überfällig" : "Rechnung fehlt"}` : ""}${esc(x.gruppe)} ${x.projekt ? `${esc(x.projekt)}${namen.get(x.projekt) ? ` ${esc(namen.get(x.projekt))}` : ""}` : ""}${euro(x.betrag)}`; const tab = document.createElement("table"); tab.className = "liqui-tabelle"; const spalten = ohne ? 6 : 5; const zahlen = (p: Zeile) => { if (!ohne) return `${p.einnahmen ? euro(p.einnahmen) : "–"}${p.ausgaben ? euro(p.ausgaben) : "–"}${euro(p.saldo)} ${euro(p.kontostand)}`; const f = flussVon(p), u = f.einnahmen - f.projektkosten - f.laufend - f.ust; const z = (c: number, kl: string) => `${c ? euro(c) : "–"}`; return `${z(f.einnahmen, "ein")}${z(-f.projektkosten, "aus")}${z(-f.laufend, "aus")}${z(-f.ust, "aus optional")}${euro(u)}`; }; tab.innerHTML = `${raster === "woche" ? "Woche" : "Monat"}${ohne ? 'EinnahmenProjektkostenLaufende KostenUmsatzsteuerÜberschuss' : 'EinnahmenAusgabenSaldoKontostand'} ${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 `${offen ? "▾" : "▸"} ${esc(zeitText(p))} ${posten.length} ${posten.length === 1 ? "Zahlung" : "Zahlungen"} ${zahlen(p)} ${offen ? `${posten.length ? `${posten.map(zeile).join("")}
Fällig amWasProjektBetrag
` : '

Keine Zahlungen in diesem Zeitraum.

'}` : ""}`; }).join("")}`; tab.addEventListener("click", (ev) => { const tr = (ev.target as HTMLElement).closest("tr.periode"); if (!tr) return; const von = tr.dataset.von!; liquiOffen.has(von) ? liquiOffen.delete(von) : liquiOffen.add(von); void liquiditaetSeite(); }); inhalt.append(kopf, tab); } async function alleZeigen(): Promise { const [perioden, projekte, einst] = await Promise.all([ api(`liquiditaet?ansicht=woche&anzahl=${WOCHEN[zeitraum]}&start=${heute()}&offene=1`), api("projekte"), api("einstellungen"), ]); const namen = new Map(projekte.map((p) => [p.nummer as string, p.bezeichnung as string])); const h = heute(); const ohne = !einst.liquiditaetMitKontostand; // Kontostand nach jeder Zahlung, in zeitlicher Reihenfolge gerechnet; bleibt beim Umsortieren an der Zahlung let stand = perioden.length ? perioden[0]!.kontostand - perioden[0]!.saldo : Number(einst.startsaldo ?? 0); const posten = perioden.flatMap((p) => p.posten as Zeile[]).filter((x) => !ohne || FLUSS_GRUPPEN.has(x.gruppe)) .sort((x, y) => (x.datum < y.datum ? -1 : x.datum > y.datum ? 1 : x.betrag - y.betrag)) .map((x, i) => ({ ...x, id: `${x.datum}-${i}-${x.bezeichnung}`, stand: (stand += x.betrag) })); inhalt.append(liste({ schluessel: "liquiditaet-zahlungen", einheit: ["Zahlung", "Zahlungen"], leer: "Keine Zahlungen im Zeitraum.", zeilenKlasse: (x) => (x.ueberfaelligSeit ? "ueber" : x.datum < h ? "vorbei" : ""), spalten: [ { id: "datum", titel: "Fällig am", art: "datum", wert: (x) => (x.ueberfaelligSeit ? `seit ${dat(x.ueberfaelligSeit)}` : dat(x.datum)), sortWert: (x) => x.ueberfaelligSeit ?? x.datum }, { id: "was", titel: "Was", text: (x) => x.bezeichnung, wert: (x) => `${esc(x.bezeichnung)}${x.ueberfaelligSeit ? ` ${x.gestellt ? "überfällig" : "Rechnung fehlt"}` : ""}${esc(x.gruppe)}` }, { id: "gruppe", titel: "Art", wert: (x) => esc(x.gruppe), klasse: "optional" }, { id: "projekt", titel: "Projekt", wert: (x) => (x.projekt ? `${esc(x.projekt)}${namen.get(x.projekt) ? ` ${esc(namen.get(x.projekt))}` : ""}` : ""), klasse: "optional" }, { id: "betrag", titel: "Betrag", art: "zahl", wert: (x) => `${euro(x.betrag)}`, sortWert: (x) => x.betrag, klasse: "zahl" }, ...(ohne ? [] : [{ id: "stand", titel: "Kontostand danach", art: "zahl" as const, wert: (x: Zeile) => `${euro(x.stand)}`, sortWert: (x: Zeile) => x.stand, klasse: "zahl optional" }]), ], zeilen: posten, fuss: (l) => (l.length === posten.length ? "" : `

Summe der gezeigten Zahlungen: ${euro(l.reduce((s, x) => s + x.betrag, 0))}

`), })); }