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

View File

@@ -2,6 +2,14 @@
Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen.
## 0.20.0
- Liquidität neu (Henning, 21.10.2026, Entwurf aus dem Liquiditäts-Thread): drei Reiter Lage, Monatsplan und Alle Zahlungen; Zeitraum 4 Wochen, 6 Wochen oder 3 Monate gilt für alle drei.
- Lage: oben „Frei verfügbar heute“ (Kontostand minus Mindestgrenze) mit Ampel und einem Satz, in welcher Woche es am knappsten wird, wie weit über oder unter der Mindestgrenze, und warum (die größten Ausgaben davor, die nächste große Einnahme danach). Darunter die Kurve je Woche: Kontostand, Einnahmen, Ausgaben, Mindestgrenze und tiefster Punkt; eine Woche anklicken zeigt ihre Zahlungen. Unten „Kommt rein“ und „Geht raus“: Überfälliges rot oben, dann nach Datum, die ersten vier sichtbar, der Rest aufklappbar, laufende Kosten je Monat in einer Zeile.
- Mindestgrenze über das Zahnrad an der Kurve: automatisch ein Monat laufende Kosten oder ein fester Betrag.
- Offene Einnahmen, deren Zahltag vorbei ist, gelten als überfällig („x Tage überfällig“, ohne gestellte Rechnung „Rechnung fehlt“) und werden heute eingerechnet, statt aus der Vorschau zu fallen.
- Startseite: der Liquiditätsblock zeigt dieselbe Lage für 4 Wochen.
## 0.19.0
- Terminplan: einzelne Freitage je Vorgang freigeben (Henning, 21.10.2026). Klick in „% erl.“ oder Rechtsklick auf den Balken, unter „Freitag arbeiten“ die Freitage im Zeitraum anhaken. Nur für diesen Vorgang zählt der Freitag als Arbeitstag: Dauer, Ende, Nachfolger, Auslastung, Kalender-Abo, „Wer macht was“ und die Einsätze am Handy. Für alle anderen bleibt der Freitag Reserve. Im Balken ist der freigegebene Freitag grün umrandet.

View File

@@ -1,6 +1,6 @@
{
"name": "betrieb",
"version": "0.19.0",
"version": "0.20.0",
"private": true,
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
"type": "module",

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); }

View File

@@ -161,6 +161,21 @@ describe.skipIf(!url)("Übernahme aus V70 über die API", () => {
expect(erwartet.some((p) => p.einnahmen > 0)).toBe(true);
});
it("Liquidität Lage: Mindestgrenze automatisch oder fest (Zahnrad)", async () => {
const l = (await app.inject("/api/liquiditaet/lage?wochen=6&heute=2026-10-21")).json();
expect(l.wochen).toHaveLength(6);
expect(l.mindestgrenzeArt).toBe("auto");
expect(l.mindestgrenze).toBe(l.laufendMonat);
expect(l.lage.frei).toBe(l.kontostand - l.mindestgrenze);
const e = (await app.inject("/api/einstellungen")).json();
const r = await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, mindestgrenzeArt: "fest", mindestreserve: 600_000 } });
expect(r.statusCode, r.body).toBe(200);
const l2 = (await app.inject("/api/liquiditaet/lage?wochen=6&heute=2026-10-21")).json();
expect(l2.mindestgrenze).toBe(600_000);
expect(l2.lage.frei).toBe(l2.kontostand - 600_000);
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: e });
});
it("Terminplan: Verknüpfungen eingehalten, V70-Nummern bleiben", async () => {
const t = (await app.inject("/api/terminplan")).json();
expect(t.vorgaenge).toHaveLength(13);

View File

@@ -1,6 +1,7 @@
import { describe, it, expect } from "vitest";
import { liquiditaet, periodenGrenzen, termineLaufend, projektBewegungen, type ProjektPlan } from "../src/domain/liquiditaet.js";
import { faelligkeit, zeitraumVon } from "../src/domain/umsatzsteuer.js";
import { lage, laufendJeMonat } from "../src/domain/lage.js";
describe("Umsatzsteuer-Fälligkeit", () => {
it("10. des Folgemonats, Wochenende verschiebt auf Montag", () => {
@@ -138,3 +139,39 @@ describe("Projekt nach V70-Regeln", () => {
expect(projektBewegungen({ ...plan, zeitraum: undefined })).toEqual({ einnahmen: plan.zahlungen, ausgaben: plan.kosten });
});
});
describe("Lage der Liquidität (Henning, 21.10.2026)", () => {
const daten = {
einnahmen: [
{ projekt: "P-26-014", bezeichnung: "1. Rate", netto: 1_000_000, termin: "2026-09-20", zahlungszielTage: 14, gestellt: true },
{ projekt: "P-26-014", bezeichnung: "alte Rate", netto: 500_000, termin: "2026-09-01", zahlungszielTage: 14, bezahlt: true },
{ projekt: "P-26-014", bezeichnung: "2. Rate", netto: 2_000_000, termin: "2026-11-16", zahlungszielTage: 14 },
],
ausgaben: [{ projekt: "P-26-014", bezeichnung: "Holz", art: "material" as const, netto: 1_200_000, termin: "2026-10-26", zahlungszielTage: 7 }],
laufend: [
{ bezeichnung: "Miete", betrag: 300_000, rhythmus: "monatlich" as const, start: "2026-01-01" },
{ bezeichnung: "Versicherung", betrag: 120_000, rhythmus: "jaehrlich" as const, start: "2026-03-01" },
],
};
const v = { ansicht: "woche" as const, start: "2026-10-21", anzahl: 13, startsaldo: 2_000_000, offeneAb: "2026-10-21" };
it("offene Einnahmen mit vergangenem Zahltag sind überfällig und zählen heute; bezahlte nicht", () => {
const w = liquiditaet(daten, v);
const alle = w.flatMap((p) => p.posten);
const rate = alle.find((p) => p.bezeichnung === "1. Rate")!;
expect(rate).toMatchObject({ datum: "2026-10-21", ueberfaelligSeit: "2026-10-04", gestellt: true });
expect(alle.find((p) => p.bezeichnung === "alte Rate")).toBeUndefined();
// ohne offeneAb bleibt es wie bisher
expect(liquiditaet(daten, { ...v, offeneAb: undefined }).flatMap((p) => p.posten).find((p) => p.bezeichnung === "1. Rate")).toBeUndefined();
});
it("Mindestgrenze aus den laufenden Kosten, Tiefpunkt mit Grund", () => {
expect(laufendJeMonat(daten.laufend, "2026-10-21")).toBe(310_000);
const w = liquiditaet(daten, v);
const l = lage(w, 2_000_000, 310_000);
expect(l.frei).toBe(1_690_000);
expect(l.tief!.kontostand).toBe(Math.min(...w.map((p) => p.kontostand)));
expect(l.grund[0]?.bezeichnung).toBe("Holz");
expect(l.ampel).toBe(l.tief!.kontostand < 0 ? "rot" : l.tief!.kontostand < 310_000 ? "gelb" : "gruen");
});
});