Laufende Kosten: Kacheln, Gruppen mit Summen, Zellen direkt ändern (0.23.0)
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:
149
src/web/laufendekosten.ts
Normal file
149
src/web/laufendekosten.ts
Normal 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);
|
||||
}
|
||||
Reference in New Issue
Block a user