Laufende Kosten: Kacheln, Gruppen mit Summen, Zellen direkt ändern (0.23.0)
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

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 21:29:29 +00:00
parent 1d1ba3ace4
commit 6184665b2d
8 changed files with 399 additions and 44 deletions

149
src/web/laufendekosten.ts Normal file
View File

@@ -0,0 +1,149 @@
// Laufende Kosten (Henning, 21.10.2026, Entwurf laufende-kosten/entwurf): oben vier Kacheln, darunter die Liste
// nach Gruppe, Kategorie oder ohne gruppiert, mit Summen je Monat und je Jahr. Zellen ändert man direkt wie im
// Terminplan, Strg+Z nimmt zurück, eine Zeile lässt sich in eine andere Gruppe ziehen. Ausgeblendete Zeilen zählen
// in Summen, Kacheln und Liquidität weiter mit.
import { type Feld, type Zeile, api, bearbeiten, dat, esc, euro, heute, inhalt, seite } from "./ui.js";
import { liste } from "./liste.js";
import { termineLaufend } from "../domain/liquiditaet.js";
import { laeuftHeute } from "../domain/lage.js";
import { plusMonate, plusTage } from "../domain/datum.js";
import { formatEuro, parseEuro } from "../domain/geld.js";
export const RHYTHMEN: [string, string][] = [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"], ["jaehrlich", "jährlich"], ["einmalig", "einmalig"]];
const RHYTHMUS_TEXT = Object.fromEntries(RHYTHMEN);
const LK_FELDER: Feld[] = [
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "kategorie", titel: "Kategorie" }, { name: "gruppe", titel: "Gruppe" },
{ name: "betrag", titel: "Betrag", art: "euro", pflicht: true }, { name: "rhythmus", titel: "Rhythmus", art: "auswahl", optionen: RHYTHMEN },
{ name: "start", titel: "Erste Zahlung", art: "datum", pflicht: true }, { name: "ende", titel: "Endet am", art: "datum" },
];
const JE_JAHR: Record<string, number> = { monatlich: 12, vierteljaehrlich: 4, jaehrlich: 1 };
const glatt = (c: number) => formatEuro(Math.sign(c) * Math.round(Math.abs(c) / 100) * 100).replace(",00 €", " €");
/** Läuft die Position heute? Gleiche Regel wie für die Mindestgrenze der Liquidität */
const laeuft = (z: Zeile, h: string) => laeuftHeute(z as never, h);
const jeJahr = (z: Zeile) => Number(z.betrag) * (JE_JAHR[z.rhythmus] ?? 0);
const naechste = (z: Zeile, h: string): string | null => termineLaufend({ ...z, betrag: Number(z.betrag), ende: z.ende ?? undefined } as never, h, plusMonate(h, 13))[0] ?? null;
const endetBald = (z: Zeile, h: string) => !!z.ende && z.ende >= h && z.ende < plusMonate(h, 6);
export function summeJeMonat(zeilen: Zeile[], h: string): number {
return zeilen.filter((z) => laeuft(z, h)).reduce((s, z) => s + jeJahr(z) / 12, 0);
}
// Rückgängig: jeder Schritt merkt die alten Werte (oder dass die Zeile neu war); gilt bis zum Neuladen
type Schritt = { id: string; vorher: Zeile | null };
const verlauf: Schritt[] = [];
let zuruecknehmen: (() => Promise<void>) | null = null;
let tasteDa = false;
export async function laufendeKostenSeite(oeffnen: { id: string; spalte: string } | null = null): Promise<void> {
const [zeilen, e] = await Promise.all([api<Zeile[]>("laufende-kosten"), api<Zeile>("einstellungen").catch(() => ({} as Zeile))]);
const h = heute();
const y = scrollY;
const neuLaden = (weiter: { id: string; spalte: string } | null = null) => laufendeKostenSeite(weiter);
seite("Laufende Kosten", { text: "+ Neue Position", aktion: async () => (await bearbeiten("laufende-kosten", "Neue laufende Kosten", LK_FELDER, null, { start: h, rhythmus: "monatlich" })) && neuLaden() });
const patch = async (z: Zeile, daten: Zeile, weiter: { id: string; spalte: string } | null = null) => {
const vorher = Object.fromEntries(Object.keys(daten).map((k) => [k, z[k] ?? null]));
await api(`laufende-kosten/${z.id}`, "PATCH", daten);
verlauf.push({ id: z.id, vorher });
await neuLaden(weiter);
};
zuruecknehmen = async () => {
const s = verlauf.pop();
if (!s) return;
if (s.vorher) await api(`laufende-kosten/${s.id}`, "PATCH", s.vorher);
else await api(`laufende-kosten/${s.id}`, "DELETE");
await neuLaden();
};
if (!tasteDa) {
tasteDa = true;
document.addEventListener("keydown", (ev) => {
if (!(ev.ctrlKey || ev.metaKey) || ev.key.toLowerCase() !== "z" || ev.shiftKey) return;
if (!document.querySelector(".lk-seite") || (ev.target as HTMLElement).closest("input, textarea, select")) return;
ev.preventDefault();
void zuruecknehmen?.();
});
}
// Kacheln
const monat = summeJeMonat(zeilen, h);
const jahr = zeilen.filter((z) => laeuft(z, h)).reduce((s, z) => s + jeJahr(z), 0);
const bald = zeilen.flatMap((z) => termineLaufend({ ...z, betrag: Number(z.betrag), ende: z.ende ?? undefined } as never, h, plusTage(h, 30)).map((t) => ({ t, betrag: Number(z.betrag) })));
const erste = bald.map((x) => x.t).sort()[0];
const gruppen = new Set(zeilen.map((z) => z.gruppe || z.kategorie));
const fest = e.mindestgrenzeArt === "fest";
const kopf = document.createElement("div");
kopf.className = "lk-seite";
kopf.innerHTML = `<div class="lk-kacheln">
<div class="lk-kachel haupt"><span>Je Monat (umgerechnet)</span><b>${glatt(monat)}</b><small>alle Rhythmen auf den Monat gerechnet</small></div>
<div class="lk-kachel"><span>Je Jahr</span><b>${glatt(jahr)}</b><small>${zeilen.length} ${zeilen.length === 1 ? "Position" : "Positionen"} in ${gruppen.size} ${gruppen.size === 1 ? "Gruppe" : "Gruppen"}</small></div>
<div class="lk-kachel"><span>Fällig nächste 30 Tage</span><b>${glatt(bald.reduce((s, x) => s + x.betrag, 0))}</b><small>${bald.length ? `${bald.length} ${bald.length === 1 ? "Zahlung" : "Zahlungen"}, nächste ${dat(erste).slice(0, 6)}` : "keine Zahlung"}</small></div>
<a class="lk-kachel" href="#liquiditaet"><span>Mindestgrenze Liquidität</span><b>${glatt(fest ? Number(e.mindestreserve) : monat)}</b><small>${fest ? "fester Betrag (in der Liquidität einstellbar)" : "= 1 Monat laufende Kosten"}</small></a>
</div>`;
inhalt.append(kopf);
const kategorien = [...new Set(zeilen.map((z) => z.kategorie).filter(Boolean))].sort((a, b) => a.localeCompare(b, "de"));
const sum = (l: Zeile[]) => {
const m = summeJeMonat(l, h);
return { jeMonat: `<b>${euro(Math.round(m))}</b>`, jeJahr: `<b>${glatt(l.filter((z) => laeuft(z, h)).reduce((s, z) => s + jeJahr(z), 0))}</b>` };
};
const tabelle = liste({
schluessel: "laufende-kosten", einheit: ["Position", "Positionen"], klasse: "lk-tabelle",
spalten: [
{ id: "bezeichnung", titel: "Bezeichnung", text: (z) => z.bezeichnung, wert: (z) => `${esc(z.bezeichnung)}${endetBald(z, h) ? ' <span class="lk-bald">endet bald</span>' : ""}`,
bearbeiten: { art: "text", roh: (z) => z.bezeichnung } },
{ id: "kategorie", titel: "Kategorie", klasse: "optional", wert: (z) => esc(z.kategorie), bearbeiten: { art: "text", roh: (z) => z.kategorie ?? "", vorschlaege: kategorien } },
{ id: "betrag", titel: "Betrag", art: "zahl", klasse: "zahl", wert: (z) => euro(Number(z.betrag)), sortWert: (z) => Number(z.betrag),
bearbeiten: { art: "euro", roh: (z) => formatEuro(Number(z.betrag), false) } },
{ id: "rhythmus", titel: "Rhythmus", wert: (z) => esc(RHYTHMUS_TEXT[z.rhythmus]), sortWert: (z) => RHYTHMEN.findIndex(([k]) => k === z.rhythmus),
bearbeiten: { art: "auswahl", optionen: RHYTHMEN, roh: (z) => z.rhythmus } },
{ id: "naechste", titel: "Nächste Zahlung", art: "datum", wert: (z) => dat(naechste(z, h)) || "–", sortWert: (z) => naechste(z, h),
bearbeiten: { art: "datum", roh: (z) => naechste(z, h) ?? z.start } },
{ id: "ende", titel: "Endet", art: "datum", klasse: "optional", wert: (z) => dat(z.ende) || "–", sortWert: (z) => z.ende, bearbeiten: { art: "datum", roh: (z) => z.ende ?? "" } },
{ id: "jeMonat", titel: "je Monat", art: "zahl", klasse: "zahl", sortWert: (z) => (laeuft(z, h) ? jeJahr(z) / 12 : 0),
wert: (z) => (z.rhythmus === "einmalig" || (z.ende && z.ende < h) ? "–" : laeuft(z, h) ? euro(Math.round(jeJahr(z) / 12))
: `<span class="lk-spaeter" title="beginnt erst am ${dat(z.start)}, zählt noch nicht">${euro(Math.round(jeJahr(z) / 12))}</span>`) },
{ id: "jeJahr", titel: "je Jahr", art: "zahl", klasse: "zahl optional", sortWert: (z) => (laeuft(z, h) ? jeJahr(z) : 0),
wert: (z) => (laeuft(z, h) ? glatt(jeJahr(z)) : "–") },
],
zeilen,
vorgabe: { sort: [["naechste", "auf"]] },
gruppieren: {
arten: [{ id: "gruppe", titel: "Gruppe", wert: (z) => z.gruppe ?? "" }, { id: "kategorie", titel: "Kategorie", wert: (z) => z.kategorie ?? "" }],
vorgabe: zeilen.some((z) => z.gruppe) ? "gruppe" : "kategorie",
neu: async (art, gruppe, bezeichnung) => {
const r = await api<Zeile>("laufende-kosten", "POST", { bezeichnung, betrag: 0, rhythmus: "monatlich", start: h, [art]: gruppe || (art === "kategorie" ? "Sonstiges" : null) });
verlauf.push({ id: r.id, vorher: null });
await neuLaden({ id: r.id, spalte: "betrag" });
},
ziehen: (z, art, gruppe) => patch(z, { [art]: gruppe || (art === "kategorie" ? "Sonstiges" : null) }),
},
summen: sum, summenTitel: 'Summe laufende Kosten <small>(ausgeblendete zählen mit)</small>',
aendern: async (z, spalte, wert, weiter) => {
const w = wert.trim();
let daten: Zeile;
if (spalte === "bezeichnung") { if (!w) throw new Error("Bitte eine Bezeichnung eintragen."); daten = { bezeichnung: w }; }
else if (spalte === "kategorie") daten = { kategorie: w || "Sonstiges" };
else if (spalte === "betrag") {
try { daten = { betrag: parseEuro(w) }; } catch { throw new Error("Bitte einen Betrag wie 120,50 eintragen."); }
} else if (spalte === "rhythmus") daten = { rhythmus: w };
// die nächste Zahlung verlegt die Reihe: ab diesem Datum im Rhythmus weiter
else if (spalte === "naechste") { if (!w) throw new Error("Bitte ein Datum wählen."); daten = { start: w }; }
else if (spalte === "ende") daten = { ende: w || null };
else return;
await patch(z, daten, weiter);
},
oeffnen,
klick: async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && neuLaden(),
leiste: () => `<button type="button" class="neben" data-lk="zurueck" title="Letzte Änderung zurücknehmen (Strg+Z)"${verlauf.length ? "" : " disabled"}>↶ Rückgängig</button>`,
fuss: () => '<p class="hinweis lk-hilfe">Zelle anklicken = direkt ändern · Enter speichert, Esc bricht ab, Tab springt weiter · Doppelklick = alle Felder · Strg+Z = Rückgängig · Zeile am ⋮⋮ in eine andere Gruppe ziehen = Gruppe ändern</p>',
});
tabelle.addEventListener("click", (ev) => { if ((ev.target as HTMLElement).closest('[data-lk="zurueck"]')) void zuruecknehmen?.(); });
const karte = document.createElement("section");
karte.className = "karte lk-karte";
karte.append(tabelle);
kopf.append(karte);
scrollTo(0, y);
}