Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
283 lines
12 KiB
TypeScript
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 } : {}) };
|
|
});
|
|
}
|