From 83828c12f8507414aaa52f85fb314c32270aad35 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 26 Oct 2026 09:34:21 +0000 Subject: [PATCH] =?UTF-8?q?Haken=20=E2=80=9Ez=C3=A4hlt=E2=80=9C:=20Posten?= =?UTF-8?q?=20dauerhaft=20aus=20der=20Liquidit=C3=A4t=20nehmen=20(0.41.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 | 6 ++ demo/kern.ts | 2 + package.json | 2 +- src/domain/liquiditaet.ts | 47 +++++++++--- src/domain/projektplan.ts | 11 ++- src/server/app.ts | 29 +++++++- src/server/migrations/027_zaehlt.sql | 8 ++ src/server/tabellen.ts | 2 + src/web/app.ts | 19 ++++- src/web/liquiditaet.ts | 105 +++++++++++++++++++-------- src/web/styles.css | 19 ++++- test/api.test.ts | 26 +++++++ test/liquiditaet.test.ts | 30 ++++++++ 13 files changed, 257 insertions(+), 49 deletions(-) create mode 100644 src/server/migrations/027_zaehlt.sql diff --git a/CHANGELOG.md b/CHANGELOG.md index b97f075..dda0d39 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,12 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.41.0 (26.10.2026) + +- Haken **„zählt“** (Hennings Kommentar „Zahlungen muss ich mit einem Haken summenunwirksam machen können“ und „füge das Häkchen zwischen Was und Betrag ein und setze das so um“ vom 26.10.2026 zum Bild summenunwirksam.png): In der Liquidität unter „Kommt rein“ und „Geht raus“ steht zwischen „Was“ und „Betrag“ eine Spalte „zählt“. Haken weg = der Posten zählt dauerhaft nicht mehr mit, weder in den Summen noch in der Kurve, im Monatsplan, in „Alle Zahlungen“, in der Übersicht oder in der Umsatzsteuer-Schätzung. Er bleibt grau durchgestrichen mit „zählt nicht“ sichtbar; unter der Liste steht „n Posten zählt nicht · alle wieder zählen“. +- Gilt für Raten, Eingangsrechnungen, Pauschalen aus den Eckdaten, die Schlussrechnung (Rest) und laufende Kosten (je Monat). Bei Pauschalen bleibt der Eckdaten-Wert im Projekt stehen, nur die Liquidität rechnet ohne ihn. Eine Eingangsrechnung ohne Haken mindert die Pauschale weiter. +- Derselbe Haken steht im Zahlungsplan des Projekts bei Raten und Eingangsrechnungen; darunter steht, was nicht in der Liquidität zählt. Anders als das Auge (nur ausblenden) und „Was wäre, wenn“ (nur probeweise) wird der Haken gespeichert. + ## 0.40.0 (26.10.2026) - Projektnummern (Hennings Kommentar und OK vom 26.10.2026 zum Bild projektnummern.png): Eine Nummer, deren Jahr und Zahl schon ein anderes Projekt hat, lehnt das Programm ab, egal mit welchem Buchstaben oder ob mit Bindestrich. Der Dialog nennt das Projekt und bietet „Nächste freie nehmen“ an; Teilaufträge wie 26-007.1 und 26-007.2 bleiben erlaubt. diff --git a/demo/kern.ts b/demo/kern.ts index a4c7516..8981384 100644 --- a/demo/kern.ts +++ b/demo/kern.ts @@ -28,6 +28,7 @@ import m023 from "../src/server/migrations/023_vierteltage.sql"; import m024 from "../src/server/migrations/024_nextcloud_zugang.sql"; import m025 from "../src/server/migrations/025_status_intern.sql"; import m026 from "../src/server/migrations/026_zahlung_bezahlt.sql"; +import m027 from "../src/server/migrations/027_zaehlt.sql"; const MIGRATIONEN: [string, string][] = [ ["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004], @@ -51,6 +52,7 @@ const MIGRATIONEN: [string, string][] = [ ["024_nextcloud_zugang.sql", m024], ["025_status_intern.sql", m025], ["026_zahlung_bezahlt.sql", m026], + ["027_zaehlt.sql", m027], ]; export async function starte(db: PGlite, v70?: unknown) { diff --git a/package.json b/package.json index 7d5f13a..a919837 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.40.0", + "version": "0.41.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/domain/liquiditaet.ts b/src/domain/liquiditaet.ts index 37fb5fc..0e5bd4b 100644 --- a/src/domain/liquiditaet.ts +++ b/src/domain/liquiditaet.ts @@ -27,6 +27,10 @@ export interface Einnahme { bezahlt?: boolean; /** Rechnung gestellt (sonst nur geplant) */ gestellt?: boolean; + /** Herkunft für den Haken „zählt“, z. B. zahlung: */ + quelle?: string; + /** Haken „zählt“ weg: bleibt sichtbar, zählt aber nicht mit (auch nicht in der Umsatzsteuer) */ + zaehltNicht?: boolean; } export interface Ausgabe { @@ -38,6 +42,8 @@ export interface Ausgabe { zahlungszielTage?: number; /** false z. B. bei Subunternehmern im Reverse-Charge oder Kleinunternehmern */ mitVorsteuer?: boolean; + quelle?: string; + zaehltNicht?: boolean; } export interface LaufendeKosten { @@ -48,6 +54,9 @@ export interface LaufendeKosten { rhythmus: Rhythmus; start: Datum; ende?: Datum; + id?: string; + /** einzelne Termine, die nicht zählen (Haken „zählt“ in der Liquidität) */ + ohneTermine?: Datum[]; } export interface Zahlungsziele { @@ -88,6 +97,9 @@ export interface Posten { gestellt?: boolean; /** Einnahme, die seit diesem Tag fällig und noch nicht bezahlt ist */ ueberfaelligSeit?: Datum; + /** woher der Posten kommt: zahlung:, kosten:, pauschale::, rest:, lk:: */ + quelle?: string; + zaehltNicht?: boolean; } export interface Periode { @@ -98,6 +110,8 @@ export interface Periode { saldo: Cent; kontostand: Cent; posten: Posten[]; + /** Posten ohne Haken „zählt“: nur zum Anzeigen, in keiner Summe */ + ohne?: Posten[]; } function zielFuer(art: Kostenart, z: Zahlungsziele): number { @@ -141,6 +155,8 @@ export interface Daten { laufend: LaufendeKosten[]; } +const markiert = (x: { quelle?: string; zaehltNicht?: boolean }) => ({ ...(x.quelle ? { quelle: x.quelle } : {}), ...(x.zaehltNicht ? { zaehltNicht: true } : {}) }); + /** Alle Zahlungsbewegungen mit ihrem Zahltag, ohne Zeitraumfilter (außer laufende Kosten). */ export function bewegungen(d: Daten, v: Vorschau, bis: Datum): Posten[] { const ziele = v.ziele ?? STANDARD_ZIELE; @@ -154,18 +170,19 @@ export function bewegungen(d: Daten, v: Vorschau, bis: Datum): Posten[] { const steuer = ustAusNetto(e.netto, ust.satz); const zahltag = e.bezahltAm ?? plusTage(e.termin, e.zahlungszielTage ?? ziele.kundenTage); posten.push({ datum: zahltag, gruppe: "Projekteinnahmen", projekt: e.projekt, bezeichnung: e.bezeichnung, betrag: e.netto + steuer, - ...(e.bezahltAm || e.bezahlt ? { bezahlt: true } : {}), ...(e.gestellt ? { gestellt: true } : {}) }); - buche(zeitraumVon(ust.versteuerung === "ist" ? zahltag : e.termin, ust.voranmeldung), e.netto); + ...(e.bezahltAm || e.bezahlt ? { bezahlt: true } : {}), ...(e.gestellt ? { gestellt: true } : {}), ...markiert(e) }); + if (!e.zaehltNicht) buche(zeitraumVon(ust.versteuerung === "ist" ? zahltag : e.termin, ust.voranmeldung), e.netto); } for (const a of d.ausgaben) { const vorsteuer = a.mitVorsteuer === false ? 0 : ustAusNetto(a.netto, ust.satz); const zahltag = plusTage(a.termin, a.zahlungszielTage ?? zielFuer(a.art, ziele)); - posten.push({ datum: zahltag, gruppe: "Projektkosten", projekt: a.projekt, bezeichnung: a.bezeichnung, betrag: -(a.netto + vorsteuer) }); - if (a.mitVorsteuer !== false) buche(zeitraumVon(ust.versteuerung === "ist" ? zahltag : a.termin, ust.voranmeldung), -a.netto); + posten.push({ datum: zahltag, gruppe: "Projektkosten", projekt: a.projekt, bezeichnung: a.bezeichnung, betrag: -(a.netto + vorsteuer), ...markiert(a) }); + if (a.mitVorsteuer !== false && !a.zaehltNicht) buche(zeitraumVon(ust.versteuerung === "ist" ? zahltag : a.termin, ust.voranmeldung), -a.netto); } for (const k of d.laufend) { for (const t of termineLaufend(k, v.start < k.start ? v.start : k.start, bis)) { - posten.push({ datum: t, gruppe: "Laufende Kosten", bezeichnung: k.bezeichnung, betrag: -k.betrag }); + posten.push({ datum: t, gruppe: "Laufende Kosten", bezeichnung: k.bezeichnung, betrag: -k.betrag, + ...(k.id ? { quelle: `lk:${k.id}:${t}` } : {}), ...(k.ohneTermine?.includes(t) ? { zaehltNicht: true } : {}) }); } } for (const [zeitraum, basis] of [...basisJeZeitraum].sort()) { @@ -184,6 +201,10 @@ export function bewegungen(d: Daten, v: Vorschau, bis: Datum): Posten[] { /** Ein Projekt mit seinen Pauschalen, Zahlungen und einzeln erfassten Kosten. */ export interface ProjektPlan { projekt: string; + /** Projekt-id für die Herkunft von Pauschalen und Rest */ + id?: string; + /** was davon nicht zählt: material, fremd, sonstiges, rest */ + ohne?: string[]; umsatz: Cent; material: Cent; fremd: Cent; @@ -211,7 +232,8 @@ export function projektBewegungen(p: ProjektPlan): { einnahmen: Einnahme[]; ausg if (!p.zeitraum) return { einnahmen: [...p.zahlungen], ausgaben: [...p.kosten] }; const einnahmen = [...p.zahlungen]; const rest = p.umsatz - summe(p.zahlungen.map((z) => z.netto)); - if (rest > 0) einnahmen.push({ projekt: p.projekt, bezeichnung: "Schlussrechnung (Rest)", netto: rest, termin: p.zeitraum.ende }); + const herkunft = (teil: string, quelle: string) => ({ ...(p.id ? { quelle } : {}), ...(p.ohne?.includes(teil) ? { zaehltNicht: true } : {}) }); + if (rest > 0) einnahmen.push({ projekt: p.projekt, bezeichnung: "Schlussrechnung (Rest)", netto: rest, termin: p.zeitraum.ende, ...herkunft("rest", `rest:${p.id}`) }); const ausgaben = [...p.kosten]; const pauschal = p.material + p.fremd + p.sonstiges; @@ -224,7 +246,7 @@ export function projektBewegungen(p: ProjektPlan): { einnahmen: Einnahme[]; ausg ]; for (const [art, betrag, bezeichnung, mitVorsteuer] of teile) { const netto = anteilig(betrag, bleibt, pauschal); - if (netto > 0) ausgaben.push({ projekt: p.projekt, bezeichnung, art, netto, termin: p.zeitraum.start, mitVorsteuer }); + if (netto > 0) ausgaben.push({ projekt: p.projekt, bezeichnung, art, netto, termin: p.zeitraum.start, mitVorsteuer, ...herkunft(art, `pauschale:${p.id}:${art}`) }); } } return { einnahmen, ausgaben }; @@ -242,14 +264,19 @@ export function liquiditaet(d: Daten, v: Vorschau): Periode[] { if (p.datum < erster) p.datum = heute; } } - if (v.ergaenzen) alle.push(...v.ergaenzen(alle)); + // Haken „zählt“ weg: bleibt zum Anzeigen, rechnet aber nirgends mit + const ohne = alle.filter((p) => p.zaehltNicht); + const zaehlen = alle.filter((p) => !p.zaehltNicht); + if (v.ergaenzen) zaehlen.push(...v.ergaenzen(zaehlen)); let kontostand = v.startsaldo; + const imZeitraum = (l: Posten[], von: Datum, bis: Datum) => l.filter((p) => p.datum >= von && p.datum <= bis).sort((a, b) => a.datum.localeCompare(b.datum)); return grenzen.map(({ von, bis }) => { - const posten = alle.filter((p) => p.datum >= von && p.datum <= bis).sort((a, b) => a.datum.localeCompare(b.datum)); + const posten = imZeitraum(zaehlen, von, bis); + const weg = imZeitraum(ohne, von, bis); const einnahmen = summe(posten.filter((p) => p.betrag > 0).map((p) => p.betrag)); const ausgaben = summe(posten.filter((p) => p.betrag < 0).map((p) => p.betrag)); const saldo = einnahmen + ausgaben; kontostand += saldo; - return { von, bis, einnahmen, ausgaben, saldo, kontostand, posten }; + return { von, bis, einnahmen, ausgaben, saldo, kontostand, posten, ...(weg.length ? { ohne: weg } : {}) }; }); } diff --git a/src/domain/projektplan.ts b/src/domain/projektplan.ts index 0b18048..98919a8 100644 --- a/src/domain/projektplan.ts +++ b/src/domain/projektplan.ts @@ -16,6 +16,8 @@ export interface BestandProjekt { material_kosten: Cent; fremd_kosten: Cent; sonstige_kosten: Cent; + /** Pauschalen und Rest, die in der Liquidität nicht zählen (material, fremd, sonstiges, rest) */ + liqui_ohne?: string[] | null; } export interface BestandVorgang { @@ -28,7 +30,10 @@ export interface BestandVorgang { } export interface BestandZahlung { + id?: string; projekt_id: string; + /** Haken „zählt“ (false = zählt in der Liquidität nicht mit) */ + zaehlt?: boolean; vorgang_id?: string | null; bezug_art?: BezugArt; bezug_tage?: number; @@ -43,7 +48,9 @@ export interface BestandZahlung { } export interface BestandKosten { + id?: string; projekt_id: string; + zaehlt?: boolean; art: Kostenart; bezeichnung: string; netto: Cent; @@ -109,6 +116,7 @@ export function liquiditaetsDaten(b: Bestand, woche: Arbeitswoche, mitAngeboten bezahlt: z.status === "bezahlt", gestellt: z.status === "gestellt" || !!z.rechnungsdatum, zahlungszielTage: z.zahlungsziel_tage ?? undefined, + ...(z.id ? { quelle: `zahlung:${z.id}` } : {}), ...(z.zaehlt === false ? { zaehltNicht: true } : {}), })); const kosten: Ausgabe[] = b.kosten .filter((k) => k.projekt_id === p.id) @@ -116,9 +124,10 @@ export function liquiditaetsDaten(b: Bestand, woche: Arbeitswoche, mitAngeboten projekt: p.nummer, bezeichnung: k.bezeichnung, art: k.art, netto: k.netto, termin: (k.status !== "bezahlt" ? bezogen(k) : undefined) ?? k.termin, mitVorsteuer: k.mit_vorsteuer, zahlungszielTage: k.zahlungsziel_tage ?? undefined, + ...(k.id ? { quelle: `kosten:${k.id}` } : {}), ...(k.zaehlt === false ? { zaehltNicht: true } : {}), })); const r = projektBewegungen({ - projekt: p.nummer, umsatz: p.umsatz_netto, material: p.material_kosten, fremd: p.fremd_kosten, sonstiges: p.sonstige_kosten, + projekt: p.nummer, id: p.id, ohne: p.liqui_ohne ?? [], umsatz: p.umsatz_netto, material: p.material_kosten, fremd: p.fremd_kosten, sonstiges: p.sonstige_kosten, zeitraum: start && schluss ? { start, ende: schluss } : undefined, zahlungen, kosten, }); diff --git a/src/server/app.ts b/src/server/app.ts index cf55d9d..a52d20c 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -429,7 +429,8 @@ export async function baueApp(o: Optionen): Promise { zahlungen: zahlungen.rows, kosten: kosten.rows, laufend: laufend.rows.map((l) => ({ - bezeichnung: l.bezeichnung, kategorie: l.kategorie, betrag: l.betrag, rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined, + id: l.id, bezeichnung: l.bezeichnung, kategorie: l.kategorie, betrag: l.betrag, rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined, + ohneTermine: l.ohne_termine ?? [], })), }, { tage: e.arbeitstage }, @@ -450,6 +451,32 @@ export async function baueApp(o: Optionen): Promise { app.get("/api/liquiditaet", async (req) => berechneLiquiditaet(LiquiAnfrage.parse(req.query))); + // Haken „zählt“ (Henning, 26.10.2026): Posten bleibt sichtbar, zählt aber in der Liquidität nicht mehr mit; dauerhaft gespeichert + const ZaehltAnfrage = z.array(z.object({ + quelle: z.string().regex(/^(zahlung:[0-9a-f-]{36}|kosten:[0-9a-f-]{36}|pauschale:[0-9a-f-]{36}:(material|fremd|sonstiges)|rest:[0-9a-f-]{36}|lk:[0-9a-f-]{36}:\d{4}-\d{2}-\d{2})$/), + zaehlt: z.boolean(), + })).min(1).max(500); + app.post("/api/liquiditaet/zaehlt", async (req) => { + const liste = ZaehltAnfrage.parse(req.body); + await transaktion(pool, benutzer(req), async (c) => { + for (const { quelle, zaehlt } of liste) { + const [art, id, teil] = quelle.split(":") as [string, string, string | undefined]; + if (art === "zahlung" || art === "kosten") { + await c.query(`update ${art} set zaehlt = $2 where id = $1 and zaehlt <> $2`, [id, zaehlt]); + } else if (art === "pauschale" || art === "rest") { + const was = art === "rest" ? "rest" : teil!; + await c.query(zaehlt ? "update projekt set liqui_ohne = array_remove(liqui_ohne, $2) where id = $1 and $2 = any(liqui_ohne)" + : "update projekt set liqui_ohne = array_append(liqui_ohne, $2) where id = $1 and not ($2 = any(liqui_ohne))", [id, was]); + } else { + const datum = quelle.slice(quelle.lastIndexOf(":") + 1); + await c.query(zaehlt ? "update laufende_kosten set ohne_termine = array_remove(ohne_termine, $2) where id = $1 and $2 = any(ohne_termine)" + : "update laufende_kosten set ohne_termine = array_append(ohne_termine, $2) where id = $1 and not ($2 = any(ohne_termine))", [id, datum]); + } + } + }); + return { ok: true }; + }); + // Lage der Liquidität (Henning, 21.10.2026): je Woche ab heute, frei verfügbar, Tiefpunkt und Grund async function liquiLage(heute: string, anzahl: number) { const e = await ladeEinstellungen(); diff --git a/src/server/migrations/027_zaehlt.sql b/src/server/migrations/027_zaehlt.sql new file mode 100644 index 0000000..6fa68c1 --- /dev/null +++ b/src/server/migrations/027_zaehlt.sql @@ -0,0 +1,8 @@ +-- Haken „zählt“ (Henning, 26.10.2026): ohne Haken bleibt ein Posten sichtbar, zählt aber in der Liquidität +-- nicht mit (Summen, Kurve, Monatsplan, Übersicht). Anders als das Auge (nur ausblenden) und „Was wäre, wenn“ (nur probeweise). +alter table zahlung add column zaehlt boolean not null default true; +alter table kosten add column zaehlt boolean not null default true; +-- Pauschalen aus den Eckdaten und die Schlussrechnung (Rest): material, fremd, sonstiges, rest +alter table projekt add column liqui_ohne text[] not null default '{}'; +-- einzelne Termine laufender Kosten (JJJJ-MM-TT) +alter table laufende_kosten add column ohne_termine text[] not null default '{}'; diff --git a/src/server/tabellen.ts b/src/server/tabellen.ts index 0eb2b45..5d4458d 100644 --- a/src/server/tabellen.ts +++ b/src/server/tabellen.ts @@ -359,6 +359,7 @@ export const TABELLEN: Tabelle[] = [ bezug_tage: z.number().int().min(-500).max(500).optional(), freitag: z.boolean().optional(), rest: z.boolean().optional(), + zaehlt: z.boolean().optional(), }), }, { @@ -381,6 +382,7 @@ export const TABELLEN: Tabelle[] = [ freitag: z.boolean().optional(), // aus dem Einsatz eines Subunternehmers; false = von Hand geändert, rechnet sich nicht mehr neu automatisch: z.boolean().optional(), + zaehlt: z.boolean().optional(), }), }, { diff --git a/src/web/app.ts b/src/web/app.ts index e305857..53a8e7c 100644 --- a/src/web/app.ts +++ b/src/web/app.ts @@ -19,7 +19,7 @@ import { angebotSeite, angeboteHtml, angeboteSeite, mengenblattSeite } from "./a import { dokumentMenue } from "./dokument.js"; import { vorlageSeite } from "./mengenblatt.js"; import { leistungSeite, stammdatenSeite } from "./stammdaten.js"; -import { flussKachelnHtml, flussSvg, lageKopfHtml, liquiditaetSeite } from "./liquiditaet.js"; +import { flussKachelnHtml, flussSvg, lageKopfHtml, liquiditaetSeite, zaehltHaken, zaehltSetzen } from "./liquiditaet.js"; import { laufendeKostenSeite } from "./laufendekosten.js"; import { jahresplanSeite } from "./jahresplan.js"; @@ -229,6 +229,11 @@ async function projektSeite(id: string): Promise { const oben = inhalt.querySelector("#p-oben")!; const unten = inhalt.querySelector("#p-unten")!; const teil = unten.querySelector("#teil")!; + // Haken „zählt“ im Zahlungsplan (Henning, 26.10.2026): wie in der Liquidität, dauerhaft gespeichert + teil.addEventListener("change", (ev) => { + const el = ev.target as HTMLInputElement; + if (el.dataset.zaehlt !== undefined) void zaehltSetzen(el.dataset.zaehlt, el.checked, neuLaden); + }); const knopfOrt = unten.querySelector("#teil-knopf")!; const knopf = (text: string, aktion: () => void) => { const b = document.createElement("button"); @@ -499,8 +504,10 @@ async function projektSeite(id: string): Promise { { id: "zahlung", titel: "Geld erwartet", art: "datum", sortWert: (z) => zahlungErwartet(z), wert: (z) => `${dat(zahlungErwartet(z))}${z.bezahlt_am ? "bezahlt" : `${frist(z)} Tage Frist`}` }, { id: "status", titel: "Status", text: (z) => z.status, wert: (z) => `${esc(z.status)}`, klasse: "optional" }, + { id: "zaehlt", titel: "Zählt", text: (z) => (z.zaehlt === false ? "zählt nicht" : "zählt"), wert: (z) => `${zaehltHaken([`zahlung:${z.id}`], z.zaehlt !== false, z.bezeichnung)} zählt in der Liquidität`, klasse: "zaehlt" }, { id: "netto", titel: "Netto", art: "zahl", wert: (z) => `${euro(z.netto)}${z.rest ? 'Rest' : ""}`, sortWert: (z) => z.netto, klasse: "zahl" }, ], + zeilenKlasse: (z) => (z.zaehlt === false ? "zaehlt-nicht" : ""), zeilen: eigeneZahlungen, klick: (z) => void zahlungBearbeiten(z), loeschen: async (z) => { await api(`zahlungen/${z.id}`, "DELETE"); neuLaden(); }, // Reihenfolge wie im Terminplan unter „Einnahmen“; von Hand verschoben ist der Plan fest @@ -509,7 +516,9 @@ async function projektSeite(id: string): Promise { neuLaden(); }, })); - teil.insertAdjacentHTML("beforeend", `

Summe ${euro(summe)}${umsatz && summe !== umsatz ? ` · Auftragswert ${euro(umsatz)}, Rest ${euro(umsatz - summe)}` : ""}

`); + const ohneZ = eigeneZahlungen.filter((z) => z.zaehlt === false); + teil.insertAdjacentHTML("beforeend", `

Summe ${euro(summe)}${umsatz && summe !== umsatz ? ` · Auftragswert ${euro(umsatz)}, Rest ${euro(umsatz - summe)}` : ""}${ohneZ.length + ? ` · ${ohneZ.length} ${ohneZ.length === 1 ? "Rate zählt" : "Raten zählen"} nicht in der Liquidität (${euro(ohneZ.reduce((s, z) => s + z.netto, 0))})` : ""}

`); } zeigeEingangsrechnungen(); } @@ -574,13 +583,17 @@ async function projektSeite(id: string): Promise { wert: (k) => `${dat(k.termin)}${abschnittVon(k) ? `${k.bezug_art === "EE" ? "nach" : "vor"} ${esc(abschnittVon(k)!.name)}` : k.vorgang_id ? 'mit Vorgang' : ""}` }, { id: "zahlung", titel: "Geld geht raus", art: "datum", sortWert: (k) => zahltag(k), wert: (k) => `${dat(zahltag(k))}${ziel(k)} Tage Ziel` }, { id: "status", titel: "Status", text: (k) => k.status, wert: (k) => `${esc(k.status)}`, klasse: "optional" }, + { id: "zaehlt", titel: "Zählt", text: (k) => (k.zaehlt === false ? "zählt nicht" : "zählt"), wert: (k) => `${zaehltHaken([`kosten:${k.id}`], k.zaehlt !== false, k.bezeichnung)} zählt in der Liquidität`, klasse: "zaehlt" }, { id: "netto", titel: "Netto", art: "zahl", wert: (k) => euro(k.netto), sortWert: (k) => k.netto, klasse: "zahl" }, ], + zeilenKlasse: (k) => (k.zaehlt === false ? "zaehlt-nicht" : ""), zeilen: eigeneKosten, klick: (k) => void bearbeitenER(k), loeschen: async (k) => { await api(`kosten/${k.id}`, "DELETE"); neuLaden(); }, })); const summeK = eigeneKosten.reduce((s, k) => s + k.netto, 0); - teil.insertAdjacentHTML("beforeend", `

Summe Ausgaben ${euro(summeK)}${eigeneZahlungen.length ? ` · Einnahmen minus Ausgaben ${euro(eigeneZahlungen.reduce((s, z) => s + z.netto, 0) - summeK)}` : ""}

`); + const ohneK = eigeneKosten.filter((k) => k.zaehlt === false); + teil.insertAdjacentHTML("beforeend", `

Summe Ausgaben ${euro(summeK)}${eigeneZahlungen.length ? ` · Einnahmen minus Ausgaben ${euro(eigeneZahlungen.reduce((s, z) => s + z.netto, 0) - summeK)}` : ""}${ohneK.length + ? ` · ${ohneK.length} ${ohneK.length === 1 ? "Rechnung zählt" : "Rechnungen zählen"} nicht in der Liquidität (${euro(ohneK.reduce((s, k) => s + k.netto, 0))})` : ""}

`); } // ---------- rechts: offene Aufgaben statt Chat ---------- diff --git a/src/web/liquiditaet.ts b/src/web/liquiditaet.ts index aed415d..5c732e9 100644 --- a/src/web/liquiditaet.ts +++ b/src/web/liquiditaet.ts @@ -191,11 +191,11 @@ Einnahmen: ${glatt(w.einnahmen)} · Ausgaben: ${glatt(-w.ausgaben)}, ohne = false): 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)); + 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 `

${kw(w.von)} · ${dat(w.von).slice(0, 6)} – ${dat(w.bis)}

- ${posten.length ? `${posten.map((p) => ` - `).join("")} -
${dat(p.datum).slice(0, 6)}${postenText(p, namen)}${glatt(p.betrag)}
Saldo der Woche${ohne ? "" : ` · Kontostand danach ${glatt(w.kontostand)}`}${glatt(ohne ? posten.reduce((x, p) => x + p.betrag, 0) : w.saldo)}
` + ${posten.length ? `${posten.map((p) => ` + `).join("")} +
${dat(p.datum).slice(0, 6)}${postenText(p, namen)}${p.zaehltNicht ? ' zählt nicht' : ""}${zaehltHaken(p.quelle ? [p.quelle] : [], !p.zaehltNicht, p.bezeichnung)}${glatt(p.betrag)}
Saldo der Woche${ohne ? "" : ` · Kontostand danach ${glatt(w.kontostand)}`}${glatt(ohne ? posten.filter((p) => !p.zaehltNicht).reduce((x, p) => x + p.betrag, 0) : w.saldo)}
` : '

In dieser Woche ist keine Zahlung geplant.

'}
`; } @@ -205,7 +205,8 @@ async function lageZeigen(): Promise { const namen = new Map(projekte.map((p) => [p.nummer as string, p.bezeichnung 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)) })); + 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"; @@ -246,6 +247,8 @@ async function lageZeigen(): Promise { void (async () => { const e = await api("einstellungen"); await api("einstellungen", "PUT", { ...e, jahresplanVorschau: pv.dataset.planVorschau === "an" }); void liquiditaetSeite(); })(); return; } + const az = t.closest("[data-alle-zaehlen]"); + if (az) { void zaehltSetzen(az.dataset.alleZaehlen!, true, () => void liquiditaetSeite()); return; } const knopf = t.closest("[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) { @@ -296,6 +299,7 @@ async function lageZeigen(): Promise { }; 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) ?? {}) }; @@ -318,24 +322,28 @@ const probe = new Map(); 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[] } +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)}` +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[]).filter((p) => (art === "ein" ? p.betrag > 0 : p.betrag < 0) && !(p.bezahlt && p.datum < h)); + 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(); 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); continue; } + 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] } : {}) }); + 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); @@ -382,18 +390,36 @@ function probeBand(d: Zeile, v: { lage: Zeile; wochen: Zeile[] }, zeilen: { ein: `; } +// ---------- 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 ``; +} + +/** Speichern und die Seite neu zeichnen */ +export async function zaehltSetzen(quellen: string, zaehlt: boolean, danach: () => void): Promise { + 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, ausSet: Set, 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 = alle.reduce((s, z) => { const x = probe.get(z.key); return s + (x?.weg || (x?.datum && x.datum > ende) ? 0 : z.betrag); }, 0); + 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; @@ -407,16 +433,19 @@ function listeHtml(art: "ein" | "aus", alle: ListenZeile[], namen: Map` : ``; - return `${vorne}${datum} - ${postenText(p, namen)}${p.anzahl > 1 ? ` (${p.anzahl})` : ""}${tag}${glatt(p.betrag)}`; + return `${vorne}${datum} + ${postenText(p, namen)}${p.anzahl > 1 ? ` (${p.anzahl})` : ""}${tag}${p.zaehlt ? "" : ' zählt nicht'} + ${zaehltHaken(p.quellen, p.zaehlt, p.bezeichnung)}${glatt(p.betrag)}`; }; const rest = posten.slice(sichtbar); - const probeText = probe.size && probeSumme !== summe(alle) ? ` (probeweise ${glatt(probeSumme)})` : ""; + const probeText = probe.size && probeSumme !== summe(zaehlen) ? ` (probeweise ${glatt(probeSumme)})` : ""; return `

${art === "ein" ? "Kommt rein" : "Geht raus"} · nächste ${ZEIT_KNOPF[zeitraum]}

- ${alle.length ? `${posten.slice(0, sichtbar).map(zeile).join("")} - ${rest.length || (mehr[art] && posten.length > SICHTBAR) ? `` : ""} - ${versteckt.length ? `` : ""} -
${versteckt.length} ${versteckt.length === 1 ? "Zeile" : "Zeilen"} ausgeblendet · ${zeigeAus[art] ? ` · ` : ""} (zählt weiter mit)
Summe aller ${alle.length}${probeText}${glatt(summe(alle))}
` + ${alle.length ? ` + ${posten.slice(0, sichtbar).map(zeile).join("")} + ${rest.length || (mehr[art] && posten.length > SICHTBAR) ? `` : ""} + ${nicht.length ? `` : ""} + ${versteckt.length ? `` : ""} +
DatumWaszähltBetrag
${nicht.length} Posten ${nicht.length === 1 ? "zählt" : "zählen"} nicht ·
${versteckt.length} ${versteckt.length === 1 ? "Zeile" : "Zeilen"} ausgeblendet · ${zeigeAus[art] ? ` · ` : ""} (zählt weiter mit)
${nicht.length ? `Summe der ${zaehlen.length}, die zählen` : `Summe aller ${alle.length}`}${probeText}${glatt(summe(zaehlen))}
` : `

${art === "ein" ? "Im Zeitraum kommt nichts rein." : "Im Zeitraum geht nichts raus."}

`}
`; } @@ -468,7 +497,8 @@ async function planZeigen(): Promise { ]); // 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)) })) : roh; + 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])); 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)}`); @@ -483,9 +513,10 @@ async function planZeigen(): Promise { 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) => `${x.ueberfaelligSeit ? `seit ${dat(x.ueberfaelligSeit)}` : dat(x.datum)} - ${esc(x.bezeichnung)}${x.ueberfaelligSeit ? ` ${x.gestellt ? "überfällig" : "Rechnung fehlt"}` : ""}${esc(x.gruppe)} - ${x.projekt ? `${esc(x.projekt)}${namen.get(x.projekt) ? ` ${esc(namen.get(x.projekt))}` : ""}` : ""}${euro(x.betrag)}`; + const zeile = (x: Zeile) => `${x.ueberfaelligSeit ? `seit ${dat(x.ueberfaelligSeit)}` : dat(x.datum)} + ${esc(x.bezeichnung)}${x.ueberfaelligSeit ? ` ${x.gestellt ? "überfällig" : "Rechnung fehlt"}` : ""}${x.zaehltNicht ? ' zählt nicht' : ""}${esc(x.gruppe)} + ${x.projekt ? `${esc(x.projekt)}${namen.get(x.projekt) ? ` ${esc(namen.get(x.projekt))}` : ""}` : ""} + ${zaehltHaken(x.quelle ? [x.quelle] : [], !x.zaehltNicht, x.bezeichnung)}${euro(x.betrag)}`; const tab = document.createElement("table"); tab.className = "liqui-tabelle"; const spalten = ohne ? 6 : 5; @@ -501,11 +532,15 @@ async function planZeigen(): Promise { : 'EinnahmenAusgabenSaldoKontostand'} ${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 `${offen ? "▾" : "▸"} ${esc(zeitText(p))} ${posten.length} ${posten.length === 1 ? "Zahlung" : "Zahlungen"} + 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 `${offen ? "▾" : "▸"} ${esc(zeitText(p))} ${posten.length} ${posten.length === 1 ? "Zahlung" : "Zahlungen"}${p.ohne?.length ? `, ${p.ohne.length} ${p.ohne.length === 1 ? "zählt" : "zählen"} nicht` : ""} ${zahlen(p)} - ${offen ? `${posten.length ? `${posten.map(zeile).join("")}
Fällig amWasProjektBetrag
` : '

Keine Zahlungen in diesem Zeitraum.

'}` : ""}`; + ${offen ? `${posten.length ? `${posten.map(zeile).join("")}
Fällig amWasProjektzähltBetrag
` : '

Keine Zahlungen in diesem Zeitraum.

'}` : ""}`; }).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("tr.periode"); if (!tr) return; @@ -525,22 +560,28 @@ async function alleZeigen(): Promise { 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[]).filter((x) => !ohne || FLUSS_GRUPPEN.has(x.gruppe)) + 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.betrag) })); - inhalt.append(liste({ + .map((x, i) => ({ ...x, id: `${x.datum}-${i}-${x.bezeichnung}`, stand: (stand += x.zaehltNicht ? 0 : x.betrag) })); + const tabelle = liste({ schluessel: "liquiditaet-zahlungen", einheit: ["Zahlung", "Zahlungen"], leer: "Keine Zahlungen im Zeitraum.", - zeilenKlasse: (x) => (x.ueberfaelligSeit ? "ueber" : x.datum < h ? "vorbei" : ""), + 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 ? ` ${x.gestellt ? "überfällig" : "Rechnung fehlt"}` : ""}${esc(x.gruppe)}` }, + { id: "was", titel: "Was", text: (x) => x.bezeichnung, wert: (x) => `${esc(x.bezeichnung)}${x.ueberfaelligSeit ? ` ${x.gestellt ? "überfällig" : "Rechnung fehlt"}` : ""}${x.zaehltNicht ? ' zählt nicht' : ""}${esc(x.gruppe)}`, klasse: "text" }, { 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: "zaehlt", titel: "Zählt", 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) => `${euro(x.betrag)}`, sortWert: (x) => x.betrag, klasse: "zahl" }, ...(ohne ? [] : [{ id: "stand", titel: "Kontostand danach", art: "zahl" as const, wert: (x: Zeile) => `${euro(x.stand)}`, sortWert: (x: Zeile) => x.stand, klasse: "zahl optional" }]), ], zeilen: posten, - fuss: (l) => (l.length === posten.length ? "" : `

Summe der gezeigten Zahlungen: ${euro(l.reduce((s, x) => s + x.betrag, 0))}

`), - })); + fuss: (l) => (l.length === posten.length ? "" : `

Summe der gezeigten Zahlungen: ${euro(l.filter((x) => !x.zaehltNicht).reduce((s, x) => s + x.betrag, 0))}

`), + }); + 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); } diff --git a/src/web/styles.css b/src/web/styles.css index 2fb265d..0c7d3a1 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -1451,9 +1451,26 @@ dl.am-kennzahlen dd { margin: 0; text-align: right; font-variant-numeric: tabula .liqui-modus { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; margin: 4px 0 10px; } .liqui-modus .chip-knopf { font-size: 13px; padding: 4px 11px; } .liqui-modus .chip-knopf.an.was { background: var(--probe-bg); border-color: var(--probe-kurve); color: var(--probe-text); } -.liqui-posten td.vorne { width: 30px; padding-right: 0; } +.liqui-posten td.vorne, .liqui-posten th.vorne { width: 30px; padding-right: 0; } .liqui-posten td.vorne input { width: 16px; height: 16px; margin: 2px 0 0; } .liqui-posten tr.ausgeblendet td:not(.vorne) { opacity: .5; } +/* Haken „zählt“ (Henning, 26.10.2026): ohne Haken grau und durchgestrichen, zählt nirgends mit */ +.liqui-posten th { padding: 2px 4px 4px; font-size: 11px; font-weight: 600; letter-spacing: .04em; text-transform: uppercase; color: var(--leise); text-align: left; } +.liqui-posten th.datum { width: 86px; } +.liqui-posten th.zahl { width: 112px; text-align: right; } +.liqui-posten th.zaehlt, .liqui-posten td.zaehlt { width: 46px; text-align: center; } +th.zaehlt, td.zaehlt { text-align: center; } +td.zaehlt input, input.zaehlt-haken { width: 16px; height: 16px; margin: 2px 0 0; cursor: pointer; } +tr.zaehlt-nicht td:not(.zaehlt):not(.vorne) { color: var(--leise); } +tr.zaehlt-nicht td.zahl, tr.zaehlt-nicht td.zahl *, tr.zaehlt-nicht td.text { text-decoration: line-through; text-decoration-color: var(--leise); } +tr.zaehlt-nicht td.zahl.ein, tr.zaehlt-nicht td.zahl.aus, tr.zaehlt-nicht td.zahl span { color: var(--leise); } +.tag-zaehlt { display: inline-block; font-size: 11px; font-weight: 600; padding: 1px 6px; border-radius: 4px; background: var(--linie); color: var(--leise); white-space: nowrap; text-decoration: none; } +tr.zaehlt-nicht td.text .tag-zaehlt { text-decoration: none; } +@media (max-width: 640px) { + .liqui-posten th.datum { width: 62px; } + .liqui-posten th.zahl { width: 84px; } + .liqui-posten th.zaehlt, .liqui-posten td.zaehlt { width: 34px; } +} .liqui-posten tr.probe-weg td { background: var(--probe-bg); } .liqui-posten tr.probe-weg td.text, .liqui-posten tr.probe-weg td.zahl { text-decoration: line-through; color: var(--leise); } .liqui-posten tr.aus-hinweis td { color: var(--leise); font-size: 13px; } diff --git a/test/api.test.ts b/test/api.test.ts index 414ce1b..e25169e 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -107,6 +107,32 @@ describe.skipIf(!url)("API mit Datenbank", () => { expect(await maerz()).toBe(1_190_000); }); + it("Haken „zählt“: Posten bleibt in der Liste, zählt aber nicht mehr mit", async () => { + const p = await anlegen("projekte", { nummer: "28-001", bezeichnung: "Zählt-Test" }); + const z = await anlegen("zahlungen", { projekt_id: p.id, bezeichnung: "Abschlag", netto: 100_000, termin: "2028-05-02", zahlungsziel_tage: 0 }); + const k = await anlegen("kosten", { projekt_id: p.id, art: "material", bezeichnung: "Holz", netto: 10_000, termin: "2028-05-03", zahlungsziel_tage: 0 }); + const l = await anlegen("laufende-kosten", { bezeichnung: "Zählt-Miete", betrag: 1_000, rhythmus: "monatlich", start: "2028-05-04", ende: "2028-06-30" }); + const mai = async () => (await app.inject("/api/liquiditaet?ansicht=monat&start=2028-05-01&anzahl=1")).json()[0]; + const vorher = await mai(); + const setze = (liste: { quelle: string; zaehlt: boolean }[]) => app.inject({ method: "POST", url: "/api/liquiditaet/zaehlt", payload: liste }); + expect((await setze([{ quelle: `zahlung:${z.id}`, zaehlt: false }, { quelle: `kosten:${k.id}`, zaehlt: false }, + { quelle: `lk:${l.id}:2028-05-04`, zaehlt: false }, { quelle: `pauschale:${p.id}:material`, zaehlt: false }])).statusCode).toBe(200); + const nachher = await mai(); + expect(nachher.einnahmen).toBe(vorher.einnahmen - 119_000); + expect(nachher.ausgaben).toBe(vorher.ausgaben + 11_900 + 1_000); + expect(nachher.ohne.map((x: { quelle: string }) => x.quelle).sort()).toEqual([`kosten:${k.id}`, `lk:${l.id}:2028-05-04`, `zahlung:${z.id}`].sort()); + expect((await app.inject(`/api/zahlungen/${z.id}`)).json().zaehlt).toBe(false); + expect((await app.inject(`/api/projekte/${p.id}`)).json().liqui_ohne).toEqual(["material"]); + // doppelt abschalten bleibt einmal, Juni zählt weiter + await setze([{ quelle: `pauschale:${p.id}:material`, zaehlt: false }, { quelle: `lk:${l.id}:2028-05-04`, zaehlt: false }]); + expect((await app.inject(`/api/laufende-kosten/${l.id}`)).json().ohne_termine).toEqual(["2028-05-04"]); + // alle wieder zählen + await setze([{ quelle: `zahlung:${z.id}`, zaehlt: true }, { quelle: `kosten:${k.id}`, zaehlt: true }, { quelle: `lk:${l.id}:2028-05-04`, zaehlt: true }, { quelle: `pauschale:${p.id}:material`, zaehlt: true }]); + expect(await mai()).toEqual(vorher); + expect((await app.inject(`/api/projekte/${p.id}`)).json().liqui_ohne).toEqual([]); + expect((await setze([{ quelle: "projekt:x", zaehlt: false }])).statusCode).toBe(400); + }); + it("Export enthält alle Tabellen", async () => { const r = await app.inject("/api/export"); const j = r.json(); diff --git a/test/liquiditaet.test.ts b/test/liquiditaet.test.ts index 596531a..b5da62b 100644 --- a/test/liquiditaet.test.ts +++ b/test/liquiditaet.test.ts @@ -186,3 +186,33 @@ describe("Lage der Liquidität (Henning, 21.10.2026)", () => { expect(l.ampel).toBe(l.tief!.kontostand < 0 ? "rot" : l.tief!.kontostand < 310_000 ? "gelb" : "gruen"); }); }); + +describe("Haken „zählt“ (Henning, 26.10.2026)", () => { + const vorschau = { ansicht: "monat" as const, start: "2026-11-01", anzahl: 1, startsaldo: 0, ust: { satz: 19, versteuerung: "ist" as const, voranmeldung: "monatlich" as const, dauerfristverlaengerung: false } }; + it("ohne Haken: sichtbar unter ohne, aber in keiner Summe und nicht in der Umsatzsteuer", () => { + const p = liquiditaet({ + einnahmen: [{ bezeichnung: "Abschlag", netto: 100_000, termin: "2026-11-02", zahlungszielTage: 0, quelle: "zahlung:a" }, + { bezeichnung: "Doppelt", netto: 50_000, termin: "2026-11-03", zahlungszielTage: 0, quelle: "zahlung:b", zaehltNicht: true }], + ausgaben: [], + laufend: [{ id: "l1", bezeichnung: "Miete", betrag: 1_000, rhythmus: "monatlich", start: "2026-11-05", ohneTermine: ["2026-11-05"] }], + }, vorschau); + expect(p[0]!.einnahmen).toBe(119_000); + expect(p[0]!.ausgaben).toBe(0); + expect(p[0]!.posten.map((x) => x.quelle)).toEqual(["zahlung:a"]); + expect(p[0]!.ohne!.map((x) => [x.quelle, x.zaehltNicht])).toEqual([["zahlung:b", true], ["lk:l1:2026-11-05", true]]); + // Zahllast nur aus dem Abschlag; die Vorauszahlung November ist erst im Dezember fällig + const d = liquiditaet({ einnahmen: [{ bezeichnung: "Doppelt", netto: 50_000, termin: "2026-11-03", zaehltNicht: true }], ausgaben: [], laufend: [] }, { ...vorschau, anzahl: 2 }); + expect(d.flatMap((x) => x.posten)).toEqual([]); + }); + it("Pauschale und Rest einzeln abschaltbar, Einzelposten mindern die Pauschale weiter", () => { + const b = projektBewegungen({ + projekt: "P-26-013", id: "p1", ohne: ["material"], umsatz: 1_000_000, material: 985_100, fremd: 0, sonstiges: 0, + zeitraum: { start: "2026-11-02", ende: "2026-11-20" }, zahlungen: [], + kosten: [{ projekt: "P-26-013", bezeichnung: "Holz", art: "material", netto: 500_000, termin: "2026-11-02", quelle: "kosten:k1", zaehltNicht: true }], + }); + expect(b.ausgaben.map((a) => [a.bezeichnung, a.netto, a.quelle, a.zaehltNicht])).toEqual([ + ["Holz", 500_000, "kosten:k1", true], ["Material (Pauschale)", 485_100, "pauschale:p1:material", true]]); + expect(b.einnahmen[0]).toMatchObject({ quelle: "rest:p1" }); + expect(b.einnahmen[0]!.zaehltNicht).toBeUndefined(); + }); +});