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:
311
src/web/liquiditaet.ts
Normal file
311
src/web/liquiditaet.ts
Normal 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>`),
|
||||
}));
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user