Files
Betriebsf-hrungssoftware/src/domain/liquiditaet.ts
Claude 83828c12f8
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
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
2026-10-26 09:34:21 +00:00

283 lines
12 KiB
TypeScript

// Liquiditätsvorschau je Woche oder Monat, Regeln wie V70 (lqEvents):
// - Abschläge sind am Vorgangsende fällig, plus Zahlungsziel; der nicht über Abschläge
// abgerechnete Rest des Umsatzes kommt als Schlussrechnung am Projektende plus Zahlungsziel.
// - Pauschale Projektkosten fallen am Projektstart plus Zahlungsziel an; einzeln erfasste
// Kosten mindern die Pauschale anteilig und zählen zu ihrem eigenen Termin.
// - Zahlungstermine sind Kalendertage, die Freitagsregel gilt dafür nicht.
// - Umsatzsteuer: Zahllast je Zeitraum aus der Summe der Nettobeträge, einmal gerundet.
// Laufende Kosten und Startsaldo kommen neu hinzu (in V70 nicht in der Liquidität).
import { type Datum, plusTage, plusMonate, montagDerWoche, monatsErster } from "./datum.js";
import { type Cent, ustAusNetto, summe, prozentVon } from "./geld.js";
import { type UstEinstellungen, STANDARD_UST, zeitraumVon, faelligkeit } from "./umsatzsteuer.js";
export type Gruppe = "Projekteinnahmen" | "Projektkosten" | "Laufende Kosten" | "Umsatzsteuer" | "Jahresplan";
export type Kostenart = "material" | "fremd" | "sonstiges";
export type Rhythmus = "einmalig" | "monatlich" | "vierteljaehrlich" | "jaehrlich";
export interface Einnahme {
projekt?: string;
bezeichnung: string;
netto: Cent;
/** Rechnungs- bzw. geplanter Termin */
termin: Datum;
zahlungszielTage?: number;
bezahltAm?: Datum;
/** bezahlt, auch ohne Datum */
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 {
projekt?: string;
bezeichnung: string;
art: Kostenart;
netto: Cent;
termin: Datum;
zahlungszielTage?: number;
/** false z. B. bei Subunternehmern im Reverse-Charge oder Kleinunternehmern */
mitVorsteuer?: boolean;
quelle?: string;
zaehltNicht?: boolean;
}
export interface LaufendeKosten {
bezeichnung: string;
kategorie?: string;
/** Betrag, der vom Konto abgeht */
betrag: Cent;
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 {
kundenTage: number;
materialTage: number;
fremdTage: number;
sonstigeTage: number;
}
/** Vorgaben aus V70: Kunden 14 Tage, Projektkosten 7 Tage ab Projektstart */
export const STANDARD_ZIELE: Zahlungsziele = { kundenTage: 14, materialTage: 7, fremdTage: 7, sonstigeTage: 7 };
export interface Vorschau {
ansicht: "woche" | "monat";
start: Datum;
anzahl: number;
startsaldo: Cent;
ziele?: Zahlungsziele;
ust?: UstEinstellungen;
/**
* Heute: offene Einnahmen, deren Zahltag schon vorbei ist, gelten als überfällig. Liegen sie vor dem
* ersten Zeitraum, kommen sie heute in die Rechnung (das Geld steht ja noch aus), höchstens ein Jahr zurück.
*/
offeneAb?: Datum;
/** weitere Posten aus allen Bewegungen, z. B. die Vorschau aus dem Jahresplan (Stufe 5) */
ergaenzen?: (alle: Posten[]) => Posten[];
}
export interface Posten {
datum: Datum;
gruppe: Gruppe;
projekt?: string;
bezeichnung: string;
/** positiv = Eingang, negativ = Ausgang */
betrag: Cent;
/** Einnahme: bezahlt bzw. Rechnung gestellt */
bezahlt?: boolean;
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 {
von: Datum;
bis: Datum;
einnahmen: Cent;
ausgaben: Cent;
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 {
return art === "material" ? z.materialTage : art === "fremd" ? z.fremdTage : z.sonstigeTage;
}
const MONATE_JE_RHYTHMUS: Record<Exclude<Rhythmus, "einmalig">, number> = {
monatlich: 1,
vierteljaehrlich: 3,
jaehrlich: 12,
};
/** Alle Termine einer laufenden Kostenposition zwischen von und bis (eingeschlossen). */
export function termineLaufend(k: LaufendeKosten, von: Datum, bis: Datum): Datum[] {
if (k.rhythmus === "einmalig") return k.start >= von && k.start <= bis ? [k.start] : [];
const schritt = MONATE_JE_RHYTHMUS[k.rhythmus];
const ende = k.ende && k.ende < bis ? k.ende : bis;
const termine: Datum[] = [];
for (let i = 0; ; i++) {
const t = plusMonate(k.start, i * schritt);
if (t > ende) break;
if (t >= von) termine.push(t);
}
return termine;
}
export function periodenGrenzen(v: Pick<Vorschau, "ansicht" | "start" | "anzahl">): { von: Datum; bis: Datum }[] {
const grenzen: { von: Datum; bis: Datum }[] = [];
let von = v.ansicht === "woche" ? montagDerWoche(v.start) : monatsErster(v.start);
for (let i = 0; i < v.anzahl; i++) {
const naechste = v.ansicht === "woche" ? plusTage(von, 7) : plusMonate(von, 1);
grenzen.push({ von, bis: plusTage(naechste, -1) });
von = naechste;
}
return grenzen;
}
export interface Daten {
einnahmen: Einnahme[];
ausgaben: Ausgabe[];
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;
const ust = v.ust ?? STANDARD_UST;
const posten: Posten[] = [];
// Nettobasis der Zahllast je Voranmeldungszeitraum: Einnahmen minus Kosten mit Vorsteuer
const basisJeZeitraum = new Map<string, Cent>();
const buche = (zeitraum: string, netto: Cent) => basisJeZeitraum.set(zeitraum, (basisJeZeitraum.get(zeitraum) ?? 0) + netto);
for (const e of d.einnahmen) {
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 } : {}), ...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), ...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,
...(k.id ? { quelle: `lk:${k.id}:${t}` } : {}), ...(k.ohneTermine?.includes(t) ? { zaehltNicht: true } : {}) });
}
}
for (const [zeitraum, basis] of [...basisJeZeitraum].sort()) {
const zahllast = prozentVon(basis, ust.satz);
if (zahllast === 0) continue;
posten.push({
datum: faelligkeit(zeitraum, ust),
gruppe: "Umsatzsteuer",
bezeichnung: `${zahllast > 0 ? "USt-Vorauszahlung" : "USt-Erstattung"} ${zeitraum}`,
betrag: -zahllast,
});
}
return 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;
sonstiges: Cent;
/** erster Start und letztes Ende aller Vorgänge und Meilensteine; ohne Termine fließt das Projekt nicht ein */
zeitraum?: { start: Datum; ende: Datum };
/** Abschläge (Termin = Vorgangsende) und einzeln erfasste Einnahmen */
zahlungen: Einnahme[];
/** einzeln erfasste Kosten, Termin = Zahlungstermin */
kosten: Ausgabe[];
}
function anteilig(betrag: Cent, zaehler: Cent, nenner: Cent): Cent {
if (zaehler === nenner) return betrag;
const z = BigInt(betrag) * BigInt(zaehler);
const n = BigInt(nenner);
return Number((2n * z + n) / (2n * n)); // kaufmännisch, alle Werte ≥ 0
}
/**
* Einnahmen und Ausgaben eines Projekts nach den V70-Regeln (Pauschale minus Einzelposten).
* Ohne Termine zählen nur die einzeln erfassten Posten, wie in V70.
*/
export function projektBewegungen(p: ProjektPlan): { einnahmen: Einnahme[]; ausgaben: Ausgabe[] } {
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));
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;
if (pauschal > 0) {
const bleibt = Math.max(0, pauschal - summe(p.kosten.map((k) => k.netto)));
const teile: [Kostenart, Cent, string, boolean][] = [
["material", p.material, "Material (Pauschale)", true],
["fremd", p.fremd, "Fremdleistung (Pauschale)", false],
["sonstiges", p.sonstiges, "Sonstiges (Pauschale)", false],
];
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, ...herkunft(art, `pauschale:${p.id}:${art}`) });
}
}
return { einnahmen, ausgaben };
}
export function liquiditaet(d: Daten, v: Vorschau): Periode[] {
const grenzen = periodenGrenzen(v);
if (grenzen.length === 0) return [];
const alle = bewegungen(d, v, grenzen[grenzen.length - 1]!.bis);
if (v.offeneAb) {
const heute = v.offeneAb, frueh = plusTage(heute, -365), erster = grenzen[0]!.von;
for (const p of alle) {
if (p.gruppe !== "Projekteinnahmen" || p.bezahlt || p.datum >= heute || p.datum < frueh) continue;
p.ueberfaelligSeit = p.datum;
if (p.datum < erster) p.datum = heute;
}
}
// 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 = 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, ...(weg.length ? { ohne: weg } : {}) };
});
}