Files
Betriebsf-hrungssoftware/src/web/liquiditaet.ts
Claude cfd36f5fd3
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
0.35.0: Liquiditätsseite ohne Kontostand, mit Umsatzsteuer
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-24 05:38:49 +00:00

547 lines
42 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.
// 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<Zeitraum, number> = { "4w": 4, "6w": 6, "3m": 13 };
const MONATE: Record<Zeitraum, number> = { "4w": 2, "6w": 2, "3m": 3 };
const ZEIT_TEXT: Record<Zeitraum, string> = { "4w": "4 Wochen", "6w": "6 Wochen", "3m": "3 Monaten" };
const ZEIT_KNOPF: Record<Zeitraum, string> = { "4w": "4 Wochen", "6w": "6 Wochen", "3m": "3 Monate" };
/** so viele Zeilen je Liste, der Rest hinter „weitere anzeigen“ */
const SICHTBAR = 4;
const gespeichert = <T extends string>(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<string>();
let gewaehlt: string | null = null;
const mehr = { ein: false, aus: false };
export async function liquiditaetSeite(): Promise<void> {
const leiste = seite("Liquidität");
leiste.classList.add("liqui-leiste");
leiste.innerHTML = `<div class="liqui-zeit" role="group" aria-label="Zeitraum"><span class="hinweis">Zeitraum:</span>${(Object.keys(WOCHEN) as Zeitraum[]).map((z) =>
`<button class="chip-knopf${z === zeitraum ? " an" : ""}" data-zeitraum="${z}" aria-pressed="${z === zeitraum}">${ZEIT_KNOPF[z]}</button>`).join("")}</div>
<div class="liqui-reiter" role="tablist">${([["lage", "Lage"], ["monat", "Monatsplan"], ["alle", "Alle Zahlungen"]] as [Reiter, string][]).map(([r, t]) =>
`<button role="tab" class="${r === reiter ? "haupt" : "neben"}" data-reiter="${r}" aria-selected="${r === reiter}">${t}</button>`).join("")}</div>`;
leiste.onclick = (ev) => {
const b = (ev.target as HTMLElement).closest<HTMLElement>("[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<string, string>) =>
`${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 `<section class="karte liqui-fluss-kopf">${flussKachelnHtml(flussJeWoche(wochen as Periode[]), ZEIT_KNOPF[zeitraum], true)}
<p class="hinweis">Ohne Kontostand gerechnet: Einnahmen, Projektkosten, laufende Kosten und Umsatzsteuer (monatlich, fällig am 10. des übernächsten Monats).
<button class="verweis" data-kontostand="an">Kontostand einbeziehen</button></p></section>`;
}
/** 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 <b>${glatt(Math.abs(l.abstand))}</b> ${l.abstand >= 0 ? "über" : "unter"} deiner Mindestgrenze von ${glatt(mg)}` : "";
satz = `In den nächsten <b>${esc(zeitText)}</b> wird es am knappsten ${l.tief.von <= heute() ? "" : "in "}<b>${wann}</b> mit <b class="${l.tief.kontostand < 0 ? "fehler" : ""}">${glatt(l.tief.kontostand)}</b>${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)}` : '<a href="#daten">Kontostand noch nicht eingetragen</a>';
return `<section class="karte liqui-lage ${chip[0]}">
<div class="liqui-frei"><span class="hinweis">Frei verfügbar heute</span><b class="gross${l.frei < 0 ? " fehler" : ""}">${glatt(l.frei)}</b>
<span class="hinweis">Kontostand ${glatt(d.kontostand)} − Mindestgrenze ${glatt(mg)} · ${stand}</span></div>
<div class="liqui-satz"><span class="ampel-chip ${chip[0]}">${chip[1]}</span><p>${satz}</p>${grund ? `<p class="hinweis">${grund}</p>` : ""}</div></section>`;
}
/** 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 `<div class="fluss-kacheln">
<div><small>Einnahmen</small><b class="fl-ein">${glatt(s("einnahmen"))}</b></div>
<div><small>Projektkosten</small><b class="fl-pk">${glatt(-s("projektkosten"))}</b></div>
<div><small>Laufende Kosten</small><b class="fl-lk">${glatt(-s("laufend"))}</b></div>
${mitUst ? `<div><small>Umsatzsteuer (Schätzung)</small><b class="fl-ust">${glatt(-s("ust"))}</b></div>` : ""}
<div><small>Überschuss ${zeitText}</small><b class="${ueber < 0 ? "fehler" : ""}">${glatt(ueber)}</b></div></div>`;
}
/** 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 '<p class="hinweis">Keine Wochen im Zeitraum.</p>';
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(`<line class="gitter${v === 0 ? " null" : ""}" x1="${L}" x2="${B - R}" y1="${y(v)}" y2="${y(v)}"/><text class="achse" x="${L - 8}" y="${y(v) + 4}" text-anchor="end">${glatt(v).replace(" €", "")}</text>`);
}
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 ? `<text class="achse" x="${x(i)}" y="${H - 8}" text-anchor="${i === n - 1 && n > 1 ? "end" : i === 0 ? "start" : "middle"}">${kw(w.von)}</text>` : "")).join("");
const kurven = reihen.map(([k, kl]) => `<polyline class="fl-linie ${kl}" points="${fluss.map((w, i) => `${x(i).toFixed(1)},${y(Number(w[k] ?? 0)).toFixed(1)}`).join(" ")}"/>
${fluss.map((w, i) => `<circle class="fl-punkt ${kl}" cx="${x(i)}" cy="${y(Number(w[k] ?? 0))}" r="3.5"><title>${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")}</title></circle>`).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) => `<rect class="woche-ziel${w.von === wahl.gewaehlt ? " an" : ""}" data-woche="${w.von}" tabindex="0" role="button" aria-label="${kw(w.von)}: Zahlungen anzeigen"
x="${x(i) - breite / 2}" y="${O}" width="${breite}" height="${H - O - U}"><title>${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")}</title></rect>`).join("") : "";
return `<svg class="liqui-svg fluss-svg" viewBox="0 0 ${B} ${H}" role="img" aria-label="${reihen.map(([, , t]) => t).join(", ")} je Woche">${linien.join("")}${kurven}${beschriftung}${ziele}</svg>
<div class="fluss-legende">${reihen.map(([, kl, t]) => `<span><i class="${kl}"></i>${t} je Woche</span>`).join("")}${mitUst ? "<span>Umsatzsteuer unter 0 = Erstattung</span>" : ""}</div>`;
}
function kurveSvg(d: Zeile, platz: number, was?: Zeile[]): string {
const wochen = d.wochen as Zeile[];
if (!wochen.length) return '<p class="hinweis">Keine Wochen im Zeitraum.</p>';
// 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(`<line class="gitter${v === 0 ? " null" : ""}" x1="${L}" x2="${B - R}" y1="${y(v)}" y2="${y(v)}"/><text class="achse" x="${L - 8}" y="${y(v) + 4}" text-anchor="end">${glatt(v).replace(" €", "")}</text>`);
}
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) => `<rect class="woche-ziel${w.von === gewaehlt ? " an" : ""}" data-woche="${w.von}" tabindex="0" role="button"
aria-label="${kw(w.von)}: Kontostand ${glatt(w.kontostand)}, Einnahmen ${glatt(w.einnahmen)}, Ausgaben ${glatt(-w.ausgaben)}"
x="${x(i + 1) - breite / 2}" y="${O}" width="${breite}" height="${H - O - U}"><title>${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)}</title></rect>`).join("");
const beschriftung = wochen.map((w, i) => ((i + 1) % jede === 0 || i === n - 1 ? `<text class="achse" x="${x(i + 1)}" y="${H - 8}" text-anchor="${i === n - 1 ? "end" : "middle"}">${kw(w.von)}</text>` : "")).join("");
const tx = x(ti), ty = y(stand[ti]!);
const rechtsBuendig = tx > B - 170;
return `<svg class="liqui-svg" viewBox="0 0 ${B} ${H}" role="img" aria-label="Kontostand je Woche, tiefster Punkt ${glatt(stand[ti]!)} in ${kw(wochen[ti - 1]!.von)}">
${linien.join("")}
${mg > 0 ? `<rect class="grenz-flaeche" x="${L}" y="${y(mg)}" width="${B - L - R}" height="${Math.max(0, basis - y(mg))}"/><line class="grenze" x1="${L}" x2="${B - R}" y1="${y(mg)}" y2="${y(mg)}"/>
<text class="grenz-text" x="${B - R - 4}" y="${y(mg) - 6}" text-anchor="end">Mindestgrenze ${glatt(mg)}</text>` : ""}
<polygon class="stand-flaeche" points="${standPkt} ${x(n).toFixed(1)},${basis} ${x(0)},${basis}"/>
<polyline class="ein-linie" points="${pfad(ein, 1)}"/>
<polyline class="aus-linie" points="${pfad(aus, 1)}"/>
<polyline class="stand-linie" points="${standPkt}"/>
${was ? `<polyline class="was-linie" points="${pfad(wasStand, 0)}"/>` : ""}
${stand.slice(1).map((v, i) => `<circle class="stand-punkt${wochen[i]!.von === gewaehlt ? " an" : ""}" cx="${x(i + 1)}" cy="${y(v)}" r="4"/>`).join("")}
<circle class="heute-punkt" cx="${x(0)}" cy="${y(stand[0]!)}" r="5"/><text class="heute-text" x="${x(0) + 8}" y="${y(stand[0]!) - 8}">heute</text>
<circle class="tief-punkt" cx="${tx}" cy="${ty}" r="7"/><text class="tief-text" x="${rechtsBuendig ? tx - 10 : tx + 10}" y="${ty + (ty > H - U - 30 ? -12 : 20)}" text-anchor="${rechtsBuendig ? "end" : "start"}">tiefster Punkt ${glatt(stand[ti]!)}</text>
${beschriftung}${spalten}</svg>`;
}
/** Zahlungen der angeklickten Woche unter der Kurve */
function wocheHtml(w: Zeile | undefined, namen: Map<string, string>, 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 `<div class="liqui-woche"><div class="karte-kopf"><h3>${kw(w.von)} · ${dat(w.von).slice(0, 6)} – ${dat(w.bis)}</h3><button class="neben" data-a="woche-zu">Schließen</button></div>
${posten.length ? `<table class="liqui-posten"><tbody>${posten.map((p) => `<tr><td>${dat(p.datum).slice(0, 6)}</td><td class="text">${postenText(p, namen)}</td>
<td class="zahl ${p.betrag < 0 ? "aus" : "ein"}">${glatt(p.betrag)}</td></tr>`).join("")}</tbody>
<tfoot><tr><td></td><td>Saldo der Woche${ohne ? "" : ` · Kontostand danach ${glatt(w.kontostand)}`}</td><td class="zahl">${glatt(ohne ? posten.reduce((x, p) => x + p.betrag, 0) : w.saldo)}</td></tr></tfoot></table>`
: '<p class="hinweis">In dieser Woche ist keine Zahlung geplant.</p>'}</div>`;
}
async function lageZeigen(): Promise<void> {
const n = WOCHEN[zeitraum];
const [d, projekte] = await Promise.all([api<Zeile>(`liquiditaet/lage?wochen=${n}&heute=${heute()}`), api<Zeile[]>("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 ? `<section class="karte liqui-kurve"><div class="karte-kopf"><h2>Einnahmen, Projektkosten, laufende Kosten und Umsatzsteuer · nächste ${ZEIT_KNOPF[zeitraum]}</h2></div>
<div class="kurve-huelle">${flussSvg(flussJeWoche((v?.wochen ?? wochen) as Periode[]), bereich.clientWidth - 34, true, { gewaehlt })}</div>
<p class="hinweis">Woche anklicken: Zahlungen dieser Woche.${v ? " Das Diagramm zeigt die probeweisen Änderungen." : ""}</p>
${wocheHtml(wochen.find((w) => w.von === gewaehlt), namen, true)}</section>` : `<section class="karte liqui-kurve"><div class="karte-kopf"><h2>Kontostand, Einnahmen und Ausgaben · nächste ${ZEIT_KNOPF[zeitraum]}</h2>
<button class="neben zahnrad" data-a="grenze" aria-label="Mindestgrenze einstellen" title="Mindestgrenze einstellen">⚙ Mindestgrenze</button></div>
<div id="l-grenze" hidden></div>
<div class="kurve-huelle">${kurveSvg(d, bereich.clientWidth - 34, v?.wochen)}</div>
<div class="kurve-legende"><span><i class="k-stand"></i>Kontostand</span><span><i class="k-ein"></i>Einnahmen je Woche</span><span><i class="k-aus"></i>Ausgaben je Woche</span><span><i class="k-grenze"></i>Mindestgrenze</span>${v ? '<span><i class="k-was"></i>Was wäre, wenn</span>' : ""}</div>
<p class="hinweis">Woche anklicken: Zahlungen dieser Woche. Mindestgrenze: ${d.mindestgrenzeArt === "fest" ? `fester Betrag ${glatt(d.mindestgrenze)}` : `1 Monat laufende Kosten (${glatt(d.laufendMonat)})`}.</p>
${planHinweis(d)}
<p class="hinweis"><button class="verweis" data-kontostand="aus">Ohne Kontostand rechnen</button></p>
${wocheHtml(wochen.find((w) => w.von === gewaehlt), namen)}</section>`)
+ `<div class="liqui-modus" role="group" aria-label="Modus der Listen"><span class="hinweis">Modus:</span>
<button class="chip-knopf${modus === "aus" ? " an" : ""}" data-modus="aus" aria-pressed="${modus === "aus"}">👁 Ausblenden</button>
<button class="chip-knopf${modus === "was" ? " an was" : ""}" data-modus="was" aria-pressed="${modus === "was"}">🧪 Was wäre, wenn</button>
<span class="hinweis-k">${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."}</span></div>
<div class="liqui-zwei">${listeHtml("ein", zeilen.ein, namen, ausSet, d)}${listeHtml("aus", zeilen.aus, namen, ausSet, d)}</div>`;
};
zeichne();
bereich.onclick = (ev) => {
const t = ev.target as HTMLElement;
const w = t.closest<SVGElement>("[data-woche]");
if (w) { gewaehlt = gewaehlt === w.dataset.woche ? null : w.dataset.woche!; return zeichne(); }
const m = t.closest<HTMLElement>("[data-mehr]");
if (m) { const k = m.dataset.mehr as "ein" | "aus"; mehr[k] = !mehr[k]; return zeichne(); }
const pv = t.closest<HTMLElement>("[data-plan-vorschau]");
if (pv) {
void (async () => { const e = await api<Zeile>("einstellungen"); await api("einstellungen", "PUT", { ...e, jahresplanVorschau: pv.dataset.planVorschau === "an" }); void liquiditaetSeite(); })();
return;
}
const knopf = t.closest<HTMLElement>("[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<HTMLElement>("[data-kontostand]");
if (ks) {
void (async () => { const e = await api<Zeile>("einstellungen"); await api("einstellungen", "PUT", { ...e, liquiditaetMitKontostand: ks.dataset.kontostand === "an" }); void liquiditaetSeite(); })();
return;
}
if (t.closest("[data-a=grenze]")) grenzeBearbeiten(bereich.querySelector<HTMLElement>("#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?.<SVGElement>("[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<string, { weg?: boolean; datum?: string }>();
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<string, ListenZeile>();
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 <b>${glatt(ueberschuss(v.wochen))}</b> statt ${glatt(ueberschuss(d.wochen))}.`
: t ? `Tiefster Punkt dann <b>${kw(t.von)} mit ${glatt(t.kontostand)}</b>${alt ? ` statt ${glatt(alt.kontostand)}` : ""}.` : "";
return `<div class="liqui-probe" role="status"><span class="symbol" aria-hidden="true">🧪</span>
<div><b>Was wäre, wenn</b> ist an: ${teile.join(", ") || "keine Änderung"}.<br>${satz} Nichts davon ist gespeichert.</div>
<button class="neben" data-a="probe-weg">Zurücksetzen</button></div>`;
}
/** „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<string, string>, ausSet: Set<string>, 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 ? ` <span class="tag-ueber">${p.gestellt ? `${tage} ${tage === 1 ? "Tag" : "Tage"} überfällig` : "Rechnung fehlt"}</span>` : "";
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
? `<button class="liqui-dat" data-verschieben="${esc(p.key)}" data-datum="${p.datum}" title="Probeweise verschieben">${datumText}</button>${x?.datum ? ` → <span class="tag-probe">${dat(x.datum).slice(0, 6)}</span>` : ""}`
: datumText;
const vorne = was
? `<input type="checkbox" data-probe="${esc(p.key)}"${x?.weg ? "" : " checked"} aria-label="${esc(p.bezeichnung)} probeweise mitrechnen" title="Haken weg = probeweise ohne diesen Posten">`
: `<button class="auge" data-ausblenden="${esc(p.key)}" title="${weg ? "Wieder einblenden" : "Zeile ausblenden (zählt weiter mit)"}" aria-label="${weg ? "Wieder einblenden" : "Zeile ausblenden"}">${weg ? AUGE : AUGE_ZU}</button>`;
return `<tr class="${seit ? "ueber" : ""}${x?.weg ? " probe-weg" : ""}${x?.datum ? " probe-dat" : ""}${weg ? " ausgeblendet" : ""}"${titel}><td class="vorne">${vorne}</td><td class="datum">${datum}</td>
<td class="text">${postenText(p, namen)}${p.anzahl > 1 ? ` <small class="hinweis">(${p.anzahl})</small>` : ""}${tag}</td><td class="zahl ${art}">${glatt(p.betrag)}</td></tr>`;
};
const rest = posten.slice(sichtbar);
const probeText = probe.size && probeSumme !== summe(alle) ? ` <small class="probe-summe">(probeweise ${glatt(probeSumme)})</small>` : "";
return `<section class="karte liqui-liste"><h2>${art === "ein" ? "Kommt rein" : "Geht raus"} <span class="hinweis">· nächste ${ZEIT_KNOPF[zeitraum]}</span></h2>
${alle.length ? `<table class="liqui-posten"><tbody>${posten.slice(0, sichtbar).map(zeile).join("")}
${rest.length || (mehr[art] && posten.length > SICHTBAR) ? `<tr class="mehr"><td></td><td></td><td colspan="2"><button class="verweis" data-mehr="${art}" aria-expanded="${mehr[art]}">${mehr[art] ? "▴ weniger anzeigen" : `▾ ${rest.length} weitere anzeigen (${glatt(summe(rest))})`}</button></td></tr>` : ""}
${versteckt.length ? `<tr class="aus-hinweis"><td></td><td></td><td colspan="2">${versteckt.length} ${versteckt.length === 1 ? "Zeile" : "Zeilen"} ausgeblendet · <button class="verweis" data-zeige-aus="${art}">${zeigeAus[art] ? "wieder verbergen" : "einblenden"}</button>${zeigeAus[art] ? ` · <button class="verweis" data-alle-ein="${art}">alle wieder einblenden</button>` : ""} <span class="hinweis">(zählt weiter mit)</span></td></tr>` : ""}</tbody>
<tfoot><tr><td></td><td></td><td>Summe aller ${alle.length}${probeText}</td><td class="zahl ${art}">${glatt(summe(alle))}</td></tr></tfoot></table>`
: `<p class="hinweis">${art === "ein" ? "Im Zeitraum kommt nichts rein." : "Im Zeitraum geht nichts raus."}</p>`}</section>`;
}
/** 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 `<p class="hinweis liqui-plan-hinweis">${d.jahresplanVorschau
? `Ab ${MONATSNAMEN[Number(plan[0]!.datum.slice(5, 7)) - 1]} ${plan[0]!.datum.slice(0, 4)} rechnet die Liquidität mit dem <a href="#jahresplanung">Jahresplan</a>, soweit echte Zahlungen fehlen (Posten „Plan: …“). <button class="verweis" data-plan-vorschau="aus">Vorschau ausschalten</button>`
: `Die Vorschau aus dem Jahresplan ist ausgeschaltet. <button class="verweis" data-plan-vorschau="an">Einschalten</button>`}</p>`;
}
/** 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 = `<form class="liqui-grenze">
<label class="schalter"><input type="radio" name="art" value="auto"${fest ? "" : " checked"}> Automatisch: 1 Monat laufende Kosten <b>${glatt(d.laufendMonat)}</b>${d.laufendMonat ? "" : ' <span class="hinweis">(noch keine laufenden Kosten erfasst)</span>'}</label>
<label class="schalter"><input type="radio" name="art" value="fest"${fest ? " checked" : ""}> Fester Betrag <input name="betrag" inputmode="decimal" value="${d.festerBetrag ? euro(d.festerBetrag).replace(" €", "") : ""}" placeholder="z. B. 6.000" aria-label="Fester Betrag in Euro"> €</label>
<p class="hinweis">Später kommen die Töpfe dazu (Stufe 5), dann ist das Ziel 6 Monate laufende Kosten.</p>
<p class="fehler" id="l-grenze-fehler"></p>
<div class="knoepfe"><button type="button" class="neben" data-a="grenze-zu">Abbrechen</button><button class="haupt">Speichern</button></div></form>`;
const f = ziel.querySelector("form")!;
f.querySelector<HTMLInputElement>("[name=betrag]")!.onfocus = () => { f.querySelector<HTMLInputElement>("[value=fest]")!.checked = true; };
f.querySelector<HTMLButtonElement>("[data-a=grenze-zu]")!.onclick = (ev) => { ev.stopPropagation(); ziel.hidden = true; };
f.onsubmit = async (ev) => {
ev.preventDefault();
const art = (f.querySelector<HTMLInputElement>("[name=art]:checked")?.value ?? "auto") as "auto" | "fest";
let betrag = d.festerBetrag as number;
try {
if (art === "fest") betrag = parseEuro(f.querySelector<HTMLInputElement>("[name=betrag]")!.value);
if (betrag < 0) throw new Error("Bitte einen Betrag ab 0 € eingeben.");
const e = await api<Zeile>("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<void> {
const anzahl = raster === "monat" ? MONATE[zeitraum] : WOCHEN[zeitraum];
const [roh, projekte, einst] = await Promise.all([
api<Zeile[]>(`liquiditaet?ansicht=${raster}&anzahl=${anzahl}&start=${heute()}&offene=1`), api<Zeile[]>("projekte"), api<Zeile>("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 = `<div role="group" aria-label="Raster"><button class="${raster === "monat" ? "haupt" : "neben"}" data-raster="monat">Monate</button><button class="${raster === "woche" ? "haupt" : "neben"}" data-raster="woche">Wochen</button></div>
<button class="neben" data-a="alle">${alleOffen ? "Alle zuklappen" : "Alle Zahlungen aufklappen"}</button>`;
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) => `<tr class="posten${x.datum < h && !x.ueberfaelligSeit ? " vorbei" : ""}"><td>${x.ueberfaelligSeit ? `seit ${dat(x.ueberfaelligSeit)}` : dat(x.datum)}</td>
<td>${esc(x.bezeichnung)}${x.ueberfaelligSeit ? ` <span class="tag-ueber">${x.gestellt ? "überfällig" : "Rechnung fehlt"}</span>` : ""}<span class="unter">${esc(x.gruppe)}</span></td>
<td class="optional">${x.projekt ? `${esc(x.projekt)}${namen.get(x.projekt) ? ` ${esc(namen.get(x.projekt))}` : ""}` : ""}</td><td class="zahl ${x.betrag < 0 ? "aus" : "ein"}">${euro(x.betrag)}</td></tr>`;
const tab = document.createElement("table");
tab.className = "liqui-tabelle";
const spalten = ohne ? 6 : 5;
const zahlen = (p: Zeile) => {
if (!ohne) return `<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>`;
const f = flussVon(p), u = f.einnahmen - f.projektkosten - f.laufend - f.ust;
const z = (c: number, kl: string) => `<td class="zahl ${kl}">${c ? euro(c) : "–"}</td>`;
return `${z(f.einnahmen, "ein")}${z(-f.projektkosten, "aus")}${z(-f.laufend, "aus")}${z(-f.ust, "aus optional")}<td class="zahl"><b class="${u < 0 ? "fehler" : ""}">${euro(u)}</b></td>`;
};
tab.innerHTML = `<thead><tr><th>${raster === "woche" ? "Woche" : "Monat"}</th>${ohne
? '<th class="zahl">Einnahmen</th><th class="zahl">Projektkosten</th><th class="zahl">Laufende Kosten</th><th class="zahl optional">Umsatzsteuer</th><th class="zahl">Überschuss</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(zeitText(p))} <small class="hinweis">${posten.length} ${posten.length === 1 ? "Zahlung" : "Zahlungen"}</small></td>
${zahlen(p)}</tr>
${offen ? `<tr class="details"><td colspan="${spalten}">${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);
void liquiditaetSeite();
});
inhalt.append(kopf, tab);
}
async function alleZeigen(): Promise<void> {
const [perioden, projekte, einst] = await Promise.all([
api<Zeile[]>(`liquiditaet?ansicht=woche&anzahl=${WOCHEN[zeitraum]}&start=${heute()}&offene=1`), api<Zeile[]>("projekte"), api<Zeile>("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 ? ` <span class="tag-ueber">${x.gestellt ? "überfällig" : "Rechnung fehlt"}</span>` : ""}<span class="unter nur-schmal">${esc(x.gruppe)}</span>` },
{ 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) => `<span class="${x.betrag < 0 ? "aus" : "ein"}">${euro(x.betrag)}</span>`, sortWert: (x) => x.betrag, klasse: "zahl" },
...(ohne ? [] : [{ id: "stand", titel: "Kontostand danach", art: "zahl" as const, wert: (x: Zeile) => `<span class="${x.stand < 0 ? "fehler" : ""}">${euro(x.stand)}</span>`, sortWert: (x: Zeile) => x.stand, klasse: "zahl optional" }]),
],
zeilen: posten,
fuss: (l) => (l.length === posten.length ? "" : `<p>Summe der gezeigten Zahlungen: <strong>${euro(l.reduce((s, x) => s + x.betrag, 0))}</strong></p>`),
}));
}