From 6184665b2db504c88f3bfc5c2d0b1a577cc20bbb Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 21 Oct 2026 21:29:29 +0000 Subject: [PATCH] =?UTF-8?q?Laufende=20Kosten:=20Kacheln,=20Gruppen=20mit?= =?UTF-8?q?=20Summen,=20Zellen=20direkt=20=C3=A4ndern=20(0.23.0)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz --- CHANGELOG.md | 9 ++ package.json | 2 +- src/domain/lage.ts | 8 +- src/web/app.ts | 30 +----- src/web/laufendekosten.ts | 149 ++++++++++++++++++++++++++++ src/web/liste.ts | 199 +++++++++++++++++++++++++++++++++++--- src/web/styles.css | 33 +++++++ test/liquiditaet.test.ts | 13 ++- 8 files changed, 399 insertions(+), 44 deletions(-) create mode 100644 src/web/laufendekosten.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index b6142ba..b5c3f1c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,15 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.23.0 + +- Laufende Kosten neu (Henning, 21.10.2026, Entwurf laufende-kosten/entwurf): oben vier Kacheln Je Monat (alle Rhythmen umgerechnet), Je Jahr, Fällig nächste 30 Tage und Mindestgrenze Liquidität. +- Liste mit „Gruppieren: Gruppe / Kategorie / keine“ (Vorgabe: Gruppe aus dem Projektplaner), Gruppen auf- und zuklappbar mit Anzahl und Summen je Monat und je Jahr; neue Spalten Nächste Zahlung, je Monat, je Jahr und der Hinweis „endet bald“. +- Zellen direkt ändern wie im Terminplan: anklicken, Enter speichert, Esc bricht ab, Tab springt weiter; Rhythmus als Auswahl, Daten als Datumsfeld. Strg+Z oder „Rückgängig“ nimmt zurück, Doppelklick öffnet den Dialog. „+ Position in …“ legt direkt in der Gruppe an; eine Zeile am Griff in eine andere Gruppe ziehen ändert ihre Gruppe. +- Summenzeile rechnet alle Rhythmen auf den Monat um (vorher zählten nur monatliche Positionen), ausgeblendete Zeilen zählen mit. +- Jährliche und vierteljährliche Kosten zählen für Mindestgrenze und Monatssumme schon, wenn ihre erste Zahlung höchstens einen Rhythmus entfernt ist (z. B. Kammerbeitrag am 02.01.). +- Alle Tabellen können jetzt Gruppen, Summenzeilen und direkt änderbare Zellen. + ## 0.22.0 - Jahresplanung (Stufe 5, Henning 21.10.2026, Entwurf finanzen/entwurf-jahresplan), nur für den Inhaber: neuer Menüpunkt mit Reitern Plan aufbauen, 12 Monate und Plan / Ist, Jahr mit ‹ › wählbar. diff --git a/package.json b/package.json index 84cf780..d4df073 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.22.0", + "version": "0.23.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/domain/lage.ts b/src/domain/lage.ts index 21bbc4b..9ca3b73 100644 --- a/src/domain/lage.ts +++ b/src/domain/lage.ts @@ -21,11 +21,17 @@ export interface Lage { danach: Posten | null; } +/** Läuft die Position heute? Die erste Zahlung darf höchstens einen Rhythmus entfernt sein (jährliche also bis 12 Monate) */ +export function laeuftHeute(k: Pick, heute: Datum): boolean { + if (k.rhythmus === "einmalig" || (k.ende && k.ende < heute)) return false; + return k.start <= plusMonate(heute, k.rhythmus === "jaehrlich" ? 12 : k.rhythmus === "vierteljaehrlich" ? 3 : 1); +} + /** Laufende Kosten eines Monats: monatliche voll, vierteljährliche ein Drittel, jährliche ein Zwölftel; nur was heute läuft */ export function laufendJeMonat(laufend: LaufendeKosten[], heute: Datum): Cent { let summe = 0; for (const k of laufend) { - if (k.rhythmus === "einmalig" || k.start > plusMonate(heute, 1) || (k.ende && k.ende < heute)) continue; + if (!laeuftHeute(k, heute)) continue; summe += k.rhythmus === "monatlich" ? k.betrag : k.rhythmus === "vierteljaehrlich" ? k.betrag / 3 : k.betrag / 12; } return Math.round(summe); diff --git a/src/web/app.ts b/src/web/app.ts index 875ed50..3472b61 100644 --- a/src/web/app.ts +++ b/src/web/app.ts @@ -16,6 +16,7 @@ import { angebotSeite, angeboteHtml, angeboteSeite, mengenblattSeite, neuesAngeb import { vorlageSeite } from "./mengenblatt.js"; import { leistungSeite, stammdatenSeite } from "./stammdaten.js"; import { lageKopfHtml, liquiditaetSeite } from "./liquiditaet.js"; +import { laufendeKostenSeite } from "./laufendekosten.js"; import { jahresplanSeite } from "./jahresplan.js"; @@ -528,33 +529,6 @@ async function terminplan(): Promise { ansicht: { lies: gespeicherteAnsicht, setze: ansichtMerken }, auge: [AUGE, AUGE_ZU] }); } -const RHYTHMEN: [string, string][] = [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"], ["jaehrlich", "jährlich"], ["einmalig", "einmalig"]]; -const LK_FELDER: Feld[] = [ - { name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "kategorie", titel: "Kategorie" }, - { 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" }, -]; - -async function laufendeKosten(): Promise { - const neu = async () => (await bearbeiten("laufende-kosten", "Neue laufende Kosten", LK_FELDER, null, { start: heute(), rhythmus: "monatlich" })) && laufendeKosten(); - seite("Laufende Kosten", { text: "Neue Position", aktion: neu }); - const zeilen = await api("laufende-kosten"); - const r = Object.fromEntries(RHYTHMEN); - const monatlich = (l: Zeile[]) => l.filter((z) => z.rhythmus === "monatlich" && (!z.ende || z.ende >= heute())).reduce((s, z) => s + z.betrag, 0); - inhalt.appendChild(liste({ - schluessel: "laufende-kosten", einheit: ["Position", "Positionen"], - spalten: [ - { id: "kategorie", titel: "Kategorie", wert: (z) => esc(z.kategorie) }, { id: "bezeichnung", titel: "Bezeichnung", wert: (z) => esc(z.bezeichnung) }, - { id: "rhythmus", titel: "Rhythmus", wert: (z) => esc(r[z.rhythmus]), sortWert: (z) => RHYTHMEN.findIndex(([k]) => k === z.rhythmus) }, - { id: "start", titel: "Ab", art: "datum", wert: (z) => dat(z.start), sortWert: (z) => z.start, klasse: "optional" }, - { id: "ende", titel: "Endet", art: "datum", wert: (z) => dat(z.ende), sortWert: (z) => z.ende, klasse: "optional" }, - { id: "betrag", titel: "Betrag", art: "zahl", wert: (z) => euro(z.betrag), sortWert: (z) => z.betrag, klasse: "zahl" }, - ], - zeilen, klick: async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && laufendeKosten(), - fuss: (sichtbar) => `

