Haken „zählt“: Posten dauerhaft aus der Liquidität nehmen (0.41.0)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
@@ -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:<id> */
|
||||
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:<id>, kosten:<id>, pauschale:<projekt>:<art>, rest:<projekt>, lk:<id>:<datum> */
|
||||
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 } : {}) };
|
||||
});
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
});
|
||||
|
||||
@@ -429,7 +429,8 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
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<FastifyInstance> {
|
||||
|
||||
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();
|
||||
|
||||
8
src/server/migrations/027_zaehlt.sql
Normal file
8
src/server/migrations/027_zaehlt.sql
Normal file
@@ -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 '{}';
|
||||
@@ -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(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
|
||||
@@ -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<void> {
|
||||
const oben = inhalt.querySelector<HTMLElement>("#p-oben")!;
|
||||
const unten = inhalt.querySelector<HTMLElement>("#p-unten")!;
|
||||
const teil = unten.querySelector<HTMLElement>("#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<HTMLElement>("#teil-knopf")!;
|
||||
const knopf = (text: string, aktion: () => void) => {
|
||||
const b = document.createElement("button");
|
||||
@@ -499,8 +504,10 @@ async function projektSeite(id: string): Promise<void> {
|
||||
{ id: "zahlung", titel: "Geld erwartet", art: "datum", sortWert: (z) => zahlungErwartet(z),
|
||||
wert: (z) => `${dat(zahlungErwartet(z))}<span class="unter">${z.bezahlt_am ? "bezahlt" : `${frist(z)} Tage Frist`}</span>` },
|
||||
{ id: "status", titel: "Status", text: (z) => z.status, wert: (z) => `<span class="etikett zahlung-${esc(z.status)}">${esc(z.status)}</span>`, 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)}<span class="nur-schmal"> zählt in der Liquidität</span>`, klasse: "zaehlt" },
|
||||
{ id: "netto", titel: "Netto", art: "zahl", wert: (z) => `${euro(z.netto)}${z.rest ? '<span class="unter">Rest</span>' : ""}`, 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<void> {
|
||||
neuLaden();
|
||||
},
|
||||
}));
|
||||
teil.insertAdjacentHTML("beforeend", `<p class="summe">Summe ${euro(summe)}${umsatz && summe !== umsatz ? ` · Auftragswert ${euro(umsatz)}, Rest ${euro(umsatz - summe)}` : ""}</p>`);
|
||||
const ohneZ = eigeneZahlungen.filter((z) => z.zaehlt === false);
|
||||
teil.insertAdjacentHTML("beforeend", `<p class="summe">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))})` : ""}</p>`);
|
||||
}
|
||||
zeigeEingangsrechnungen();
|
||||
}
|
||||
@@ -574,13 +583,17 @@ async function projektSeite(id: string): Promise<void> {
|
||||
wert: (k) => `${dat(k.termin)}${abschnittVon(k) ? `<span class="unter">${k.bezug_art === "EE" ? "nach" : "vor"} ${esc(abschnittVon(k)!.name)}</span>` : k.vorgang_id ? '<span class="unter">mit Vorgang</span>' : ""}` },
|
||||
{ id: "zahlung", titel: "Geld geht raus", art: "datum", sortWert: (k) => zahltag(k), wert: (k) => `${dat(zahltag(k))}<span class="unter">${ziel(k)} Tage Ziel</span>` },
|
||||
{ id: "status", titel: "Status", text: (k) => k.status, wert: (k) => `<span class="etikett kosten-${esc(k.status)}">${esc(k.status)}</span>`, 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)}<span class="nur-schmal"> zählt in der Liquidität</span>`, 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", `<p class="summe">Summe Ausgaben ${euro(summeK)}${eigeneZahlungen.length ? ` · Einnahmen minus Ausgaben ${euro(eigeneZahlungen.reduce((s, z) => s + z.netto, 0) - summeK)}` : ""}</p>`);
|
||||
const ohneK = eigeneKosten.filter((k) => k.zaehlt === false);
|
||||
teil.insertAdjacentHTML("beforeend", `<p class="summe">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))})` : ""}</p>`);
|
||||
}
|
||||
|
||||
// ---------- rechts: offene Aufgaben statt Chat ----------
|
||||
|
||||
@@ -191,11 +191,11 @@ Einnahmen: ${glatt(w.einnahmen)} · Ausgaben: ${glatt(-w.ausgaben)}</title></rec
|
||||
/** 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[])].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 `<div class="liqui-woche"><div class="karte-kopf"><h3>${kw(w.von)} · ${dat(w.von).slice(0, 6)} – ${dat(w.bis)}</h3><button class="neben" data-a="woche-zu">Schließen</button></div>
|
||||
${posten.length ? `<table class="liqui-posten"><tbody>${posten.map((p) => `<tr><td>${dat(p.datum).slice(0, 6)}</td><td class="text">${postenText(p, namen)}</td>
|
||||
<td class="zahl ${p.betrag < 0 ? "aus" : "ein"}">${glatt(p.betrag)}</td></tr>`).join("")}</tbody>
|
||||
<tfoot><tr><td></td><td>Saldo der Woche${ohne ? "" : ` · Kontostand danach ${glatt(w.kontostand)}`}</td><td class="zahl">${glatt(ohne ? posten.reduce((x, p) => x + p.betrag, 0) : w.saldo)}</td></tr></tfoot></table>`
|
||||
${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>`;
|
||||
}
|
||||
|
||||
@@ -205,7 +205,8 @@ async function lageZeigen(): Promise<void> {
|
||||
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> {
|
||||
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) {
|
||||
@@ -296,6 +299,7 @@ async function lageZeigen(): Promise<void> {
|
||||
};
|
||||
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<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[] }
|
||||
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<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); 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:
|
||||
<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 = 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<string, s
|
||||
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" : ""}"${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}</td><td class="zahl ${art}">${glatt(p.betrag)}</td></tr>`;
|
||||
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(alle) ? ` <small class="probe-summe">(probeweise ${glatt(probeSumme)})</small>` : "";
|
||||
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"><tbody>${posten.slice(0, sichtbar).map(zeile).join("")}
|
||||
${rest.length || (mehr[art] && posten.length > SICHTBAR) ? `<tr class="mehr"><td></td><td></td><td colspan="2"><button class="verweis" data-mehr="${art}" aria-expanded="${mehr[art]}">${mehr[art] ? "▴ weniger anzeigen" : `▾ ${rest.length} weitere anzeigen (${glatt(summe(rest))})`}</button></td></tr>` : ""}
|
||||
${versteckt.length ? `<tr class="aus-hinweis"><td></td><td></td><td colspan="2">${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>Summe aller ${alle.length}${probeText}</td><td class="zahl ${art}">${glatt(summe(alle))}</td></tr></tfoot></table>`
|
||||
${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">zählt</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>`;
|
||||
}
|
||||
|
||||
@@ -468,7 +497,8 @@ async function planZeigen(): Promise<void> {
|
||||
]);
|
||||
// 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<void> {
|
||||
if (b.dataset.raster) { raster = b.dataset.raster as "monat" | "woche"; void liquiditaetSeite(); }
|
||||
if (b.dataset.a === "alle") { liquiOffen = alleOffen ? new Set() : new Set(perioden.map((p) => p.von)); void liquiditaetSeite(); }
|
||||
};
|
||||
const zeile = (x: Zeile) => `<tr class="posten${x.datum < h && !x.ueberfaelligSeit ? " vorbei" : ""}"><td>${x.ueberfaelligSeit ? `seit ${dat(x.ueberfaelligSeit)}` : dat(x.datum)}</td>
|
||||
<td>${esc(x.bezeichnung)}${x.ueberfaelligSeit ? ` <span class="tag-ueber">${x.gestellt ? "überfällig" : "Rechnung fehlt"}</span>` : ""}<span class="unter">${esc(x.gruppe)}</span></td>
|
||||
<td class="optional">${x.projekt ? `${esc(x.projekt)}${namen.get(x.projekt) ? ` ${esc(namen.get(x.projekt))}` : ""}` : ""}</td><td class="zahl ${x.betrag < 0 ? "aus" : "ein"}">${euro(x.betrag)}</td></tr>`;
|
||||
const 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;
|
||||
@@ -501,11 +532,15 @@ async function planZeigen(): Promise<void> {
|
||||
: '<th class="zahl">Einnahmen</th><th class="zahl">Ausgaben</th><th class="zahl optional">Saldo</th><th class="zahl">Kontostand</th>'}</tr></thead>
|
||||
${perioden.map((p) => {
|
||||
const offen = liquiOffen.has(p.von);
|
||||
const posten = [...p.posten].sort((x: Zeile, y: Zeile) => (x.datum < y.datum ? -1 : x.datum > y.datum ? 1 : x.betrag - y.betrag));
|
||||
return `<tbody><tr class="klickbar periode${offen ? " offen" : ""}" data-von="${p.von}"><td><span class="pfeil">${offen ? "▾" : "▸"}</span> ${esc(zeitText(p))} <small class="hinweis">${posten.length} ${posten.length === 1 ? "Zahlung" : "Zahlungen"}</small></td>
|
||||
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="zahl">Betrag</th></tr></thead><tbody>${posten.map(zeile).join("")}</tbody></table>` : '<p class="hinweis">Keine Zahlungen in diesem Zeitraum.</p>'}</td></tr>` : ""}</tbody>`;
|
||||
${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">zählt</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;
|
||||
@@ -525,22 +560,28 @@ async function alleZeigen(): Promise<void> {
|
||||
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 ? ` <span class="tag-ueber">${x.gestellt ? "überfällig" : "Rechnung fehlt"}</span>` : ""}<span class="unter nur-schmal">${esc(x.gruppe)}</span>` },
|
||||
{ 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", 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) => `<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.reduce((s, x) => s + x.betrag, 0))}</strong></p>`),
|
||||
}));
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
@@ -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; }
|
||||
|
||||
Reference in New Issue
Block a user