0.20.0: Liquidität mit Lage, Kurve, Kommt rein / Geht raus und Mindestgrenze per Zahnrad

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
Claude
2026-10-21 16:46:54 +00:00
parent feb19241c5
commit 176b1db832
13 changed files with 562 additions and 126 deletions

46
src/domain/lage.ts Normal file
View File

@@ -0,0 +1,46 @@
// Liquidität auf einen Blick (Henning, 21.10.2026): frei verfügbar heute, Ampel und ein Satz, wann es am knappsten
// wird und warum. Die Mindestgrenze ist vorerst ein Monat laufende Kosten oder ein fester Betrag; Töpfe kommen in Stufe 5.
import { type Datum, plusMonate } from "./datum.js";
import type { Cent } from "./geld.js";
import type { LaufendeKosten, Periode, Posten } from "./liquiditaet.js";
export type Ampel = "gruen" | "gelb" | "rot";
export interface Lage {
/** Kontostand heute minus Mindestgrenze */
frei: Cent;
ampel: Ampel;
/** Woche mit dem niedrigsten Kontostand am Ende */
tief: { von: Datum; bis: Datum; kontostand: Cent } | null;
/** Abstand des Tiefpunkts zur Mindestgrenze, negativ = darunter */
abstand: Cent;
/** die größten Ausgaben bis zum Tiefpunkt */
grund: Posten[];
/** die nächste größere Einnahme nach dem Tiefpunkt */
danach: Posten | null;
}
/** Laufende Kosten eines Monats: monatliche voll, vierteljährliche ein Drittel, jährliche ein Zwölftel; nur was heute läuft */
export function laufendJeMonat(laufend: LaufendeKosten[], heute: Datum): Cent {
let summe = 0;
for (const k of laufend) {
if (k.rhythmus === "einmalig" || k.start > plusMonate(heute, 1) || (k.ende && k.ende < heute)) continue;
summe += k.rhythmus === "monatlich" ? k.betrag : k.rhythmus === "vierteljaehrlich" ? k.betrag / 3 : k.betrag / 12;
}
return Math.round(summe);
}
export function lage(wochen: Periode[], kontostand: Cent, mindestgrenze: Cent): Lage {
const frei = kontostand - mindestgrenze;
if (!wochen.length) return { frei, ampel: kontostand < 0 ? "rot" : kontostand < mindestgrenze ? "gelb" : "gruen", tief: null, abstand: frei, grund: [], danach: null };
let ti = 0;
wochen.forEach((w, i) => { if (w.kontostand < wochen[ti]!.kontostand) ti = i; });
const t = wochen[ti]!;
const tiefster = Math.min(kontostand, t.kontostand);
const ampel: Ampel = tiefster < 0 ? "rot" : tiefster < mindestgrenze ? "gelb" : "gruen";
const bisTief = wochen.slice(0, ti + 1).flatMap((w) => w.posten);
const grund = bisTief.filter((p) => p.betrag < 0).sort((a, b) => a.betrag - b.betrag).slice(0, 2);
const danach = wochen.slice(ti + 1, ti + 5).flatMap((w) => w.posten).filter((p) => p.betrag > 0).sort((a, b) => b.betrag - a.betrag)[0] ?? null;
return { frei, ampel, tief: { von: t.von, bis: t.bis, kontostand: t.kontostand }, abstand: t.kontostand - mindestgrenze, grund, danach };
}

View File

