// 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: */ 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:, kosten:, pauschale::, rest:, lk:: */ 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, 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): { 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(); 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 } : {}) }; }); }