Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
604 lines
47 KiB
TypeScript
604 lines
47 KiB
TypeScript
// 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 { AUGE, AUGE_ZU, ansichtMerken, gespeicherteAnsicht, liste } from "./liste.js";
|
||
import { flussJeWoche, lage } from "../domain/lage.js";
|
||
import type { Periode } from "../domain/liquiditaet.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 €", " €");
|
||
/** Projektnummer → Projekt-ID, damit die Nummern Links zum Projekt sind (UX-Prüfung, 08.11.2026) */
|
||
let projektIds = new Map<string, string>();
|
||
const projektLink = (nr: string) => (projektIds.has(nr) ? `<a href="#projekt-${esc(projektIds.get(nr)!)}">${esc(nr)}</a>` : esc(nr));
|
||
const postenText = (p: Zeile, namen?: Map<string, string>) =>
|
||
`${esc(p.bezeichnung)}${p.projekt ? ` · ${projektLink(p.projekt)}${namen?.get(p.projekt) ? ` ${esc(namen.get(p.projekt))}` : ""}` : ""}`;
|
||
/** vom Projekt aus „in Liquidität zeigen“: „Alle Zahlungen“ nur dieses Projekts */
|
||
let nurProjekt: string | null = null;
|
||
export function liquiNurProjekt(nummer: string): void {
|
||
nurProjekt = nummer;
|
||
reiter = "alle";
|
||
}
|
||
|
||
const FLUSS_GRUPPEN = new Set(["Projekteinnahmen", "Projektkosten", "Laufende Kosten", "Umsatzsteuer"]);
|
||
|
||
/** Karte oben ohne Kontostand (UX-Prüfung, 08.11.2026): ein Lage-Satz mit Zeitraum und Überschuss, darunter die Summen */
|
||
function flussKopfHtml(wochen: Zeile[]): string {
|
||
const fluss = flussJeWoche(wochen as Periode[]);
|
||
const ueber = fluss.reduce((x, w) => x + w.einnahmen - w.projektkosten - w.laufend - w.ust, 0);
|
||
const von = heute(), bis = (wochen.at(-1)?.bis as string | undefined) ?? von;
|
||
return `<section class="karte liqui-satz-ohne"><p class="liqui-satz-gross">${dat(von)} – ${dat(bis)}: <b class="${ueber < 0 ? "fehler" : ""}">${ueber > 0 ? "+" : ""}${glatt(ueber)}</b> ${ueber < 0 ? "Fehlbetrag" : "Überschuss"}</p>
|
||
<p class="hinweis">Trag den Kontostand ein, dann steht hier „frei verfügbar heute“ und die Woche, in der es am knappsten wird. <button class="verweis" data-kontostand="an">Kontostand eintragen</button></p></section>
|
||
<section class="karte liqui-fluss-kopf">${flussKachelnHtml(fluss, ZEIT_KNOPF[zeitraum], true)}</section>`;
|
||
}
|
||
|
||
/** 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="#einstellungen-programmteile">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>`;
|
||
}
|
||
|
||
/** Liniendiagramm je Woche: Kontostand als Fläche, Einnahmen und Ausgaben je Woche, Mindestgrenze, tiefster Punkt */
|
||
// Geldfluss ohne Kontostand (Henning, 23.10.2026): je Woche Einnahmen, Projektkosten, laufende Kosten und auf Wunsch die Umsatzsteuer
|
||
const FLUSS: [string, string, string][] = [["einnahmen", "fl-ein", "Einnahmen"], ["projektkosten", "fl-pk", "Projektkosten"], ["laufend", "fl-lk", "Laufende Kosten"], ["ust", "fl-ust", "Umsatzsteuer"]];
|
||
|
||
/** Kacheln mit den Summen des Zeitraums und dem Überschuss */
|
||
export function flussKachelnHtml(fluss: Zeile[], zeitText: string, mitUst: boolean): string {
|
||
const s = (k: string) => fluss.reduce((x, w) => x + Number(w[k] ?? 0), 0);
|
||
const ueber = s("einnahmen") - s("projektkosten") - s("laufend") - (mitUst ? s("ust") : 0);
|
||
return `<div class="fluss-kacheln">
|
||
<div><small>Einnahmen</small><b class="fl-ein">${glatt(s("einnahmen"))}</b></div>
|
||
<div><small>Projektkosten</small><b class="fl-pk">${glatt(-s("projektkosten"))}</b></div>
|
||
<div><small>Laufende Kosten</small><b class="fl-lk">${glatt(-s("laufend"))}</b></div>
|
||
${mitUst ? `<div><small>Umsatzsteuer (Schätzung)</small><b class="fl-ust">${glatt(-s("ust"))}</b></div>` : ""}
|
||
<div><small>Überschuss ${zeitText}</small><b class="${ueber < 0 ? "fehler" : ""}">${glatt(ueber)}</b></div></div>`;
|
||
}
|
||
|
||
/** Linien je Woche; Kosten als positive Beträge, Umsatzsteuer: Zahllast positiv, Erstattung negativ */
|
||
export function flussSvg(fluss: Zeile[], platz: number, mitUst: boolean, wahl?: { gewaehlt: string | null }): string {
|
||
if (!fluss.length) return '<p class="hinweis">Keine Wochen im Zeitraum.</p>';
|
||
const reihen = FLUSS.filter(([k]) => mitUst || k !== "ust");
|
||
const B = Math.max(340, Math.round(platz)), H = B < 600 ? 200 : 230, L = 56, R = 16, O = 14, U = 28;
|
||
const alle = fluss.flatMap((w) => reihen.map(([k]) => Number(w[k] ?? 0)));
|
||
const roh = { min: Math.min(0, ...alle), max: Math.max(1, ...alle) };
|
||
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 = fluss.length;
|
||
const x = (i: number) => L + (n === 1 ? (B - L - R) / 2 : (i * (B - L - R)) / (n - 1));
|
||
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 jede = Math.max(1, Math.ceil(n / Math.max(2, Math.floor(B / 90))));
|
||
const beschriftung = fluss.map((w, i) => (i % jede === 0 || i === n - 1 ? `<text class="achse" x="${x(i)}" y="${H - 8}" text-anchor="${i === n - 1 && n > 1 ? "end" : i === 0 ? "start" : "middle"}">${kw(w.von)}</text>` : "")).join("");
|
||
const kurven = reihen.map(([k, kl]) => `<polyline class="fl-linie ${kl}" points="${fluss.map((w, i) => `${x(i).toFixed(1)},${y(Number(w[k] ?? 0)).toFixed(1)}`).join(" ")}"/>
|
||
${fluss.map((w, i) => `<circle class="fl-punkt ${kl}" cx="${x(i)}" cy="${y(Number(w[k] ?? 0))}" r="3.5"><title>${kw(w.von)} · ${dat(w.von).slice(0, 6)} – ${dat(w.bis).slice(0, 6)}
|
||
${reihen.map(([k2, , t]) => `${t}: ${glatt(Number(w[k2] ?? 0))}`).join("\n")}</title></circle>`).join("")}`).join("");
|
||
// Woche anklicken: Zahlungen dieser Woche (Liquiditätsseite)
|
||
const breite = n > 1 ? (B - L - R) / (n - 1) : B - L - R;
|
||
const ziele = wahl ? fluss.map((w, i) => `<rect class="woche-ziel${w.von === wahl.gewaehlt ? " an" : ""}" data-woche="${w.von}" tabindex="0" role="button" aria-label="${kw(w.von)}: Zahlungen anzeigen"
|
||
x="${x(i) - 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)}
|
||
${reihen.map(([k2, , t]) => `${t}: ${glatt(Number(w[k2] ?? 0))}`).join("\n")}</title></rect>`).join("") : "";
|
||
return `<svg class="liqui-svg fluss-svg" viewBox="0 0 ${B} ${H}" role="img" aria-label="${reihen.map(([, , t]) => t).join(", ")} je Woche">${linien.join("")}${kurven}${beschriftung}${ziele}</svg>
|
||
<div class="fluss-legende">${reihen.map(([, kl, t]) => `<span><i class="${kl}"></i>${t} je Woche</span>`).join("")}${mitUst ? "<span>Umsatzsteuer unter 0 = Erstattung</span>" : ""}</div>`;
|
||
}
|
||
|
||
function kurveSvg(d: Zeile, platz: number, was?: Zeile[]): 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;
|
||
// Was wäre, wenn: Kontostand der Variante als zweite, gestrichelte Linie
|
||
const wasStand = was ? [d.kontostand as number, ...was.map((w) => w.kontostand as number)] : [];
|
||
const roh = { min: Math.min(0, ...stand, ...wasStand), max: Math.max(1, mg, ...stand, ...wasStand, ...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}"/>
|
||
${was ? `<polyline class="was-linie" points="${pfad(wasStand, 0)}"/>` : ""}
|
||
${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>, ohne = false): string {
|
||
if (!w) return "";
|
||
const posten = [...(w.posten as Zeile[]), ...((w.ohne ?? []) 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${p.zaehltNicht ? ' class="zaehlt-nicht"' : ""}><td>${dat(p.datum).slice(0, 6)}</td><td class="text">${postenText(p, namen)}${p.zaehltNicht ? ' <span class="tag-zaehlt">zählt nicht</span>' : ""}</td>
|
||
<td class="zaehlt">${zaehltHaken(p.quelle ? [p.quelle] : [], !p.zaehltNicht, p.bezeichnung)}</td><td class="zahl ${p.betrag < 0 ? "aus" : "ein"}">${glatt(p.betrag)}</td></tr>`).join("")}</tbody>
|
||
<tfoot><tr><td></td><td colspan="2">Saldo der Woche${ohne ? "" : ` · Kontostand danach ${glatt(w.kontostand)}`}</td><td class="zahl">${glatt(ohne ? posten.filter((p) => !p.zaehltNicht).reduce((x, p) => x + p.betrag, 0) : w.saldo)}</td></tr></tfoot></table>`
|
||
: '<p class="hinweis">In dieser Woche ist keine Zahlung geplant.</p>'}</div>`;
|
||
}
|
||
|
||
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]));
|
||
projektIds = new Map(projekte.map((p) => [p.nummer as string, p.id as string]));
|
||
// vorerst ohne Kontostand (Henning, 23.10.2026): nur Einnahmen, Projektkosten, laufende Kosten und Umsatzsteuer
|
||
const ohne = !d.mitKontostand;
|
||
if (ohne) d.wochen = (d.wochen as Zeile[]).map((w) => ({ ...w, posten: (w.posten as Zeile[]).filter((p) => FLUSS_GRUPPEN.has(p.gruppe)),
|
||
ohne: ((w.ohne ?? []) as Zeile[]).filter((p) => FLUSS_GRUPPEN.has(p.gruppe)) }));
|
||
const wochen = d.wochen as Zeile[];
|
||
const bereich = document.createElement("div");
|
||
bereich.className = "liqui-seite";
|
||
inhalt.append(bereich);
|
||
let ansicht = gespeicherteAnsicht(AUS_SCHLUESSEL);
|
||
const zeichne = () => {
|
||
const ausSet = new Set(ansicht.aus);
|
||
const zeilen = { ein: zeilenVon("ein", wochen), aus: zeilenVon("aus", wochen) };
|
||
const v = variante(d);
|
||
bereich.innerHTML = (v ? probeBand(d, v, zeilen, ohne) : "") + (ohne ? flussKopfHtml(wochen) : lageKopfHtml(d, ZEIT_TEXT[zeitraum]))
|
||
+ (ohne ? `<section class="karte liqui-kurve"><div class="karte-kopf"><h2>Einnahmen, Projektkosten, laufende Kosten und Umsatzsteuer · nächste ${ZEIT_KNOPF[zeitraum]}</h2></div>
|
||
<div class="kurve-huelle">${flussSvg(flussJeWoche((v?.wochen ?? wochen) as Periode[]), bereich.clientWidth - 34, true, { gewaehlt })}</div>
|
||
<p class="hinweis">Woche anklicken: Zahlungen dieser Woche.${v ? " Das Diagramm zeigt die probeweisen Änderungen." : ""}</p>
|
||
${wocheHtml(wochen.find((w) => w.von === gewaehlt), namen, true)}</section>` : `<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, v?.wochen)}</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>${v ? '<span><i class="k-was"></i>Was wäre, wenn</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>
|
||
${planHinweis(d)}
|
||
<p class="hinweis"><button class="verweis" data-kontostand="aus">Ohne Kontostand rechnen</button></p>
|
||
${wocheHtml(wochen.find((w) => w.von === gewaehlt), namen)}</section>`)
|
||
+ `<div class="liqui-zwei">${listeHtml("ein", zeilen.ein, namen, ausSet, d)}${listeHtml("aus", zeilen.aus, namen, ausSet, d)}</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(); }
|
||
const pv = t.closest<HTMLElement>("[data-plan-vorschau]");
|
||
if (pv) {
|
||
void (async () => { const e = await api<Zeile>("einstellungen"); await api("einstellungen", "PUT", { ...e, jahresplanVorschau: pv.dataset.planVorschau === "an" }); void liquiditaetSeite(); })();
|
||
return;
|
||
}
|
||
const az = t.closest<HTMLElement>("[data-alle-zaehlen]");
|
||
if (az) { void zaehltSetzen(az.dataset.alleZaehlen!, true, () => void liquiditaetSeite()); return; }
|
||
const knopf = t.closest<HTMLElement>("[data-modus], [data-ausblenden], [data-zeige-aus], [data-alle-ein], [data-a=probe-weg], [data-verschieben]");
|
||
if (knopf?.dataset.modus) { modus = knopf.dataset.modus as "aus" | "was"; return zeichne(); }
|
||
if (knopf?.dataset.ausblenden) {
|
||
const k = knopf.dataset.ausblenden;
|
||
ansicht = { ...ansicht, aus: ansicht.aus.includes(k) ? ansicht.aus.filter((x) => x !== k) : [...ansicht.aus, k] };
|
||
ansichtMerken(AUS_SCHLUESSEL, ansicht);
|
||
return zeichne();
|
||
}
|
||
if (knopf?.dataset.zeigeAus) { const k = knopf.dataset.zeigeAus as "ein" | "aus"; zeigeAus[k] = !zeigeAus[k]; return zeichne(); }
|
||
if (knopf?.dataset.alleEin) {
|
||
const art = knopf.dataset.alleEin as "ein" | "aus";
|
||
const keys = new Set(zeilenVon(art, wochen).map((z) => z.key));
|
||
ansicht = { ...ansicht, aus: ansicht.aus.filter((x) => !keys.has(x)) };
|
||
ansichtMerken(AUS_SCHLUESSEL, ansicht);
|
||
zeigeAus[art] = false;
|
||
return zeichne();
|
||
}
|
||
if (knopf?.dataset.a === "probe-weg") { probe.clear(); return zeichne(); }
|
||
if (knopf?.dataset.verschieben) {
|
||
// Datum probeweise verschieben: kleines Datumsfeld an Ort und Stelle
|
||
const k = knopf.dataset.verschieben;
|
||
const alt = knopf.dataset.datum!;
|
||
const feld = document.createElement("input");
|
||
feld.type = "date";
|
||
feld.className = "liqui-datum";
|
||
feld.value = probe.get(k)?.datum ?? alt;
|
||
feld.setAttribute("aria-label", "Probeweise verschieben auf");
|
||
knopf.replaceWith(feld);
|
||
feld.focus();
|
||
try { feld.showPicker?.(); } catch { /* nicht überall erlaubt */ }
|
||
const fertig = () => {
|
||
const p = { ...(probe.get(k) ?? {}) };
|
||
if (feld.value && feld.value !== alt) p.datum = feld.value; else delete p.datum;
|
||
if (p.weg || p.datum) probe.set(k, p); else probe.delete(k);
|
||
zeichne();
|
||
};
|
||
feld.addEventListener("change", fertig);
|
||
feld.addEventListener("blur", fertig);
|
||
return;
|
||
}
|
||
if (t.closest("[data-a=woche-zu]")) { gewaehlt = null; return zeichne(); }
|
||
const ks = t.closest<HTMLElement>("[data-kontostand]");
|
||
if (ks) {
|
||
void (async () => { const e = await api<Zeile>("einstellungen"); await api("einstellungen", "PUT", { ...e, liquiditaetMitKontostand: ks.dataset.kontostand === "an" }); void liquiditaetSeite(); })();
|
||
return;
|
||
}
|
||
if (t.closest("[data-a=grenze]")) grenzeBearbeiten(bereich.querySelector<HTMLElement>("#l-grenze")!, d);
|
||
};
|
||
bereich.onchange = (ev) => {
|
||
const el = ev.target as HTMLInputElement;
|
||
if (el.dataset.zaehlt !== undefined) { void zaehltSetzen(el.dataset.zaehlt, el.checked, () => void liquiditaetSeite()); return; }
|
||
if (el.dataset.probe === undefined) return;
|
||
const k = el.dataset.probe;
|
||
const p = { ...(probe.get(k) ?? {}) };
|
||
if (el.checked) delete p.weg; else p.weg = true;
|
||
if (p.weg || p.datum) probe.set(k, p); else probe.delete(k);
|
||
zeichne();
|
||
};
|
||
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(); }
|
||
};
|
||
}
|
||
|
||
// ---------- Ausblenden und „Was wäre, wenn“ (Henning, 21.10.2026) ----------
|
||
|
||
const AUS_SCHLUESSEL = "liquiditaet-lage";
|
||
/** Modus der Listen und die probeweisen Änderungen; nichts davon wird gespeichert, beim Verlassen der Seite ist es weg */
|
||
let modus: "aus" | "was" = "aus";
|
||
const probe = new Map<string, { weg?: boolean; datum?: string }>();
|
||
const zeigeAus = { ein: false, aus: false };
|
||
addEventListener("hashchange", () => { if (!location.hash.startsWith("#liquiditaet")) { probe.clear(); modus = "aus"; } });
|
||
|
||
interface ListenZeile { key: string; datum: string; ueberfaelligSeit?: string; gestellt?: boolean; bezeichnung: string; projekt?: string; betrag: number; anzahl: number; einzeln?: string[];
|
||
/** Herkunft für den Haken „zählt“; leer z. B. bei der Umsatzsteuer, die sich aus allem anderen ergibt */
|
||
quellen: string[]; zaehlt: boolean }
|
||
|
||
/** Schlüssel einer Zahlung, bleibt über Neuladen gleich; laufende Kosten eines Monats sind eine Zeile */
|
||
const postenKey = (p: Zeile): string => (p.gruppe === "Laufende Kosten" && p.betrag < 0 ? `lk|${String(p.datum).slice(0, 7)}${p.zaehltNicht ? "|ohne" : ""}`
|
||
: `${p.gruppe}|${p.projekt ?? ""}|${p.bezeichnung}|${p.ueberfaelligSeit ?? p.datum}`);
|
||
|
||
/** Zeilen für „Kommt rein“ oder „Geht raus“: Überfälliges oben, dann nach Datum; laufende Kosten je Monat in einer Zeile */
|
||
function zeilenVon(art: "ein" | "aus", wochen: Zeile[]): ListenZeile[] {
|
||
const h = heute();
|
||
const posten = wochen.flatMap((w) => [...(w.posten as Zeile[]), ...((w.ohne ?? []) as Zeile[])])
|
||
.filter((p) => (art === "ein" ? p.betrag > 0 : p.betrag < 0) && !(p.bezahlt && p.datum < h));
|
||
const nachKey = new Map<string, ListenZeile>();
|
||
for (const p of posten) {
|
||
const key = postenKey(p);
|
||
const z = nachKey.get(key);
|
||
if (z) { z.betrag += p.betrag; z.anzahl++; z.einzeln?.push(p.bezeichnung); if (p.quelle) z.quellen.push(p.quelle); continue; }
|
||
const lk = key.startsWith("lk|");
|
||
nachKey.set(key, { key, datum: p.datum, ueberfaelligSeit: p.ueberfaelligSeit, gestellt: p.gestellt, projekt: p.projekt, betrag: p.betrag, anzahl: 1,
|
||
bezeichnung: lk ? `Laufende Kosten ${MONATSNAMEN[Number(String(p.datum).slice(5, 7)) - 1]}` : p.bezeichnung, ...(lk ? { einzeln: [p.bezeichnung] } : {}),
|
||
quellen: p.quelle ? [p.quelle] : [], zaehlt: !p.zaehltNicht });
|
||
}
|
||
return [...nachKey.values()].sort((a, b) => (a.ueberfaelligSeit ? 0 : 1) - (b.ueberfaelligSeit ? 0 : 1)
|
||
|| (a.ueberfaelligSeit ?? a.datum).localeCompare(b.ueberfaelligSeit ?? b.datum) || a.betrag - b.betrag);
|
||
}
|
||
|
||
/** Die Wochen noch einmal mit den probeweisen Änderungen gerechnet: weggelassen, verschoben (vor dem Zeitraum = erste Woche, danach = raus) */
|
||
function variante(d: Zeile): { wochen: Zeile[]; lage: Zeile } | null {
|
||
if (!probe.size) return null;
|
||
const wochen = d.wochen as Zeile[];
|
||
if (!wochen.length) return null;
|
||
const alle: Zeile[] = [];
|
||
for (const w of wochen) for (const p of w.posten as Zeile[]) {
|
||
const x = probe.get(postenKey(p));
|
||
if (x?.weg) continue;
|
||
alle.push(x?.datum ? { ...p, datum: x.datum } : p);
|
||
}
|
||
let stand = d.kontostand as number;
|
||
const neu = wochen.map((w, i) => {
|
||
const posten = alle.filter((p) => p.datum <= w.bis);
|
||
for (const p of posten) alle.splice(alle.indexOf(p), 1);
|
||
const einnahmen = posten.filter((p) => p.betrag > 0).reduce((s, p) => s + p.betrag, 0);
|
||
const ausgaben = posten.filter((p) => p.betrag < 0).reduce((s, p) => s + p.betrag, 0);
|
||
stand += einnahmen + ausgaben;
|
||
return { ...w, posten, einnahmen, ausgaben, saldo: einnahmen + ausgaben, kontostand: stand };
|
||
});
|
||
return { wochen: neu, lage: lage(neu as Periode[], d.kontostand, d.mindestgrenze) };
|
||
}
|
||
|
||
/** Gelbes Band oben: was probeweise geändert ist und wo der tiefste Punkt dann liegt */
|
||
function probeBand(d: Zeile, v: { lage: Zeile; wochen: Zeile[] }, zeilen: { ein: ListenZeile[]; aus: ListenZeile[] }, ohne = false): string {
|
||
const alle = [...zeilen.ein, ...zeilen.aus];
|
||
const teile = [...probe.entries()].map(([k, x]) => {
|
||
const z = alle.find((y) => y.key === k);
|
||
if (!z) return "";
|
||
const name = `${esc(z.bezeichnung)} ${glatt(Math.abs(z.betrag))}`;
|
||
return x.weg ? `${name} rausgenommen` : `${name} auf ${dat(x.datum!).slice(0, 6)} verschoben`;
|
||
}).filter(Boolean);
|
||
const t = v.lage.tief, alt = d.lage.tief;
|
||
const ueberschuss = (w: Zeile[]) => flussJeWoche(w as Periode[]).reduce((s, x) => s + x.einnahmen - x.projektkosten - x.laufend - x.ust, 0);
|
||
const satz = ohne ? `Überschuss dann <b>${glatt(ueberschuss(v.wochen))}</b> statt ${glatt(ueberschuss(d.wochen))}.`
|
||
: t ? `Tiefster Punkt dann <b>${kw(t.von)} mit ${glatt(t.kontostand)}</b>${alt ? ` statt ${glatt(alt.kontostand)}` : ""}.` : "";
|
||
return `<div class="liqui-probe" role="status"><span class="symbol" aria-hidden="true">🧪</span>
|
||
<div><b>Was wäre, wenn</b> ist an: ${teile.join(", ") || "keine Änderung"}.<br>${satz} Nichts davon ist gespeichert.</div>
|
||
<button class="neben" data-a="probe-weg">Zurücksetzen</button></div>`;
|
||
}
|
||
|
||
// ---------- Haken „zählt“ (Henning, 26.10.2026): dauerhaft gespeichert, anders als Auge und „Was wäre, wenn“ ----------
|
||
|
||
/** Haken für eine Zeile; ohne Herkunft (Umsatzsteuer, Jahresplan) gibt es keinen */
|
||
export function zaehltHaken(quellen: string[], zaehlt: boolean, name: string): string {
|
||
if (!quellen.length) return "";
|
||
return `<input type="checkbox" class="zaehlt-haken" data-zaehlt="${esc(quellen.join(" "))}"${zaehlt ? " checked" : ""}
|
||
aria-label="${esc(name)} zählt in der Liquidität" title="${zaehlt ? "Haken weg = zählt dauerhaft nicht mehr mit (Summen, Kurve, Monatsplan, Übersicht)" : "Zählt nicht mit. Haken setzen = zählt wieder"}">`;
|
||
}
|
||
|
||
/** Speichern und die Seite neu zeichnen */
|
||
export async function zaehltSetzen(quellen: string, zaehlt: boolean, danach: () => void): Promise<void> {
|
||
const liste = quellen.split(" ").filter(Boolean).map((quelle) => ({ quelle, zaehlt }));
|
||
if (!liste.length) return;
|
||
await api("liquiditaet/zaehlt", "POST", liste);
|
||
danach();
|
||
}
|
||
|
||
/** „Kommt rein“ oder „Geht raus“ mit Auge (Ausblenden) oder Haken und Datum (Was wäre, wenn) */
|
||
function listeHtml(art: "ein" | "aus", alle: ListenZeile[], namen: Map<string, string>, ausSet: Set<string>, d: Zeile): string {
|
||
const h = heute();
|
||
const was = modus === "was";
|
||
const versteckt = alle.filter((z) => ausSet.has(z.key));
|
||
const zaehlen = alle.filter((z) => z.zaehlt), nicht = alle.filter((z) => !z.zaehlt);
|
||
const posten = alle.filter((z) => !ausSet.has(z.key) || zeigeAus[art]);
|
||
const ueber = posten.filter((p) => p.ueberfaelligSeit).length;
|
||
const sichtbar = mehr[art] ? posten.length : Math.max(SICHTBAR, ueber);
|
||
const summe = (l: ListenZeile[]) => l.reduce((s, p) => s + p.betrag, 0);
|
||
const wochen = d.wochen as Zeile[];
|
||
const ende = wochen.at(-1)?.bis ?? h;
|
||
const probeSumme = zaehlen.reduce((s, z) => { const x = probe.get(z.key); return s + (x?.weg || (x?.datum && x.datum > ende) ? 0 : z.betrag); }, 0);
|
||
const zeile = (p: ListenZeile) => {
|
||
const seit = p.ueberfaelligSeit;
|
||
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(", "))}"` : "";
|
||
const x = probe.get(p.key), weg = ausSet.has(p.key);
|
||
const datumText = seit ? `seit ${dat(seit).slice(0, 6)}` : dat(p.datum).slice(0, 6);
|
||
const datum = was
|
||
? `<button class="liqui-dat" data-verschieben="${esc(p.key)}" data-datum="${p.datum}" title="Probeweise verschieben">${datumText}</button>${x?.datum ? ` → <span class="tag-probe">${dat(x.datum).slice(0, 6)}</span>` : ""}`
|
||
: datumText;
|
||
const vorne = was
|
||
? `<input type="checkbox" data-probe="${esc(p.key)}"${x?.weg ? "" : " checked"} aria-label="${esc(p.bezeichnung)} probeweise mitrechnen" title="Haken weg = probeweise ohne diesen Posten">`
|
||
: `<button class="auge" data-ausblenden="${esc(p.key)}" title="${weg ? "Wieder einblenden" : "Zeile ausblenden (zählt weiter mit)"}" aria-label="${weg ? "Wieder einblenden" : "Zeile ausblenden"}">${weg ? AUGE : AUGE_ZU}</button>`;
|
||
return `<tr class="${seit ? "ueber" : ""}${x?.weg ? " probe-weg" : ""}${x?.datum ? " probe-dat" : ""}${weg ? " ausgeblendet" : ""}${p.zaehlt ? "" : " zaehlt-nicht"}"${titel}><td class="vorne">${vorne}</td><td class="datum">${datum}</td>
|
||
<td class="text">${postenText(p, namen)}${p.anzahl > 1 ? ` <small class="hinweis">(${p.anzahl})</small>` : ""}${tag}${p.zaehlt ? "" : ' <span class="tag-zaehlt">zählt nicht</span>'}</td>
|
||
<td class="zaehlt">${zaehltHaken(p.quellen, p.zaehlt, p.bezeichnung)}</td><td class="zahl ${art}">${glatt(p.betrag)}</td></tr>`;
|
||
};
|
||
const rest = posten.slice(sichtbar);
|
||
const probeText = probe.size && probeSumme !== summe(zaehlen) ? ` <small class="probe-summe">(probeweise ${glatt(probeSumme)})</small>` : "";
|
||
return `<section class="karte liqui-liste"><h2>${art === "ein" ? "Kommt rein" : "Geht raus"} <span class="hinweis">· nächste ${ZEIT_KNOPF[zeitraum]}</span></h2>
|
||
${alle.length ? `<table class="liqui-posten"><thead><tr><th class="vorne"></th><th class="datum">Datum</th><th class="text">Was</th><th class="zaehlt" title="Haken weg = zählt dauerhaft nicht mit">In Rechnung</th><th class="zahl">Betrag</th></tr></thead>
|
||
<tbody>${posten.slice(0, sichtbar).map(zeile).join("")}
|
||
${rest.length || (mehr[art] && posten.length > SICHTBAR) ? `<tr class="mehr"><td></td><td></td><td colspan="3"><button class="verweis" data-mehr="${art}" aria-expanded="${mehr[art]}">${mehr[art] ? "▴ weniger anzeigen" : `▾ ${rest.length} weitere anzeigen (${glatt(summe(rest.filter((z) => z.zaehlt)))})`}</button></td></tr>` : ""}
|
||
${nicht.length ? `<tr class="aus-hinweis"><td></td><td></td><td colspan="3">${nicht.length} Posten ${nicht.length === 1 ? "zählt" : "zählen"} nicht · <button class="verweis" data-alle-zaehlen="${esc(nicht.flatMap((z) => z.quellen).join(" "))}">alle wieder zählen</button></td></tr>` : ""}
|
||
${versteckt.length ? `<tr class="aus-hinweis"><td></td><td></td><td colspan="3">${versteckt.length} ${versteckt.length === 1 ? "Zeile" : "Zeilen"} ausgeblendet · <button class="verweis" data-zeige-aus="${art}">${zeigeAus[art] ? "wieder verbergen" : "einblenden"}</button>${zeigeAus[art] ? ` · <button class="verweis" data-alle-ein="${art}">alle wieder einblenden</button>` : ""} <span class="hinweis">(zählt weiter mit)</span></td></tr>` : ""}</tbody>
|
||
<tfoot><tr><td></td><td></td><td colspan="2">${nicht.length ? `Summe der ${zaehlen.length}, die zählen` : `Summe aller ${alle.length}`}${probeText}</td><td class="zahl ${art}">${glatt(summe(zaehlen))}</td></tr></tfoot></table>`
|
||
: `<p class="hinweis">${art === "ein" ? "Im Zeitraum kommt nichts rein." : "Im Zeitraum geht nichts raus."}</p>`}</section>`;
|
||
}
|
||
|
||
/** Stufe 5: Posten aus dem Jahresplan zählen als Vorschau; hier ein- und ausschalten */
|
||
function planHinweis(d: Zeile): string {
|
||
const plan = (d.wochen as Zeile[]).flatMap((w) => w.posten as Zeile[]).filter((p) => p.gruppe === "Jahresplan");
|
||
if (d.jahresplanVorschau && !plan.length) return "";
|
||
return `<p class="hinweis liqui-plan-hinweis">${d.jahresplanVorschau
|
||
? `Ab ${MONATSNAMEN[Number(plan[0]!.datum.slice(5, 7)) - 1]} ${plan[0]!.datum.slice(0, 4)} rechnet die Liquidität mit dem <a href="#jahresplanung">Jahresplan</a>, soweit echte Zahlungen fehlen (Posten „Plan: …“). <button class="verweis" data-plan-vorschau="aus">Vorschau ausschalten</button>`
|
||
: `Die Vorschau aus dem Jahresplan ist ausgeschaltet. <button class="verweis" data-plan-vorschau="an">Einschalten</button>`}</p>`;
|
||
}
|
||
|
||
/** 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 [roh, projekte, einst] = await Promise.all([
|
||
api<Zeile[]>(`liquiditaet?ansicht=${raster}&anzahl=${anzahl}&start=${heute()}&offene=1`), api<Zeile[]>("projekte"), api<Zeile>("einstellungen"),
|
||
]);
|
||
// ohne Kontostand: nur die vier Gruppen, Spalten je Gruppe und Überschuss statt Kontostand
|
||
const ohne = !einst.liquiditaetMitKontostand;
|
||
const perioden: Zeile[] = ohne ? roh.map((p) => ({ ...p, posten: (p.posten as Zeile[]).filter((x) => FLUSS_GRUPPEN.has(x.gruppe)),
|
||
ohne: ((p.ohne ?? []) as Zeile[]).filter((x) => FLUSS_GRUPPEN.has(x.gruppe)) })) : roh;
|
||
const flussVon = (p: Zeile) => flussJeWoche([p as Periode])[0]!;
|
||
const namen = new Map(projekte.map((p) => [p.nummer as string, p.bezeichnung as string]));
|
||
projektIds = new Map(projekte.map((p) => [p.nummer as string, p.id 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" : ""}${x.zaehltNicht ? " zaehlt-nicht" : ""}"><td>${x.ueberfaelligSeit ? `seit ${dat(x.ueberfaelligSeit)}` : dat(x.datum)}</td>
|
||
<td class="text">${esc(x.bezeichnung)}${x.ueberfaelligSeit ? ` <span class="tag-ueber">${x.gestellt ? "überfällig" : "Rechnung fehlt"}</span>` : ""}${x.zaehltNicht ? ' <span class="tag-zaehlt">zählt nicht</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="zaehlt">${zaehltHaken(x.quelle ? [x.quelle] : [], !x.zaehltNicht, x.bezeichnung)}</td><td class="zahl ${x.betrag < 0 ? "aus" : "ein"}">${euro(x.betrag)}</td></tr>`;
|
||
const tab = document.createElement("table");
|
||
tab.className = "liqui-tabelle";
|
||
const spalten = ohne ? 6 : 5;
|
||
const zahlen = (p: Zeile) => {
|
||
if (!ohne) return `<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>`;
|
||
const f = flussVon(p), u = f.einnahmen - f.projektkosten - f.laufend - f.ust;
|
||
const z = (c: number, kl: string) => `<td class="zahl ${kl}">${c ? euro(c) : "–"}</td>`;
|
||
return `${z(f.einnahmen, "ein")}${z(-f.projektkosten, "aus")}${z(-f.laufend, "aus")}${z(-f.ust, "aus optional")}<td class="zahl"><b class="${u < 0 ? "fehler" : ""}">${euro(u)}</b></td>`;
|
||
};
|
||
tab.innerHTML = `<thead><tr><th>${raster === "woche" ? "Woche" : "Monat"}</th>${ohne
|
||
? '<th class="zahl">Einnahmen</th><th class="zahl">Projektkosten</th><th class="zahl">Laufende Kosten</th><th class="zahl optional">Umsatzsteuer</th><th class="zahl">Überschuss</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, ...(p.ohne ?? [])].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"}${p.ohne?.length ? `, ${p.ohne.length} ${p.ohne.length === 1 ? "zählt" : "zählen"} nicht` : ""}</small></td>
|
||
${zahlen(p)}</tr>
|
||
${offen ? `<tr class="details"><td colspan="${spalten}">${posten.length ? `<table class="posten-tabelle"><thead><tr><th>Fällig am</th><th>Was</th><th class="optional">Projekt</th><th class="zaehlt" title="Haken weg = zählt dauerhaft nicht mit">In Rechnung</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("change", (ev) => {
|
||
const el = ev.target as HTMLInputElement;
|
||
if (el.dataset.zaehlt !== undefined) void zaehltSetzen(el.dataset.zaehlt, el.checked, () => void liquiditaetSeite());
|
||
});
|
||
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]));
|
||
projektIds = new Map(projekte.map((p) => [p.nummer as string, p.id as string]));
|
||
const h = heute();
|
||
const ohne = !einst.liquiditaetMitKontostand;
|
||
// 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[]), ...((p.ohne ?? []) as Zeile[])]).filter((x) => !ohne || FLUSS_GRUPPEN.has(x.gruppe))
|
||
.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.zaehltNicht ? 0 : x.betrag) }))
|
||
.filter((x) => !nurProjekt || (x as Zeile).projekt === nurProjekt);
|
||
if (nurProjekt) {
|
||
inhalt.insertAdjacentHTML("beforeend", `<div class="fb-chips"><button class="chip-wahl an" data-nur-weg>Nur ${esc(nurProjekt)} ${esc(namen.get(nurProjekt) ?? "")} ✕</button></div>`);
|
||
inhalt.querySelector<HTMLElement>("[data-nur-weg]")!.onclick = () => { nurProjekt = null; void liquiditaetSeite(); };
|
||
}
|
||
const tabelle = liste({
|
||
schluessel: "liquiditaet-zahlungen", einheit: ["Zahlung", "Zahlungen"], leer: "Keine Zahlungen im Zeitraum.",
|
||
zeilenKlasse: (x) => `${x.ueberfaelligSeit ? "ueber" : x.datum < h ? "vorbei" : ""}${x.zaehltNicht ? " zaehlt-nicht" : ""}`,
|
||
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>` : ""}${x.zaehltNicht ? ' <span class="tag-zaehlt">zählt nicht</span>' : ""}<span class="unter nur-schmal">${esc(x.gruppe)}</span>`, klasse: "text" },
|
||
{ id: "gruppe", titel: "Art", wert: (x) => esc(x.gruppe), klasse: "optional" },
|
||
{ id: "projekt", titel: "Projekt", text: (x) => (x.projekt ? `${x.projekt} ${namen.get(x.projekt) ?? ""}`.trim() : ""), wert: (x) => (x.projekt ? `${projektLink(x.projekt)}${namen.get(x.projekt) ? ` ${esc(namen.get(x.projekt))}` : ""}` : ""), klasse: "optional" },
|
||
{ id: "zaehlt", titel: "In Rechnung", text: (x) => (x.zaehltNicht ? "zählt nicht" : "zählt"), wert: (x) => zaehltHaken(x.quelle ? [x.quelle] : [], !x.zaehltNicht, x.bezeichnung), klasse: "zaehlt" },
|
||
{ 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" },
|
||
...(ohne ? [] : [{ id: "stand", titel: "Kontostand danach", art: "zahl" as const, wert: (x: Zeile) => `<span class="${x.stand < 0 ? "fehler" : ""}">${euro(x.stand)}</span>`, sortWert: (x: Zeile) => x.stand, klasse: "zahl optional" }]),
|
||
],
|
||
zeilen: posten,
|
||
fuss: (l) => (l.length === posten.length ? "" : `<p>Summe der gezeigten Zahlungen: <strong>${euro(l.filter((x) => !x.zaehltNicht).reduce((s, x) => s + x.betrag, 0))}</strong></p>`),
|
||
});
|
||
tabelle.addEventListener("change", (ev) => {
|
||
const el = ev.target as HTMLInputElement;
|
||
if (el.dataset.zaehlt !== undefined) void zaehltSetzen(el.dataset.zaehlt, el.checked, () => void liquiditaetSeite());
|
||
});
|
||
inhalt.append(tabelle);
|
||
}
|
||
|