@@ -23,6 +23,10 @@ export interface Einnahme {
termin: Datum;
zahlungszielTage?: number;
bezahltAm?: Datum;
/** bezahlt, auch ohne Datum */
bezahlt?: boolean;
/** Rechnung gestellt (sonst nur geplant) */
gestellt?: boolean;
}
export interface Ausgabe {
@@ -63,6 +67,11 @@ export interface Vorschau {
startsaldo: Cent;
ziele?: Zahlungsziele;
ust?: UstEinstellungen;
/**
* Heute: offene Einnahmen, deren Zahltag schon vorbei ist, gelten als überfällig. Liegen sie vor dem
* ersten Zeitraum, kommen sie heute in die Rechnung (das Geld steht ja noch aus), höchstens ein Jahr zurück.
*/
offeneAb?: Datum;
}
export interface Posten {
@@ -72,6 +81,11 @@ export interface Posten {
bezeichnung: string;
/** positiv = Eingang, negativ = Ausgang */
betrag: Cent;
/** Einnahme: bezahlt bzw. Rechnung gestellt */
bezahlt?: boolean;
gestellt?: boolean;
/** Einnahme, die seit diesem Tag fällig und noch nicht bezahlt ist */
ueberfaelligSeit?: Datum;
}
export interface Periode {
@@ -137,7 +151,8 @@ export function bewegungen(d: Daten, v: Vorschau, bis: Datum): Posten[] {
for (const e of d.einnahmen) {
const steuer = ustAusNetto(e.netto, ust.satz);
const zahltag = e.bezahltAm ?? plusTage(e.termin, e.zahlungszielTage ?? ziele.kundenTage);
posten.push({ datum: zahltag, gruppe: "Projekteinnahmen", projekt: e.projekt, bezeichnung: e.bezeichnung, betrag: e.netto + steuer });
posten.push({ datum: zahltag, gruppe: "Projekteinnahmen", projekt: e.projekt, bezeichnung: e.bezeichnung, betrag: e.netto + steuer,
...(e.bezahltAm || e.bezahlt ? { bezahlt: true } : {}), ...(e.gestellt ? { gestellt: true } : {}) });
buche(zeitraumVon(ust.versteuerung === "ist" ? zahltag : e.termin, ust.voranmeldung), e.netto);
}
for (const a of d.ausgaben) {
@@ -217,6 +232,14 @@ export function liquiditaet(d: Daten, v: Vorschau): Periode[] {
const grenzen = periodenGrenzen(v);
if (grenzen.length === 0) return [];
const alle = bewegungen(d, v, grenzen[grenzen.length - 1]!.bis);
if (v.offeneAb) {
const heute = v.offeneAb, frueh = plusTage(heute, -365), erster = grenzen[0]!.von;
for (const p of alle) {
if (p.gruppe !== "Projekteinnahmen" || p.bezahlt || p.datum >= heute || p.datum < frueh) continue;
p.ueberfaelligSeit = p.datum;
if (p.datum < erster) p.datum = heute;
}
}
let kontostand = v.startsaldo;
return grenzen.map(({ von, bis }) => {
const posten = alle.filter((p) => p.datum >= von && p.datum <= bis).sort((a, b) => a.datum.localeCompare(b.datum));

View File

@@ -102,6 +102,8 @@ export function liquiditaetsDaten(b: Bestand, woche: Arbeitswoche, mitAngeboten
netto: z.netto,
termin: z.rechnungsdatum ?? (folgtVorgang(z) ? bezogen(z) : undefined) ?? z.termin,
bezahltAm: z.bezahlt_am ?? undefined,
bezahlt: z.status === "bezahlt",
gestellt: z.status === "gestellt" || !!z.rechnungsdatum,
zahlungszielTage: z.zahlungsziel_tage ?? undefined,
}));
const kosten: Ausgabe[] = b.kosten

View File

@@ -14,6 +14,7 @@ import { type Nextcloud, ordnerAbgleichen } from "./nextcloud.js";
import { NUR_SICHERUNG, TABELLEN } from "./tabellen.js";
import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js";
import { liquiditaet } from "../domain/liquiditaet.js";
import { laufendJeMonat, lage } from "../domain/lage.js";
import { liquiditaetsDaten } from "../domain/projektplan.js";
import { uebernimmV70 } from "../domain/v70.js";
import { speichereUebernahme } from "./v70import.js";
@@ -305,6 +306,8 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
ansicht: z.enum(["woche", "monat"]).default("woche"),
start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
anzahl: z.coerce.number().int().min(1).max(104).default(12),
// offene Einnahmen mit vergangenem Zahltag als überfällig markieren und heute einrechnen
offene: z.enum(["0", "1"]).optional(),
});
async function berechneLiquiditaet(q: z.infer<typeof LiquiAnfrage>) {
@@ -329,11 +332,32 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
{ tage: e.arbeitstage },
);
const start = q.start ?? new Date().toISOString().slice(0, 10);
return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust });
return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust,
offeneAb: q.offene === "1" ? start : undefined });
}
app.get("/api/liquiditaet", async (req) => berechneLiquiditaet(LiquiAnfrage.parse(req.query)));
// Lage der Liquidität (Henning, 21.10.2026): je Woche ab heute, frei verfügbar, Tiefpunkt und Grund
async function liquiLage(heute: string, anzahl: number) {
const e = await ladeEinstellungen();
const [wochen, laufend] = await Promise.all([
berechneLiquiditaet({ ansicht: "woche", start: heute, anzahl, offene: "1" }),
pool.query("select betrag, rhythmus, start, ende from laufende_kosten"),
]);
const laufendMonat = laufendJeMonat(laufend.rows.map((l) => ({ bezeichnung: "", betrag: Number(l.betrag), rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined })), heute);
const mindestgrenze = e.mindestgrenzeArt === "fest" ? e.mindestreserve : laufendMonat;
return {
heute, wochen, kontostand: e.startsaldo, kontostandDatum: e.startsaldoDatum,
mindestgrenze, mindestgrenzeArt: e.mindestgrenzeArt, festerBetrag: e.mindestreserve, laufendMonat,
lage: lage(wochen, e.startsaldo, mindestgrenze),
};
}
app.get("/api/liquiditaet/lage", async (req) => {
const q = z.object({ heute: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(), wochen: z.coerce.number().int().min(1).max(26).default(13) }).parse(req.query);
return liquiLage(q.heute ?? new Date().toISOString().slice(0, 10), q.wochen);
});
// Startseite: Aufgaben, Warnungen, wer macht was in den nächsten zwei Wochen, Liquidität 4 Wochen
app.get("/api/uebersicht", async (req) => {
const heute = z.object({ heute: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional() }).parse(req.query).heute ?? new Date().toISOString().slice(0, 10);
@@ -345,10 +369,10 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
from aufgabe a left join projekt p on p.id = a.projekt_id left join kontakt k on k.id = a.kontakt_id
left join aufgabe_kategorie g on g.id = a.kategorie_id
where a.erledigt_am is null order by a.faellig_am nulls last, a.angelegt_am`),
berechneLiquiditaet({ ansicht: "woche", start: heute, anzahl: 4 }),
liquiLage(heute, 4),
]);
const u = uebersicht({ heute, woche, tp, aufgaben: aufgaben.rows, liqui, mindestreserve: e.mindestreserve,
kontostandErfasst: e.startsaldo !== 0 || e.startsaldoDatum !== null });
const u = { ...uebersicht({ heute, woche, tp, aufgaben: aufgaben.rows, liqui: liqui.wochen, mindestreserve: liqui.mindestgrenze,
kontostandErfasst: e.startsaldo !== 0 || e.startsaldoDatum !== null }), liquiLage: { ...liqui, wochen: undefined } };
// M10: offene Urlaubsanträge oben in den Warnungen, damit kein Mitarbeiter auf Antwort wartet
const antraege = await pool.query(`select a.von, a.bis, a.kontakt_id, k.name from abwesenheit a join kontakt k on k.id = a.kontakt_id
where a.art = 'urlaub' and a.status = 'beantragt' order by a.von`);

View File

@@ -45,6 +45,8 @@ export const EinstellungenSchema = z.object({
startsaldo: z.number().int().default(0),
startsaldoDatum: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().default(null),
mindestreserve: z.number().int().default(0),
// Mindestgrenze der Liquidität (Henning, 21.10.2026): automatisch ein Monat laufende Kosten oder fest der Betrag oben
mindestgrenzeArt: z.enum(["auto", "fest"]).default("auto"),
// M3: immer voll abziehen (6:10 → 5:40, Henning 20.10.2026) oder knapp über einer Grenze nur bis zur Grenze (6:10 → 6:00)
pausenabzug: z.enum(["bis_grenze", "voll"]).default("voll"),
// geheimer Teil der Kalender-Links (T11); Outlook classic kann sich nicht anmelden

View File

@@ -59,7 +59,7 @@ export function uebersicht({ heute, woche, tp, aufgaben, liqui, mindestreserve,
warnungen.push({ art: "kontostand", ziel: "daten", text: "Aktueller Kontostand ist noch nicht eingetragen, die Liquidität rechnet ab 0 €" });
} else if (knapp) {
warnungen.push({ art: "kontostand", ziel: "liquiditaet",
text: `Kontostand in der Woche ab ${formatDatum(knapp.von)} bei ${formatEuro(knapp.kontostand)}${mindestreserve ? `, unter der Mindestreserve von ${formatEuro(mindestreserve)}` : ""}` });
text: `Kontostand in der Woche ab ${formatDatum(knapp.von)} bei ${formatEuro(knapp.kontostand)}${mindestreserve ? `, unter deiner Mindestgrenze von ${formatEuro(mindestreserve)}` : ""}` });
}
const tage = naechsteArbeitstage(heute, 8, woche);

View File

@@ -15,6 +15,7 @@ import { meineStunden, stundenSeite } from "./stunden.js";
import { angebotSeite, angeboteHtml, angeboteSeite, mengenblattSeite, neuesAngebot } from "./angebote.js";
import { vorlageSeite } from "./mengenblatt.js";
import { leistungSeite, stammdatenSeite } from "./stammdaten.js";
import { lageKopfHtml, liquiditaetSeite } from "./liquiditaet.js";
// ---------- Reiter ----------
@@ -526,111 +527,6 @@ async function terminplan(): Promise<void> {
ansicht: { lies: gespeicherteAnsicht, setze: ansichtMerken }, auge: [AUGE, AUGE_ZU] });
}
// Liquidität (Henning, 20.10.2026): oben die Lage in Zahlen und als Kontostandverlauf, darunter je Woche
// oder Monat jede einzelne Zahlung mit Datum, Projekt und Betrag zum Aufklappen
let liquiOffen = new Set<string>();
async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {
const leiste = seite("Liquidität");
leiste.innerHTML = `<select id="l-ansicht" aria-label="Zeitraster"><option value="woche">Wochen</option><option value="monat">Monate</option><option value="liste">Einzelne Zahlungen</option></select>
<select id="l-anzahl" aria-label="Anzahl">${[4, 8, 12, 26, 52].map((n) => `<option>${n}</option>`).join("")}</select>
${ansicht === "liste" ? "" : '<button class="neben" id="l-alle">Alle Zahlungen aufklappen</button>'}`;
const a = leiste.querySelector("#l-ansicht") as HTMLSelectElement;
const n = leiste.querySelector("#l-anzahl") as HTMLSelectElement;
a.value = ansicht;
n.value = String(anzahl);
a.onchange = n.onchange = () => liquiditaetSeite(a.value, Number(n.value));
// „Einzelne Zahlungen“: dieselben Wochen, aber jede Zahlung als Zeile zum Sortieren und Filtern
const einzeln = ansicht === "liste";
if (einzeln) ansicht = "woche";
const [perioden, projekte, einst] = await Promise.all([
api<Zeile[]>(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`), api<Zeile[]>("projekte"), api<Zeile>("einstellungen"),
]);
const projektName = new Map(projekte.map((p) => [p.nummer, p.bezeichnung]));
const zeitraum = (p: Zeile) => (ansicht === "woche" ? `KW ${kalenderwoche(p.von)} · ${dat(p.von).slice(0, 6)} – ${dat(p.bis).slice(0, 6)}` : `${MONATSNAMEN[Number(p.von.slice(5, 7)) - 1]} ${p.von.slice(0, 4)}`);
// Kennzahlen
const tief = perioden.reduce((m, p) => (p.kontostand < m.kontostand ? p : m), perioden[0] ?? { kontostand: 0 });
const summeEin = perioden.reduce((s, p) => s + p.einnahmen, 0), summeAus = perioden.reduce((s, p) => s + p.ausgaben, 0);
const ende = perioden.at(-1);
const kachel = (titel: string, wert: string, unter: string, rot = false) =>
`<div class="kachel liqui-zahl"><h3>${esc(titel)}</h3><p class="gross${rot ? " fehler" : ""}">${wert}</p><p class="hinweis">${unter}</p></div>`;
const startsaldo = Number(einst.startsaldo ?? 0);
inhalt.insertAdjacentHTML("beforeend", `<div class="kacheln liqui-kacheln">
${kachel("Kontostand", euro(startsaldo), einst.startsaldoDatum ? `eingetragen am ${dat(einst.startsaldoDatum)} · <a href="#daten">ändern</a>` : '<a href="#daten">unter Daten eintragen</a>')}
${kachel("Tiefster Stand", tief ? euro(tief.kontostand) : "–", tief ? esc(zeitraum(tief)) : "", (tief?.kontostand ?? 0) < 0)}
${kachel("Einnahmen / Ausgaben", `<span class="ein">${euro(summeEin)}</span><br>${euro(summeAus)}`, `im angezeigten Zeitraum, Saldo ${euro(summeEin + summeAus)}`)}
${kachel(`Stand am ${ende ? dat(ende.bis) : ""}`, ende ? euro(ende.kontostand) : "–", "Ende des angezeigten Zeitraums", (ende?.kontostand ?? 0) < 0)}
</div>`);
// Verlauf: Kontostand je Zeitraum als Säulen, unter null rot
if (perioden.length) {
const werte = perioden.map((p) => p.kontostand as number);
const hoch = Math.max(0, ...werte), tiefst = Math.min(0, ...werte), spanne = hoch - tiefst || 1;
const nullAb = (hoch / spanne) * 100;
const jede = Math.ceil(perioden.length / 13);
inhalt.insertAdjacentHTML("beforeend", `<section class="karte liqui-verlauf"><h2>Kontostand am Ende ${ansicht === "woche" ? "der Woche" : "des Monats"}</h2>
<div class="saeulen" style="--null:${nullAb}%">${perioden.map((p, i) => {
const v = p.kontostand as number, h = (Math.abs(v) / spanne) * 100;
return `<div class="saeule" title="${esc(zeitraum(p))}: ${euro(v)}"><div class="flaeche"><i class="${v < 0 ? "minus" : "plus"}" style="height:${h}%"></i></div>
<small>${i % jede === 0 ? (ansicht === "woche" ? `KW ${kalenderwoche(p.von)}` : MONATSNAMEN[Number(p.von.slice(5, 7)) - 1]!.slice(0, 3)) : ""}</small></div>`;
}).join("")}</div></section>`);
}
const heuteD = heute();
if (einzeln) {
// Kontostand nach jeder Zahlung, in zeitlicher Reihenfolge gerechnet; bleibt beim Umsortieren an der Zahlung
let stand = perioden.length ? perioden[0]!.kontostand - perioden[0]!.saldo : startsaldo;
const posten = perioden.flatMap((p) => p.posten as Zeile[])
.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.datum < heuteD ? "vorbei" : ""),
spalten: [
{ id: "datum", titel: "Fällig am", art: "datum", wert: (x) => dat(x.datum), sortWert: (x) => x.datum },
{ id: "was", titel: "Was", text: (x) => x.bezeichnung, wert: (x) => `${esc(x.bezeichnung)}<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)}${projektName.get(x.projekt) ? ` ${esc(projektName.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" },
{ id: "stand", titel: "Kontostand danach", art: "zahl", wert: (x) => `<span class="${x.stand < 0 ? "fehler" : ""}">${euro(x.stand)}</span>`, sortWert: (x) => 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>`),
}));
return;
}
// Tabelle: je Zeitraum eine Zeile, aufgeklappt jede Zahlung mit Datum
const zeile = (x: Zeile) => {
const projekt = x.projekt ? `${esc(x.projekt)}${projektName.get(x.projekt) ? ` ${esc(projektName.get(x.projekt))}` : ""}` : "";
return `<tr class="posten${x.datum < heuteD ? " vorbei" : ""}"><td>${dat(x.datum)}</td><td>${esc(x.bezeichnung)}<span class="unter">${esc(x.gruppe)}</span></td>
<td class="optional">${projekt}</td><td class="zahl ${x.betrag < 0 ? "aus" : "ein"}">${euro(x.betrag)}</td></tr>`;
};
const tab = document.createElement("table");
tab.className = "liqui-tabelle";
tab.innerHTML = `<thead><tr><th>${ansicht === "woche" ? "Woche" : "Monat"}</th><th class="zahl">Einnahmen</th><th class="zahl">Ausgaben</th><th class="zahl optional">Saldo</th><th class="zahl">Kontostand</th></tr></thead>
${perioden.map((p) => {
const offen = liquiOffen.has(p.von);
const posten = [...p.posten].sort((x: Zeile, y: Zeile) => (x.datum < y.datum ? -1 : x.datum > y.datum ? 1 : x.betrag - y.betrag));
return `<tbody><tr class="klickbar periode${offen ? " offen" : ""}" data-von="${p.von}"><td><span class="pfeil">${offen ? "▾" : "▸"}</span> ${esc(zeitraum(p))} <small class="hinweis">${posten.length} ${posten.length === 1 ? "Zahlung" : "Zahlungen"}</small></td>
<td class="zahl ein">${p.einnahmen ? euro(p.einnahmen) : "–"}</td><td class="zahl aus">${p.ausgaben ? euro(p.ausgaben) : "–"}</td><td class="zahl optional">${euro(p.saldo)}</td>
<td class="zahl"><b class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</b></td></tr>
${offen ? `<tr class="details"><td colspan="5">${posten.length ? `<table class="posten-tabelle"><thead><tr><th>Fällig am</th><th>Was</th><th class="optional">Projekt</th><th class="zahl">Betrag</th></tr></thead><tbody>${posten.map(zeile).join("")}</tbody></table>` : '<p class="hinweis">Keine Zahlungen in diesem Zeitraum.</p>'}</td></tr>` : ""}</tbody>`;
}).join("")}`;
tab.addEventListener("click", (ev) => {
const tr = (ev.target as HTMLElement).closest<HTMLElement>("tr.periode");
if (!tr) return;
const von = tr.dataset.von!;
liquiOffen.has(von) ? liquiOffen.delete(von) : liquiOffen.add(von);
liquiditaetSeite(ansicht, anzahl);
});
const alleOffen = perioden.every((p) => liquiOffen.has(p.von));
const alleKnopf = leiste.querySelector<HTMLButtonElement>("#l-alle")!;
alleKnopf.textContent = alleOffen ? "Alle zuklappen" : "Alle Zahlungen aufklappen";
alleKnopf.onclick = () => { liquiOffen = alleOffen ? new Set() : new Set(perioden.map((p) => p.von)); liquiditaetSeite(ansicht, anzahl); };
inhalt.append(tab);
}
const RHYTHMEN: [string, string][] = [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"], ["jaehrlich", "jährlich"], ["einmalig", "einmalig"]];
const LK_FELDER: Feld[] = [
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "kategorie", titel: "Kategorie" },
@@ -813,6 +709,7 @@ async function uebersicht(): Promise<void> {
: '<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>
${u.liquiLage ? lageKopfHtml(u.liquiLage, "4 Wochen") : ""}
<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);

311
src/web/liquiditaet.ts Normal file
View File

@@ -0,0 +1,311 @@
// 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 { liste } from "./liste.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))}` : ""}` : ""}`;
/** 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>`;
}
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]));
const wochen = d.wochen as Zeile[];
const bereich = document.createElement("div");
bereich.className = "liqui-seite";
inhalt.append(bereich);
const zeichne = () => {
bereich.innerHTML = lageKopfHtml(d, ZEIT_TEXT[zeitraum])
+ `<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)}</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></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>
${wocheHtml(wochen.find((w) => w.von === gewaehlt), namen)}</section>
<div class="liqui-zwei">${listeHtml("ein", wochen, namen)}${listeHtml("aus", wochen, namen)}</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(); }
if (t.closest("[data-a=woche-zu]")) { gewaehlt = null; return zeichne(); }
if (t.closest("[data-a=grenze]")) grenzeBearbeiten(bereich.querySelector<HTMLElement>("#l-grenze")!, d);
};
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(); }
};
}
/** Liniendiagramm je Woche: Kontostand als Fläche, Einnahmen und Ausgaben je Woche, Mindestgrenze, tiefster Punkt */
function kurveSvg(d: Zeile, platz: number): 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;
const roh = { min: Math.min(0, ...stand), max: Math.max(1, mg, ...stand, ...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}"/>
${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>): 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 · Kontostand danach ${glatt(w.kontostand)}</td><td class="zahl">${glatt(w.saldo)}</td></tr></tfoot></table>`
: '<p class="hinweis">In dieser Woche ist keine Zahlung geplant.</p>'}</div>`;
}
/** „Kommt rein“ oder „Geht raus“: Überfälliges oben, dann nach Datum; laufende Kosten je Monat in einer Zeile */
function listeHtml(art: "ein" | "aus", wochen: Zeile[], namen: Map<string, string>): string {
const h = heute();
let posten = wochen.flatMap((w) => w.posten as Zeile[]).filter((p) => (art === "ein" ? p.betrag > 0 : p.betrag < 0) && !(p.bezahlt && p.datum < h));
if (art === "aus") {
const lk = new Map<string, Zeile>();
const rest: Zeile[] = [];
for (const p of posten) {
if (p.gruppe !== "Laufende Kosten") { rest.push(p); continue; }
const m = p.datum.slice(0, 7);
const z = lk.get(m);
if (z) { z.betrag += p.betrag; z.anzahl++; z.einzeln.push(p.bezeichnung); } else lk.set(m, { ...p, anzahl: 1, einzeln: [p.bezeichnung], bezeichnung: `Laufende Kosten ${MONATSNAMEN[Number(m.slice(5, 7)) - 1]}` });
}
posten = [...rest, ...lk.values()];
}
posten.sort((a, b) => (a.ueberfaelligSeit ? 0 : 1) - (b.ueberfaelligSeit ? 0 : 1) || (a.ueberfaelligSeit ?? a.datum).localeCompare(b.ueberfaelligSeit ?? b.datum) || a.betrag - b.betrag);
const ueber = posten.filter((p) => p.ueberfaelligSeit).length;
const sichtbar = mehr[art] ? posten.length : Math.max(SICHTBAR, ueber);
const summe = (l: Zeile[]) => l.reduce((s, p) => s + p.betrag, 0);
const zeile = (p: Zeile) => {
const seit = p.ueberfaelligSeit as string | undefined;
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(", "))}"` : "";
return `<tr class="${seit ? "ueber" : ""}"${titel}><td class="datum">${seit ? `seit ${dat(seit).slice(0, 6)}` : dat(p.datum).slice(0, 6)}</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);
return `<section class="karte liqui-liste"><h2>${art === "ein" ? "Kommt rein" : "Geht raus"} <span class="hinweis">· nächste ${ZEIT_KNOPF[zeitraum]}</span></h2>
${posten.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 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>` : ""}</tbody>
<tfoot><tr><td></td><td>Summe aller ${posten.length}</td><td class="zahl ${art}">${glatt(summe(posten))}</td></tr></tfoot></table>`
: `<p class="hinweis">${art === "ein" ? "Im Zeitraum kommt nichts rein." : "Im Zeitraum geht nichts raus."}</p>`}</section>`;
}
/** 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 [perioden, projekte] = await Promise.all([
api<Zeile[]>(`liquiditaet?ansicht=${raster}&anzahl=${anzahl}&start=${heute()}&offene=1`), api<Zeile[]>("projekte"),
]);
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";
tab.innerHTML = `<thead><tr><th>${raster === "woche" ? "Woche" : "Monat"}</th><th class="zahl">Einnahmen</th><th class="zahl">Ausgaben</th><th class="zahl optional">Saldo</th><th class="zahl">Kontostand</th></tr></thead>
${perioden.map((p) => {
const offen = liquiOffen.has(p.von);
const posten = [...p.posten].sort((x: Zeile, y: Zeile) => (x.datum < y.datum ? -1 : x.datum > y.datum ? 1 : x.betrag - y.betrag));
return `<tbody><tr class="klickbar periode${offen ? " offen" : ""}" data-von="${p.von}"><td><span class="pfeil">${offen ? "▾" : "▸"}</span> ${esc(zeitText(p))} <small class="hinweis">${posten.length} ${posten.length === 1 ? "Zahlung" : "Zahlungen"}</small></td>
<td class="zahl ein">${p.einnahmen ? euro(p.einnahmen) : "–"}</td><td class="zahl aus">${p.ausgaben ? euro(p.ausgaben) : "–"}</td><td class="zahl optional">${euro(p.saldo)}</td>
<td class="zahl"><b class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</b></td></tr>
${offen ? `<tr class="details"><td colspan="5">${posten.length ? `<table class="posten-tabelle"><thead><tr><th>Fällig am</th><th>Was</th><th class="optional">Projekt</th><th class="zahl">Betrag</th></tr></thead><tbody>${posten.map(zeile).join("")}</tbody></table>` : '<p class="hinweis">Keine Zahlungen in diesem Zeitraum.</p>'}</td></tr>` : ""}</tbody>`;
}).join("")}`;
tab.addEventListener("click", (ev) => {
const tr = (ev.target as HTMLElement).closest<HTMLElement>("tr.periode");
if (!tr) return;
const von = tr.dataset.von!;
liquiOffen.has(von) ? liquiOffen.delete(von) : liquiOffen.add(von);
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();
// 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[])
.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" },
{ id: "stand", titel: "Kontostand danach", art: "zahl", wert: (x) => `<span class="${x.stand < 0 ? "fehler" : ""}">${euro(x.stand)}</span>`, sortWert: (x) => 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>`),
}));
}