Monatlich${sichtbar.length === zeilen.length ? "" : " (gezeigte Positionen)"}: ${euro(monatlich(sichtbar))}

`, - })); -} - // G4: Kategorien für Aufgaben, im Auswahlmenü über „Kategorien bearbeiten …“ pflegbar const KATEGORIEN_BEARBEITEN = { text: "Kategorien bearbeiten …", aktion: kategorienBearbeiten }; const kategorieOptionen = (liste: Zeile[], leer = "–"): [string, string][] => [["", leer], ...liste.map((k): [string, string] => [k.id, k.name])]; @@ -974,7 +948,7 @@ function reiterFuer(s: Sitzung): Reiter[] { const alle: Reiter[] = [ ["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte], ["terminplan", "Terminplan", terminplan], ["personal", "Personal", () => personalSeite()], ["stunden", "Stunden", stundenSeite], ["kontakte", "Kontakte", kontakte], - ["stammdaten", "Stammdaten", () => stammdatenSeite()], ["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten], + ["stammdaten", "Stammdaten", () => stammdatenSeite()], ["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", () => laufendeKostenSeite()], ]; // Jahresplan und BWA (Stufe 5) nur für den Inhaber if (rolle === "inhaber") alle.push(["jahresplanung", "Jahresplanung", () => jahresplanSeite()], ["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]); diff --git a/src/web/laufendekosten.ts b/src/web/laufendekosten.ts new file mode 100644 index 0000000..b5c5f38 --- /dev/null +++ b/src/web/laufendekosten.ts @@ -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 = { 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) | null = null; +let tasteDa = false; + +export async function laufendeKostenSeite(oeffnen: { id: string; spalte: string } | null = null): Promise { + const [zeilen, e] = await Promise.all([api("laufende-kosten"), api("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 = `
+
Je Monat (umgerechnet)${glatt(monat)}alle Rhythmen auf den Monat gerechnet
+
Je Jahr${glatt(jahr)}${zeilen.length} ${zeilen.length === 1 ? "Position" : "Positionen"} in ${gruppen.size} ${gruppen.size === 1 ? "Gruppe" : "Gruppen"}
+
Fällig nächste 30 Tage${glatt(bald.reduce((s, x) => s + x.betrag, 0))}${bald.length ? `${bald.length} ${bald.length === 1 ? "Zahlung" : "Zahlungen"}, nächste ${dat(erste).slice(0, 6)}` : "keine Zahlung"}
+ Mindestgrenze Liquidität${glatt(fest ? Number(e.mindestreserve) : monat)}${fest ? "fester Betrag (in der Liquidität einstellbar)" : "= 1 Monat laufende Kosten"} +
`; + 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: `${euro(Math.round(m))}`, jeJahr: `${glatt(l.filter((z) => laeuft(z, h)).reduce((s, z) => s + jeJahr(z), 0))}` }; + }; + 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) ? ' endet bald' : ""}`, + 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)) + : `${euro(Math.round(jeJahr(z) / 12))}`) }, + { 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("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 (ausgeblendete zählen mit)', + 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: () => ``, + fuss: () => '

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

', + }); + 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); +} diff --git a/src/web/liste.ts b/src/web/liste.ts index 65c8d87..7f5d44d 100644 --- a/src/web/liste.ts +++ b/src/web/liste.ts @@ -21,6 +21,19 @@ export interface Spalte { kopf?: string; /** ohne Sortieren und Filtern */ fest?: boolean; + /** Zelle direkt ändern wie im Terminplan: Klick öffnet das Feld, Enter speichert, Esc bricht ab, Tab springt weiter */ + bearbeiten?: { art: "text" | "euro" | "datum" | "auswahl"; optionen?: [string, string][]; roh: (z: Zeile) => string; vorschlaege?: string[] }; +} + +/** Zeilen in Gruppen (Henning, 21.10.2026, laufende Kosten): Kopfzeile mit Anzahl und Summen, auf- und zuklappbar */ +export interface Gruppierung { + arten: { id: string; titel: string; wert: (z: Zeile) => string }[]; + /** Art beim ersten Öffnen; "" = keine */ + vorgabe: string; + /** „+ Position in …“ unter jeder Gruppe: legt mit der eingegebenen Bezeichnung an */ + neu?: (art: string, gruppe: string, bezeichnung: string) => Promise; + /** Zeile am Griff in eine andere Gruppe gezogen */ + ziehen?: (z: Zeile, art: string, gruppe: string) => Promise; } export interface ListenOptionen { @@ -45,9 +58,20 @@ export interface ListenOptionen { klasse?: string; /** Zeilen am Griff ⋮⋮ verschieben (ohne Sortierung): bekommt alle IDs in der neuen Reihenfolge */ verschieben?: (ids: string[]) => Promise; + gruppieren?: Gruppierung; + /** Summen je Spalten-ID für Gruppenköpfe und die Summenzeile; bekommt auch ausgeblendete Zeilen, die zählen mit */ + summen?: (zeilen: Zeile[]) => Record; + /** Summenzeile unter der Tabelle mit diesem Titel */ + summenTitel?: string; + /** direkt geänderte Zelle speichern; weiter = Zelle, die danach offen sein soll (Tab). Fehler bleiben im Feld stehen. */ + aendern?: (z: Zeile, spalte: string, wert: string, weiter: { id: string; spalte: string } | null) => Promise; + /** nach dem Neuaufbau diese Zelle gleich zum Ändern öffnen */ + oeffnen?: { id: string; spalte: string } | null; + /** weitere Knöpfe in der Leiste (z. B. Rückgängig) */ + leiste?: () => string; } -interface Gespeichert { aktuell?: unknown; name?: string | null; ansichten?: { name: string; ansicht: unknown }[] } +interface Gespeichert { aktuell?: unknown; name?: string | null; ansichten?: { name: string; ansicht: unknown }[]; gruppe?: string; zu?: string[] } let speicher: Record = {}; const warten = new Map>(); @@ -261,6 +285,7 @@ export function liste(o: ListenOptionen): HTMLElement { const zeigen = sortiere(zeigeAus ? gefiltert : gefiltert.filter((i) => !ausSet.has(ids[i]!)), a.sort, sw); const filterIds = beweglich.map((s) => s.id).filter((id) => a.filter[id]?.length || a.zeit[id]); const geaendert = !gleich(a, basis(name)); + const art = gruppenArt(); const sortChip = a.sort.length ? `Sortiert: ${a.sort.map(([id, r], n) => `${a.sort.length > 1 ? `${n + 1}. ` : ""}${esc(spalte(id)?.titel ?? id)} ${r === "auf" ? "↑" : "↓"}`).join(" · ")}` : ""; const chips = filterIds.map((id) => ``).join(""); @@ -268,8 +293,9 @@ export function liste(o: ListenOptionen): HTMLElement { const leiste = leisteZeigen ? `
${o.klein ? "" : ``} ${o.klein ? "" : ''} + ${o.gruppieren ? `` : ""} ${sortChip}${chips} - ${geaendert ? '' : ""}
` : ""; + ${geaendert ? '' : ""}${o.leiste ? `${o.leiste()}` : ""}` : ""; const kopf = o.spalten.map((s) => { if (s.fest) return `${s.kopf ?? esc(s.titel)}`; @@ -279,25 +305,139 @@ export function liste(o: ListenOptionen): HTMLElement { return ` `; }).join(""); - const griff = !!o.verschieben && !a.sort.length; + const griff = (!!o.verschieben && !a.sort.length) || (!!art && !!o.gruppieren?.ziehen); + const griffZelle = griff ? '' : ""; const zeile = (i: number) => { const x = z[i]!, weg = ausSet.has(ids[i]!); - return `${griff ? '⋮⋮' : ""}${o.spalten.map((s) => `${s.wert(x)}`).join("")} + return `${griff ? '⋮⋮' : ""}${o.spalten.map((s) => `${s.wert(x)}`).join("")} `; }; + // Summenzeile im Spaltenraster: Titel über die Spalten bis zur ersten Summe + const summenZellen = (titel: string, werte: Record) => { + const erste = o.spalten.findIndex((s) => werte[s.id] !== undefined); + const span = erste < 1 ? o.spalten.length : erste; + return `${griffZelle}${titel}${o.spalten.slice(span).map((s) => `${werte[s.id] ?? ""}`).join("")}`; + }; const breite = o.spalten.length + 1 + (griff ? 1 : 0); + let zeilenHtml = zeigen.map(zeile).join(""); + if (art && zeigen.length) { + const schluessel = (i: number) => art.wert(z[i]!); + const namen = [...new Set(gefiltert.map(schluessel))].sort((x, y) => (x === "" ? 1 : y === "" ? -1 : x.localeCompare(y, "de", { numeric: true }))); + const zu = new Set(g.zu ?? []); + zeilenHtml = namen.map((k) => { + const hier = zeigen.filter((i) => schluessel(i) === k); + const alle = gefiltert.filter((i) => schluessel(i) === k); + const geschlossen = zu.has(`${art.id}:${k}`); + const titel = ` · ${alle.length}`; + const neu = o.gruppieren?.neu && !geschlossen ? `${griffZelle}` : ""; + return `${summenZellen(titel, o.summen?.(alle.map((i) => z[i]!)) ?? {})}${geschlossen ? "" : hier.map(zeile).join("")}${neu}`; + }).join(""); + } const rumpf = !z.length ? `${esc(o.leer ?? "Noch nichts eingetragen.")}` : !zeigen.length ? `${versteckt.length ? "Alle passenden Zeilen sind ausgeblendet." : "Nichts passt zu den Filtern."} ` - : zeigen.map(zeile).join(""); + : zeilenHtml; + const fussZeile = o.summenTitel && o.summen && z.length ? `${summenZellen(o.summenTitel, o.summen(gefiltert.map((i) => z[i]!)))}` : ""; const [eins, mehr] = o.einheit ?? ["Eintrag", "Einträge"]; const sichtbar = zeigen.length; const anzahl = !z.length ? "" : `${sichtbar === z.length ? `${z.length} ${z.length === 1 ? eins : mehr}` : `${sichtbar} von ${z.length} ${z.length === 1 ? eins : mehr}`}${versteckt.length ? ` · ${versteckt.length} ausgeblendet · ${zeigeAus ? ' · ' : ""}` : ""}`; - wurzel.innerHTML = `${leiste}
${griff ? '' : ""}${kopf}${rumpf}
- ${o.verschieben && a.sort.length && z.length > 1 ? '

Zum Verschieben der Zeilen die Sortierung entfernen.

' : ""} + wurzel.innerHTML = `${leiste}
${griff ? '' : ""}${kopf}${rumpf}${fussZeile}
+ ${o.verschieben && a.sort.length && z.length > 1 && !art ? '

Zum Verschieben der Zeilen die Sortierung entfernen.

' : ""} ${anzahl && (!o.klein || sichtbar !== z.length || versteckt.length) ? `

${anzahl}

` : ""}${o.fuss ? o.fuss(zeigen.filter((i) => !ausSet.has(ids[i]!)).map((i) => z[i]!)) : ""}`; } + function gruppenArt() { + const gr = o.gruppieren; + if (!gr) return null; + return gr.arten.find((x) => x.id === (g.gruppe ?? gr.vorgabe)) ?? null; + } + + function gruppenMenue(anker: HTMLElement): void { + const gr = o.gruppieren!; + const jetzt = gruppenArt()?.id ?? ""; + const m = menue(anker, `
Gruppieren nach
+ ${[...gr.arten.map((x) => [x.id, x.titel]), ["", "keine"]].map(([id, t]) => ``).join("")}`); + m.addEventListener("click", (ev) => { + const b = (ev.target as HTMLElement).closest("[data-gr],[data-m]"); + if (!b) return; + menueSchliessen(); + if (b.dataset.gr === undefined) return; + g.gruppe = b.dataset.gr; + merken(o.schluessel); + zeichne(); + }); + } + + // Zellen direkt ändern (Henning, 21.10.2026): wie im Terminplan + const editierbar = o.aendern ? o.spalten.filter((s) => s.bearbeiten).map((s) => s.id) : []; + function nachbar(i: number, sid: string, schritt: 1 | -1): { id: string; spalte: string } | null { + const k = editierbar.indexOf(sid) + schritt; + if (k >= 0 && k < editierbar.length) return { id: ids[i]!, spalte: editierbar[k]! }; + const reihen = [...wurzel.querySelectorAll("tbody tr[data-i]")].map((t) => Number(t.dataset.i)); + const n = reihen[reihen.indexOf(i) + schritt]; + return n === undefined ? null : { id: ids[n]!, spalte: editierbar[schritt > 0 ? 0 : editierbar.length - 1]! }; + } + function starte(i: number, sid: string): void { + const td = wurzel.querySelector(`tr[data-i="${i}"] td[data-b="${sid}"]`); + const b = o.spalten.find((s) => s.id === sid)?.bearbeiten; + if (!td || !b || td.classList.contains("in-arbeit")) return; + const x = z[i]!, roh = b.roh(x); + const liste = b.vorschlaege?.length ? `${b.vorschlaege.map((v) => `` : ""; + td.innerHTML = b.art === "auswahl" + ? `` + : `${liste}`; + td.classList.add("in-arbeit"); + td.dataset.seit = String(Date.now()); + const ed = td.querySelector(".zelle-ed")!; + ed.focus(); + if (ed instanceof HTMLInputElement && ed.type === "text") ed.select(); + let fertig = false; + const abschliessen = async (speichern: boolean, weiter: { id: string; spalte: string } | null) => { + if (fertig) return; + fertig = true; + if (!speichern || ed.value === roh) { + zeichne(); + if (weiter) oeffne(weiter); + return; + } + try { await o.aendern!(x, sid, ed.value, weiter); } catch (e) { + fertig = false; + td.classList.add("fehler-zelle"); + ed.title = (e as Error).message; + ed.focus(); + } + }; + ed.addEventListener("keydown", (ev) => { + const k = (ev as KeyboardEvent).key; + if (k === "Enter") { ev.preventDefault(); void abschliessen(true, null); } + else if (k === "Escape") { ev.preventDefault(); ev.stopPropagation(); void abschliessen(false, null); } + else if (k === "Tab") { ev.preventDefault(); void abschliessen(true, nachbar(i, sid, (ev as KeyboardEvent).shiftKey ? -1 : 1)); } + }); + if (ed instanceof HTMLSelectElement) ed.addEventListener("change", () => void abschliessen(true, null)); + ed.addEventListener("blur", () => setTimeout(() => { if (!fertig && document.activeElement !== ed) void abschliessen(true, null); }, 0)); + } + function oeffne(w: { id: string; spalte: string }): void { + const i = ids.indexOf(w.id); + if (i >= 0) starte(i, w.spalte); + } + // neue Position unter einer Gruppe: erst nur die Bezeichnung, Enter legt an + function neueZeile(tr: HTMLElement, gruppe: string): void { + const art = gruppenArt(); + if (!art || !o.gruppieren?.neu) return; + const td = tr.querySelector("td[colspan]")!; + td.innerHTML = ``; + const ed = td.querySelector("input")!; + ed.focus(); + let fertig = false; + ed.addEventListener("keydown", async (ev) => { + if (ev.key === "Escape") { fertig = true; zeichne(); } + if (ev.key !== "Enter" || !ed.value.trim() || fertig) return; + fertig = true; + try { await o.gruppieren!.neu!(art.id, gruppe, ed.value.trim()); } catch (e) { fertig = false; ed.title = (e as Error).message; td.classList.add("fehler-zelle"); } + }); + ed.addEventListener("blur", () => setTimeout(() => { if (!fertig && !ed.value.trim()) { fertig = true; zeichne(); } }, 0)); + } + function spaltenMenue(id: string, anker: HTMLElement): void { const s = spalte(id); const nr = a.sort.findIndex(([x]) => x === id); @@ -362,22 +502,24 @@ export function liste(o: ListenOptionen): HTMLElement { // Zeilen ziehen wie im Terminplan, mit Zeigerereignissen (auch am Tablet) wurzel.addEventListener("pointerdown", (ev) => { const g = (ev.target as HTMLElement).closest("[data-griff]"); - if (!g || ev.button !== 0 || !o.verschieben) return; + const art = gruppenArt(); + const inGruppe = !!art && !!o.gruppieren?.ziehen; + if (!g || ev.button !== 0 || !(o.verschieben || inGruppe)) return; ev.preventDefault(); const tr = g.closest("tr[data-i]")!; const von = Number(tr.dataset.i); g.setPointerCapture(ev.pointerId); - let ziel: { i: number; nach: boolean } | null = null; + let ziel: { i: number; nach: boolean; g?: string } | null = null; const markiere = () => wurzel.querySelectorAll("tr.einfuege-vor,tr.einfuege-nach").forEach((x) => x.classList.remove("einfuege-vor", "einfuege-nach")); const zieh = (e: PointerEvent) => { markiere(); tr.classList.add("gezogen"); - const zeilen = [...wurzel.querySelectorAll("tbody tr[data-i]")]; + const zeilen = [...wurzel.querySelectorAll(inGruppe ? "tbody tr[data-g]" : "tbody tr[data-i]")]; const t = zeilen.find((x) => { const r = x.getBoundingClientRect(); return e.clientY >= r.top && e.clientY < r.bottom; }) ?? (e.clientY < zeilen[0]!.getBoundingClientRect().top ? zeilen[0] : zeilen.at(-1)); if (!t || t === tr) { ziel = null; return; } const r = t.getBoundingClientRect(); - ziel = { i: Number(t.dataset.i), nach: e.clientY > r.top + r.height / 2 }; + ziel = { i: Number(t.dataset.i), nach: inGruppe || e.clientY > r.top + r.height / 2, g: t.dataset.g }; t.classList.add(ziel.nach ? "einfuege-nach" : "einfuege-vor"); }; const los = async () => { @@ -385,6 +527,10 @@ export function liste(o: ListenOptionen): HTMLElement { markiere(); tr.classList.remove("gezogen"); if (!ziel) return; + if (inGruppe) { + if (ziel.g !== undefined && ziel.g !== art!.wert(z[von]!)) await o.gruppieren!.ziehen!(z[von]!, art!.id, ziel.g); + return; + } const neu = ids.filter((x) => x !== ids[von]); const pos = neu.indexOf(ids[ziel.i]!) + (ziel.nach ? 1 : 0); neu.splice(pos, 0, ids[von]!); @@ -397,10 +543,19 @@ export function liste(o: ListenOptionen): HTMLElement { wurzel.addEventListener("click", (ev) => { const t = ev.target as HTMLElement; - const knopf = t.closest("[data-menue],[data-aus],[data-chip-weg],[data-a]"); + const knopf = t.closest("[data-menue],[data-aus],[data-chip-weg],[data-a],[data-zu],[data-neu]"); if (knopf && wurzel.contains(knopf)) { ev.stopPropagation(); if (knopf.dataset.menue) return spaltenMenue(knopf.dataset.menue, knopf); + if (knopf.dataset.zu !== undefined) { + const k = `${gruppenArt()?.id}:${knopf.dataset.zu}`; + const zu = new Set(g.zu ?? []); + if (zu.has(k)) zu.delete(k); else zu.add(k); + g.zu = [...zu]; + merken(o.schluessel); + return zeichne(); + } + if (knopf.dataset.neu !== undefined) return neueZeile(knopf.closest("tr")!, knopf.dataset.neu); if (knopf.dataset.aus) { const id = knopf.dataset.aus; return setze({ ...a, aus: a.aus.includes(id) ? a.aus.filter((x) => x !== id) : [...a.aus, id] }); @@ -419,15 +574,33 @@ export function liste(o: ListenOptionen): HTMLElement { case "alle-ein": zeigeAus = false; return setze({ ...a, aus: a.aus.filter((x) => !ids.includes(x)) }); case "ansichten": return ansichtenMenue(knopf); case "spalten": return spaltenAuswahl(knopf); + case "gruppieren": return gruppenMenue(knopf); } return; } // Zeile anklicken öffnet sie; Links, Knöpfe und Eingaben in der Zeile behalten ihre eigene Wirkung - if (!o.klick || t.closest("a,button,input,select,label,textarea,[data-griff]")) return; + if (t.closest("a,button,input,select,label,textarea,[data-griff]")) return; + const tr = t.closest("tr[data-i]"); + if (!tr || !wurzel.contains(tr)) return; + // mit direkt änderbaren Zellen: Klick ändert die Zelle, Doppelklick öffnet den Dialog + if (editierbar.length) { + const td = t.closest("td[data-b]"); + if (td) starte(Number(tr.dataset.i), td.dataset.b!); + return; + } + if (o.klick) o.klick(z[Number(tr.dataset.i)]!); + }); + wurzel.addEventListener("dblclick", (ev) => { + const t = ev.target as HTMLElement; + if (!editierbar.length || !o.klick || t.closest("a,button,[data-griff]")) return; + // in einem schon länger offenen Feld wählt der Doppelklick nur ein Wort aus + const offen = t.closest("td.in-arbeit"); + if (offen && Date.now() - Number(offen.dataset.seit) > 700) return; const tr = t.closest("tr[data-i]"); if (tr && wurzel.contains(tr)) o.klick(z[Number(tr.dataset.i)]!); }); zeichne(); + if (o.oeffnen) { const w = o.oeffnen; setTimeout(() => oeffne(w)); } return wurzel; } diff --git a/src/web/styles.css b/src/web/styles.css index 3f403bc..5ae91d2 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -1485,3 +1485,36 @@ input.jp-notiz { width: 100%; min-width: 140px; border: 1px solid var(--linie); .knopf-datei { margin-left: 0; } } .jp-monate .karte-kopf { flex-wrap: wrap; gap: 8px; } + +/* Laufende Kosten (Henning, 21.10.2026): Kacheln, Gruppen mit Summen, Zellen direkt ändern */ +.lk-kacheln { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px; margin-bottom: 16px; } +.lk-kachel { display: flex; flex-direction: column; gap: 2px; background: var(--fl); border: 1px solid var(--linie); border-radius: 10px; padding: 14px 16px; min-width: 0; color: inherit; text-decoration: none; } +.lk-kachel.haupt { border-left: 4px solid var(--akzent); } +.lk-kachel span { color: var(--leise); font-size: 14px; } +.lk-kachel b { font-size: 26px; font-variant-numeric: tabular-nums; } +.lk-kachel small { color: var(--leise); } +a.lk-kachel:hover { border-color: var(--akzent); } +.lk-karte { padding: 14px 16px; } +.liste-leiste .leiste-rechts { margin-left: auto; display: inline-flex; gap: 6px; } +.liste-leiste .leiste-rechts button:disabled { opacity: 0.5; cursor: default; } +table.gruppiert tr.gruppen-kopf td { background: var(--bg); font-weight: 600; border-top: 1px solid var(--linie); } +tr.gruppen-kopf small { color: var(--leise); font-weight: 400; } +.gruppe-knopf { all: unset; cursor: pointer; display: inline-flex; gap: 6px; align-items: center; font-weight: 600; border-radius: 4px; } +.gruppe-knopf:focus-visible { outline: 2px solid var(--akzent); outline-offset: 2px; } +.gruppe-knopf .pfeil { display: inline-block; transition: transform 0.15s; color: var(--leise); font-size: 12px; } +tr.gruppen-kopf.zu .pfeil { transform: rotate(-90deg); } +tr.gruppen-neu td { padding-top: 4px; padding-bottom: 8px; } +tr.gruppen-neu .verweis { font-weight: 600; } +tfoot tr.summen-zeile td { border-top: 2px solid var(--text); font-weight: 600; padding-top: 10px; } +tfoot tr.summen-zeile small { font-weight: 400; color: var(--leise); } +td.editierbar { cursor: text; } +td.editierbar:hover { box-shadow: inset 0 0 0 1px var(--linie); border-radius: 4px; } +td.in-arbeit { padding: 2px 4px; } +.zelle-ed { width: 100%; min-width: 90px; box-sizing: border-box; padding: 5px 7px; border: 2px solid var(--akzent); border-radius: 6px; font: inherit; background: var(--fl); color: var(--text); } +.zelle-ed.zahl { text-align: right; } +td.fehler-zelle .zelle-ed { border-color: var(--warn); background: var(--warnung-bg); } +.lk-bald { display: inline-block; margin-left: 6px; padding: 1px 7px; border-radius: 999px; font-size: 12px; background: var(--warnung-bg); color: var(--warnung-text); white-space: nowrap; } +.lk-spaeter { color: var(--leise); font-style: italic; } +.lk-hilfe { font-size: 13px; margin-top: 8px; } +@media (max-width: 1100px) { .lk-kacheln { grid-template-columns: repeat(2, minmax(0, 1fr)); } } +@media (max-width: 500px) { .lk-kachel b { font-size: 22px; } .lk-hilfe { display: none; } } diff --git a/test/liquiditaet.test.ts b/test/liquiditaet.test.ts index ccdc054..596531a 100644 --- a/test/liquiditaet.test.ts +++ b/test/liquiditaet.test.ts @@ -1,7 +1,7 @@ import { describe, it, expect } from "vitest"; import { liquiditaet, periodenGrenzen, termineLaufend, projektBewegungen, type ProjektPlan } from "../src/domain/liquiditaet.js"; import { faelligkeit, zeitraumVon } from "../src/domain/umsatzsteuer.js"; -import { lage, laufendJeMonat } from "../src/domain/lage.js"; +import { lage, laeuftHeute, laufendJeMonat } from "../src/domain/lage.js"; describe("Umsatzsteuer-Fälligkeit", () => { it("10. des Folgemonats, Wochenende verschiebt auf Montag", () => { @@ -165,6 +165,17 @@ describe("Lage der Liquidität (Henning, 21.10.2026)", () => { expect(liquiditaet(daten, { ...v, offeneAb: undefined }).flatMap((p) => p.posten).find((p) => p.bezeichnung === "1. Rate")).toBeUndefined(); }); + it("jährliche Kosten mit erster Zahlung in den nächsten 12 Monaten laufen schon (Henning, 21.10.2026)", () => { + const h = "2026-10-21"; + expect(laeuftHeute({ rhythmus: "jaehrlich", start: "2027-01-02" }, h)).toBe(true); + expect(laeuftHeute({ rhythmus: "jaehrlich", start: "2027-11-01" }, h)).toBe(false); + expect(laeuftHeute({ rhythmus: "vierteljaehrlich", start: "2027-01-15" }, h)).toBe(true); + expect(laeuftHeute({ rhythmus: "monatlich", start: "2027-01-01" }, h)).toBe(false); + expect(laeuftHeute({ rhythmus: "monatlich", start: "2026-01-01", ende: "2026-10-01" }, h)).toBe(false); + expect(laeuftHeute({ rhythmus: "einmalig", start: "2026-11-01" }, h)).toBe(false); + expect(laufendJeMonat([{ bezeichnung: "Kammer", betrag: 120_000, rhythmus: "jaehrlich", start: "2027-01-02" }], h)).toBe(10_000); + }); + it("Mindestgrenze aus den laufenden Kosten, Tiefpunkt mit Grund", () => { expect(laufendJeMonat(daten.laufend, "2026-10-21")).toBe(310_000); const w = liquiditaet(daten, v);