View File

@@ -338,20 +338,91 @@ dl.werte dd { margin: 0; text-align: right; font-variant-numeric: tabular-nums;
.vorschlag { display: grid; gap: 10px; justify-items: start; padding: 4px 0 8px; }
.vorschlag p { margin: 0; max-width: 65ch; color: var(--leise); }
/* Liquidität: Kennzahlen, Verlauf, Zahlungen je Zeitraum mit Datum (Henning, 20.10.2026) */
.liqui-kacheln { grid-template-columns: repeat(auto-fill, minmax(220px, 1fr)); }
.liqui-zahl .gross { font-size: 20px; font-weight: 600; font-variant-numeric: tabular-nums; }
.liqui-zahl .gross small { color: var(--leise); font-weight: 400; }
.liqui-verlauf { margin-bottom: 16px; }
.liqui-verlauf h2 { font-size: 14px; margin: 0 0 8px; color: var(--leise); font-weight: 600; }
.saeulen { display: flex; gap: 6px; height: 170px; align-items: stretch; }
.saeule { flex: 1; min-width: 0; display: grid; grid-template-rows: 1fr auto; gap: 4px; }
.saeule .flaeche { position: relative; border-bottom: 0; background: linear-gradient(var(--leise), var(--leise)) 0 var(--null) / 100% 1px no-repeat; }
.saeule i { position: absolute; left: 12%; right: 12%; border-radius: 3px; }
.saeule i.plus { bottom: calc(100% - var(--null)); background: var(--akzent); opacity: 0.8; }
.saeule i.minus { top: var(--null); background: var(--warn); opacity: 0.85; }
.saeule small { text-align: center; font-size: 11px; color: var(--leise); white-space: nowrap; overflow: hidden; }
.liqui-zahl .ein { color: var(--ein); }
/* Liquidität (Henning, 21.10.2026): Reiter Lage / Monatsplan / Alle Zahlungen, Zeitraum 4 Wochen bis 3 Monate */
.liqui-leiste .hinweis { margin-left: 0; }
.liqui-zeit { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; }
.chip-knopf { padding: 5px 12px; border: 1px solid var(--linie); border-radius: 99px; background: var(--fl); color: var(--text); font: inherit; font-size: 14px; cursor: pointer; }
.chip-knopf.an { background: var(--akzent-hell); border-color: var(--akzent); color: var(--akzent); font-weight: 600; }
.liqui-reiter { display: flex; gap: 6px; margin-left: auto; flex-wrap: wrap; }
.liqui-seite { display: grid; gap: 14px; }
.liqui-lage { display: grid; grid-template-columns: minmax(200px, auto) 1fr; gap: 10px 28px; align-items: center; border-left: 6px solid var(--gut-text); }
.liqui-lage.gelb { border-left-color: var(--eingabe-linie); }
.liqui-lage.rot { border-left-color: var(--warn); }
.karte .karte.liqui-lage { border-top: 0; border-right: 0; border-bottom: 0; border-radius: 0; padding: 4px 0 4px 14px; margin-bottom: 12px; }
.liqui-frei { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
.liqui-frei .gross { font-size: 30px; font-weight: 700; font-variant-numeric: tabular-nums; line-height: 1.15; }
.liqui-frei .hinweis { font-size: 13px; }
.liqui-satz { min-width: 0; }
.liqui-satz p { margin: 6px 0 0; font-size: 15px; text-wrap: pretty; }
.liqui-satz p.hinweis { font-size: 14px; }
.ampel-chip { display: inline-block; padding: 3px 10px; border-radius: 99px; font-size: 12px; font-weight: 600; background: var(--gut-bg); color: var(--gut-text); }
.ampel-chip.gelb { background: var(--eingabe-bg); color: var(--eingabe-text); }
.ampel-chip.rot { background: var(--warnung-bg); color: var(--warnung-text); }
.liqui-kurve h2, .liqui-liste h2 { font-size: 15px; margin: 0; }
.liqui-kurve .zahnrad { white-space: nowrap; }
.kurve-huelle { overflow-x: auto; }
.liqui-svg { display: block; width: 100%; height: auto; overflow: visible; }
.liqui-svg .gitter { stroke: var(--linie); stroke-width: 1; vector-effect: non-scaling-stroke; }
.liqui-svg .gitter.null { stroke: var(--leise); }
.liqui-svg text { font-size: 11px; fill: var(--leise); }
.liqui-svg .grenz-flaeche { fill: var(--warnung-bg); opacity: 0.7; }
.liqui-svg .grenze { stroke: var(--warn); stroke-width: 1.5; stroke-dasharray: 6 4; vector-effect: non-scaling-stroke; }
.liqui-svg .grenz-text { fill: var(--warn); }
.liqui-svg .stand-flaeche { fill: var(--akzent); opacity: 0.08; }
.liqui-svg .stand-linie { fill: none; stroke: var(--akzent); stroke-width: 3; vector-effect: non-scaling-stroke; stroke-linejoin: round; }
.liqui-svg .ein-linie { fill: none; stroke: var(--gut-text); stroke-width: 2; vector-effect: non-scaling-stroke; stroke-linejoin: round; }
.liqui-svg .aus-linie { fill: none; stroke: var(--warn); stroke-width: 2; stroke-dasharray: 6 3; vector-effect: non-scaling-stroke; stroke-linejoin: round; }
.liqui-svg .stand-punkt { fill: var(--fl); stroke: var(--akzent); stroke-width: 2; vector-effect: non-scaling-stroke; }
.liqui-svg .stand-punkt.an { fill: var(--akzent); }
.liqui-svg .heute-punkt { fill: var(--akzent); }
.liqui-svg .heute-text { fill: var(--akzent); font-weight: 700; }
.liqui-svg .tief-punkt { fill: var(--fl); stroke: var(--holz); stroke-width: 3; vector-effect: non-scaling-stroke; }
.liqui-svg .tief-text { fill: var(--holz); font-weight: 700; }
.liqui-svg .woche-ziel { fill: transparent; cursor: pointer; }
.liqui-svg .woche-ziel:hover, .liqui-svg .woche-ziel.an { fill: var(--akzent); fill-opacity: 0.07; }
.liqui-svg .woche-ziel:focus-visible { outline: none; fill: var(--akzent); fill-opacity: 0.12; }
.kurve-legende { display: flex; flex-wrap: wrap; gap: 6px 16px; font-size: 12px; color: var(--leise); margin-top: 4px; }
.kurve-legende i { display: inline-block; width: 18px; height: 0; border-top: 3px solid; vertical-align: middle; margin-right: 5px; }
.kurve-legende .k-stand { border-color: var(--akzent); }
.kurve-legende .k-ein { border-color: var(--gut-text); }
.kurve-legende .k-aus { border-color: var(--warn); border-top-style: dashed; }
.kurve-legende .k-grenze { border-color: var(--warn); border-top-width: 2px; border-top-style: dotted; }
.liqui-kurve > .hinweis { margin: 4px 0 0; font-size: 12px; }
.liqui-woche { margin-top: 10px; padding: 10px 12px; background: var(--bg); border-radius: 8px; }
.liqui-woche h3 { font-size: 14px; margin: 0; }
.liqui-grenze { display: grid; gap: 8px; padding: 10px 12px; margin-bottom: 8px; background: var(--bg); border-radius: 8px; }
.liqui-grenze .schalter { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; }
.liqui-grenze input[name=betrag] { width: 110px; padding: 6px 8px; border: 1px solid var(--linie); border-radius: 6px; background: var(--fl); color: var(--text); font: inherit; }
.liqui-grenze .knoepfe { display: flex; gap: 8px; justify-content: flex-end; }
.liqui-grenze p { margin: 0; }
.liqui-zwei { display: grid; grid-template-columns: 1fr 1fr; gap: 14px; }
.liqui-posten { width: 100%; border-collapse: collapse; margin-top: 6px; table-layout: fixed; }
.liqui-posten td { padding: 7px 4px; border-top: 1px solid var(--linie); font-size: 14px; vertical-align: top; }
.liqui-posten td.datum, .liqui-posten td:first-child { width: 86px; white-space: nowrap; color: var(--leise); }
.liqui-posten td.text { overflow-wrap: break-word; }
.liqui-posten td.zahl { width: 112px; text-align: right; white-space: nowrap; font-variant-numeric: tabular-nums; font-weight: 600; }
.liqui-posten .ein { color: var(--gut-text); }
.liqui-posten .aus { color: var(--warn); }
.liqui-posten tr.ueber td { background: var(--warnung-bg); }
.liqui-posten tr.ueber td.datum { color: var(--warnung-text); }
.liqui-posten tr.mehr td { border-top: 1px dashed var(--linie); }
.liqui-posten tr.mehr button { text-decoration: none; font-weight: 600; }
.liqui-posten tfoot td { border-top: 2px solid var(--linie); font-weight: 700; }
.tag-ueber { display: inline-block; font-size: 11px; font-weight: 600; padding: 1px 6px; border-radius: 4px; background: var(--warnung-bg); color: var(--warn); white-space: nowrap; }
tr.ueber .tag-ueber { background: var(--fl); }
.liqui-plan-kopf { display: flex; gap: 8px; justify-content: space-between; flex-wrap: wrap; margin-bottom: 10px; }
.liqui-plan-kopf > div { display: flex; gap: 6px; }
@media (max-width: 900px) {
.liqui-lage { grid-template-columns: 1fr; }
.liqui-zwei { grid-template-columns: 1fr; }
.liqui-reiter { margin-left: 0; }
}
@media (max-width: 500px) {
.liqui-posten td.datum, .liqui-posten td:first-child { width: 62px; font-size: 13px; white-space: normal; }
.liqui-posten td.zahl { width: 84px; }
.liqui-posten td { padding-inline: 2px; }
.liqui-frei .gross { font-size: 26px; }
}
.liqui-tabelle td.ein { color: var(--ein); }
.liqui-tabelle .periode td:first-child { white-space: nowrap; }
.liqui-tabelle .pfeil { display: inline-block; width: 14px; color: var(--leise); }