Files
Betriebsf-hrungssoftware/src/domain/jahresplan.ts
Claude 1d1ba3ace4
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
Stufe 5: Jahresplanung mit Versionen, 12 Monaten, Plan/Ist und BWA-Import (0.22.0)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-21 21:20:22 +00:00

423 lines
19 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Jahresfinanzplanung (Stufe 5, Henning 21.10.2026, Entwurf finanzen/entwurf-jahresplan): ein Jahresplan wird aus
// Bausteinen gebaut (Mitarbeiter, Investitionen, Annahmen) und rechnet die „Treppe“ nach Roos:
// Stunden × Satz + Material/Sub mit Aufschlag = Umsatz → Rohertrag → Personal + Werbung (Ziel ≤ 55 % vom Rohertrag)
// → laufende Kosten → Abschreibungen → Gewinn (Ziel 20 % vom Rohertrag). Der Monatsplan verteilt den Umsatz nach
// der Saison und rechnet bis zum Kontostand am Monatsende. Alle Beträge netto in Cent.
import type { Cent } from "./geld.js";
import type { Posten } from "./liquiditaet.js";
export interface PlanMitarbeiter {
id: string;
name: string;
/** Inhaber: „brutto“ ist der Unternehmerlohn je Monat; angestellt: Bruttolohn je Monat */
art: "inhaber" | "angestellt";
/** verkaufbare Stunden bei einem vollen Jahr */
stunden: number;
brutto: Cent;
/** Arbeitgeberanteile usw., Vorschlag 1,25 */
faktor: number;
/** erster und letzter Monat im Planjahr (1–12) */
eintritt: number;
austritt: number;
/** kommt neu dazu: steht noch nicht in den laufenden Kosten, zählt in der Liquidität als Plan mit */
neu: boolean;
}
export interface PlanInvestition {
id: string;
name: string;
betrag: Cent;
/** Monat der Anschaffung (1–12) */
monat: number;
art: "kauf" | "kredit" | "leasing";
/** Kredit: Eigenanteil; Leasing: Sonderzahlung */
anzahlung: Cent;
/** Kredit- bzw. Leasinglaufzeit in Monaten */
laufzeit: number;
/** Zins % im Jahr (Kredit) */
zins: number;
/** Leasingrate je Monat */
rate: Cent;
/** Nutzungsdauer für die Abschreibung in Jahren (Kauf und Kredit) */
nutzungsdauer: number;
}
export interface PlanAnnahmen {
stundensatz: Cent;
materialEinkauf: Cent;
materialAufschlag: number;
subEinkauf: Cent;
subAufschlag: number;
/** laufende Kosten je Monat ohne Personal (aus „Laufende Kosten“) */
laufendMonat: Cent;
preissteigerung: number;
werbungMonat: Cent;
/** Abschreibungen auf das, was schon da ist, je Jahr */
afaBisher: Cent;
/** Tilgung laufender Kredite je Monat */
tilgungBisher: Cent;
/** Steuer-Vorauszahlungen je Quartal (März, Juni, September, Dezember) */
steuerQuartal: Cent;
kontostandStart: Cent;
mindestgrenze: Cent;
}
export interface PlanDaten {
mitarbeiter: PlanMitarbeiter[];
investitionen: PlanInvestition[];
annahmen: PlanAnnahmen;
/** Anteil am Jahresumsatz je Monat in % */
saison: number[];
}
/** typisch für eine Zimmerei: ruhiger Winter, Saison Mai bis November (Entwurf) */
export const SAISON_HANDWERK = [4, 4, 6, 8, 10, 10, 10, 10, 10, 10, 10, 8];
export const SAISON_GLEICH = Array.from({ length: 12 }, () => 100 / 12);
export const ZIEL_PERSONAL = 55;
export const ZIEL_GEWINN = 20;
export function leererPlan(vorgaben: Partial<PlanAnnahmen> = {}): PlanDaten {
return {
mitarbeiter: [],
investitionen: [],
annahmen: {
stundensatz: 6200, materialEinkauf: 0, materialAufschlag: 15, subEinkauf: 0, subAufschlag: 10,
laufendMonat: 0, preissteigerung: 3, werbungMonat: 0, afaBisher: 0, tilgungBisher: 0, steuerQuartal: 0,
kontostandStart: 0, mindestgrenze: 0, ...vorgaben,
},
saison: [...SAISON_HANDWERK],
};
}
const MONATE = Array.from({ length: 12 }, (_, i) => i + 1);
const null12 = (): Cent[] => Array(12).fill(0);
/** Betrag nach Gewichten auf 12 Monate, Summe bleibt genau (größter Rest) */
export function verteile(betrag: Cent, gewichte: number[]): Cent[] {
const g = gewichte.map((x) => (Number.isFinite(x) && x > 0 ? x : 0));
const s = g.reduce((a, b) => a + b, 0);
if (!s) return verteile(betrag, Array(12).fill(1));
const roh = g.map((x) => (betrag * x) / s);
const teile = roh.map((x) => Math.floor(x));
let rest = betrag - teile.reduce((a, b) => a + b, 0);
const reihenfolge = roh.map((x, i) => [x - Math.floor(x), i] as const).sort((a, b) => b[0] - a[0]);
for (let k = 0; rest > 0; k = (k + 1) % 12, rest--) teile[reihenfolge[k]![1]]! += 1;
return teile;
}
export const aktiv = (m: PlanMitarbeiter, monat: number) => monat >= m.eintritt && monat <= m.austritt;
export const monateAktiv = (m: PlanMitarbeiter) => Math.max(0, Math.min(12, m.austritt) - Math.max(1, m.eintritt) + 1);
export const stundenImJahr = (m: PlanMitarbeiter) => Math.round((m.stunden * monateAktiv(m)) / 12);
export const personalMonat = (m: PlanMitarbeiter): Cent => (m.art === "inhaber" ? m.brutto : Math.round(m.brutto * m.faktor));
/** Annuität: gleiche Monatsrate aus Zins und Tilgung */
export function annuitaet(betrag: Cent, zinsJahr: number, monate: number): Cent {
if (betrag <= 0 || monate <= 0) return 0;
const i = zinsJahr / 1200;
return Math.round(i ? (betrag * i) / (1 - (1 + i) ** -monate) : betrag / monate);
}
export interface InvestitionImJahr {
/** was vom Konto geht: Kauf, Anzahlung, Kredit- oder Leasingrate */
abfluss: Cent[];
/** Kosten in der Treppe: Zinsen und Leasing */
kosten: Cent[];
afa: Cent[];
/** Kreditrate bzw. Leasingrate je Monat (zur Anzeige) */
rate: Cent;
afaJahr: Cent;
}
export function investitionImJahr(v: PlanInvestition): InvestitionImJahr {
const abfluss = null12(), kosten = null12(), afa = null12();
const m0 = Math.min(12, Math.max(1, v.monat)) - 1;
let rate = 0;
if (v.art === "kauf") abfluss[m0]! += v.betrag;
if (v.art === "kredit") {
abfluss[m0]! += v.anzahlung;
const kredit = Math.max(0, v.betrag - v.anzahlung);
rate = annuitaet(kredit, v.zins, v.laufzeit);
let rest = kredit;
for (let k = 1; k <= v.laufzeit && m0 + k < 12 && rest > 0; k++) {
const zins = Math.round((rest * v.zins) / 1200);
const zahlung = Math.min(rate, rest + zins);
abfluss[m0 + k]! += zahlung;
kosten[m0 + k]! += zins;
rest -= zahlung - zins;
}
}
if (v.art === "leasing") {
abfluss[m0]! += v.anzahlung;
rate = v.rate;
// Sonderzahlung verteilt über die Laufzeit als Kosten
const anteil = v.laufzeit > 0 ? Math.round(v.anzahlung / v.laufzeit) : v.anzahlung;
for (let k = 1; k <= v.laufzeit && m0 + k < 12; k++) { abfluss[m0 + k]! += v.rate; kosten[m0 + k]! += v.rate; }
for (let k = 0; k < v.laufzeit && m0 + k < 12; k++) kosten[m0 + k]! += anteil;
}
if (v.art !== "leasing" && v.nutzungsdauer > 0) {
const monatlich = v.betrag / (v.nutzungsdauer * 12);
// ab dem Monat der Anschaffung (monatsgenau wie im Steuerrecht), Summe kaufmännisch gerundet
const jahr = Math.round(monatlich * (12 - m0));
verteile(jahr, MONATE.map((m) => (m - 1 >= m0 ? 1 : 0))).forEach((x, i) => (afa[i] = x));
}
return { abfluss, kosten, afa, rate, afaJahr: afa.reduce((a, b) => a + b, 0) };
}
export type Ampel = "gruen" | "gelb" | "rot";
export const ampelPersonal = (p: number): Ampel => (p <= ZIEL_PERSONAL ? "gruen" : p <= ZIEL_PERSONAL + 5 ? "gelb" : "rot");
export const ampelGewinn = (p: number): Ampel => (p >= ZIEL_GEWINN ? "gruen" : p >= ZIEL_GEWINN - 5 ? "gelb" : "rot");
export interface Treppe {
stunden: number;
stundenUmsatz: Cent;
materialUmsatz: Cent;
subUmsatz: Cent;
umsatz: Cent;
wareneinsatz: Cent;
rohertrag: Cent;
personal: Cent;
unternehmerlohn: Cent;
werbung: Cent;
personalWerbung: Cent;
laufend: Cent;
afa: Cent;
gewinn: Cent;
/** in % vom Rohertrag */
quotePersonal: number;
quoteLaufend: number;
quoteAfa: number;
quoteGewinn: number;
ampelPersonal: Ampel;
ampelGewinn: Ampel;
/** fehlender Gewinn bis 20 % vom Rohertrag (0 = Ziel erreicht) */
luecke: Cent;
}
/** Zeilen des Monatsplans, Ausgaben positiv */
export interface Monate {
umsatz: Cent[];
waren: Cent[];
rohertrag: Cent[];
personal: Cent[];
unternehmerlohn: Cent[];
werbung: Cent[];
laufend: Cent[];
investition: Cent[];
steuer: Cent[];
ueberschuss: Cent[];
kontostand: Cent[];
/** Kosten in der Treppe je Monat (laufend inkl. Zinsen und Leasing), für Plan/Ist */
laufendKosten: Cent[];
afa: Cent[];
/** nur neue Mitarbeiter (Liquidität) */
personalNeu: Cent[];
}
export interface Rechnung {
treppe: Treppe;
monate: Monate;
investitionen: (InvestitionImJahr & { id: string })[];
/** knappster Monat (1–12) */
tief: { monat: number; kontostand: Cent; abstand: Cent };
}
const quote = (x: Cent, basis: Cent) => (basis > 0 ? Math.round((x / basis) * 1000) / 10 : 0);
export function rechne(d: PlanDaten): Rechnung {
const a = d.annahmen;
const stunden = d.mitarbeiter.reduce((s, m) => s + stundenImJahr(m), 0);
const stundenUmsatz = Math.round(stunden * a.stundensatz);
const materialUmsatz = Math.round(a.materialEinkauf * (1 + a.materialAufschlag / 100));
const subUmsatz = Math.round(a.subEinkauf * (1 + a.subAufschlag / 100));
const umsatz = stundenUmsatz + materialUmsatz + subUmsatz;
const wareneinsatz = a.materialEinkauf + a.subEinkauf;
const personal = null12(), unternehmerlohn = null12(), personalNeu = null12();
for (const m of d.mitarbeiter) {
for (const monat of MONATE) {
if (!aktiv(m, monat)) continue;
const k = personalMonat(m);
if (m.art === "inhaber") unternehmerlohn[monat - 1]! += k;
else personal[monat - 1]! += k;
if (m.neu) personalNeu[monat - 1]! += k;
}
}
const lfd = Math.round(a.laufendMonat * (1 + a.preissteigerung / 100));
const investitionen = d.investitionen.map((v) => ({ id: v.id, ...investitionImJahr(v) }));
const afaBisher = verteile(a.afaBisher, Array(12).fill(1));
const monate: Monate = {
umsatz: verteile(umsatz, d.saison),
waren: verteile(wareneinsatz, d.saison),
rohertrag: [], personal, unternehmerlohn, personalNeu,
werbung: Array(12).fill(a.werbungMonat),
laufend: Array(12).fill(lfd),
investition: MONATE.map((m) => a.tilgungBisher + investitionen.reduce((s, v) => s + v.abfluss[m - 1]!, 0)),
steuer: MONATE.map((m) => (m % 3 === 0 ? a.steuerQuartal : 0)),
laufendKosten: MONATE.map((m) => lfd + investitionen.reduce((s, v) => s + v.kosten[m - 1]!, 0)),
afa: MONATE.map((m) => afaBisher[m - 1]! + investitionen.reduce((s, v) => s + v.afa[m - 1]!, 0)),
ueberschuss: [], kontostand: [],
};
let stand = a.kontostandStart;
for (let i = 0; i < 12; i++) {
monate.rohertrag[i] = monate.umsatz[i]! - monate.waren[i]!;
monate.ueberschuss[i] = monate.rohertrag[i]! - personal[i]! - unternehmerlohn[i]! - monate.werbung[i]! - monate.laufend[i]! - monate.investition[i]! - monate.steuer[i]!;
stand += monate.ueberschuss[i]!;
monate.kontostand[i] = stand;
}
const s = (x: Cent[]) => x.reduce((p, q) => p + q, 0);
const rohertrag = umsatz - wareneinsatz;
const personalSumme = s(personal) + s(unternehmerlohn);
const werbung = s(monate.werbung);
const laufend = s(monate.laufendKosten);
const afa = s(monate.afa);
const gewinn = rohertrag - personalSumme - werbung - laufend - afa;
const quotePersonal = quote(personalSumme + werbung, rohertrag);
const quoteGewinn = quote(gewinn, rohertrag);
let ti = 0;
monate.kontostand.forEach((k, i) => { if (k < monate.kontostand[ti]!) ti = i; });
return {
treppe: {
stunden, stundenUmsatz, materialUmsatz, subUmsatz, umsatz, wareneinsatz, rohertrag,
personal: s(personal), unternehmerlohn: s(unternehmerlohn), werbung, personalWerbung: personalSumme + werbung,
laufend, afa, gewinn, quotePersonal, quoteLaufend: quote(laufend, rohertrag), quoteAfa: quote(afa, rohertrag), quoteGewinn,
ampelPersonal: ampelPersonal(quotePersonal), ampelGewinn: ampelGewinn(quoteGewinn),
luecke: Math.max(0, Math.ceil((rohertrag * ZIEL_GEWINN) / 100) - gewinn),
},
monate,
investitionen,
tief: { monat: ti + 1, kontostand: monate.kontostand[ti]!, abstand: monate.kontostand[ti]! - a.mindestgrenze },
};
}
export interface Vorschlag {
id: string;
text: string;
/** Gewinn danach minus Gewinn vorher */
mehrGewinn: Cent;
name: string;
daten: PlanDaten;
}
const kopie = (d: PlanDaten): PlanDaten => JSON.parse(JSON.stringify(d));
const euroGanz = (c: Cent) => `${Math.round(c / 100).toLocaleString("de-DE")} €`;
/**
* Was die Lücke zum Gewinnziel schließen würde, jeweils allein: Stundensatz, Material- oder Sub-Aufschlag.
* Mehr Umsatz hebt auch den Rohertrag und damit das Ziel, deshalb wird mit dem neuen Plan nachgerechnet.
*/
export function vorschlaege(d: PlanDaten): Vorschlag[] {
const r = rechne(d);
if (r.treppe.luecke <= 0) return [];
const a = d.annahmen;
const aus: Vorschlag[] = [];
const reicht = (x: PlanDaten) => rechne(x).treppe.luecke <= 0;
const suche = (start: number, schritt: number, setze: (x: PlanDaten, w: number) => void, max = 400): number | null => {
for (let w = start + schritt, i = 0; i < max; w += schritt, i++) {
const x = kopie(d);
setze(x, w);
if (reicht(x)) return w;
}
return null;
};
if (r.treppe.stunden > 0) {
const satz = suche(Math.ceil(a.stundensatz / 100) * 100, 100, (x, w) => (x.annahmen.stundensatz = w));
if (satz !== null) {
const x = kopie(d);
x.annahmen.stundensatz = satz;
aus.push({ id: "satz", text: `Stundensatz ${euroGanz(a.stundensatz)} → ${euroGanz(satz)}`, name: `Stundensatz ${euroGanz(satz)}`, mehrGewinn: rechne(x).treppe.gewinn - r.treppe.gewinn, daten: x });
}
}
if (a.materialEinkauf > 0) {
const p = suche(Math.ceil(a.materialAufschlag), 1, (x, w) => (x.annahmen.materialAufschlag = w), 200);
if (p !== null) {
const x = kopie(d);
x.annahmen.materialAufschlag = p;
aus.push({ id: "material", text: `Material-Aufschlag ${a.materialAufschlag} → ${p} %`, name: `Material +${p} %`, mehrGewinn: rechne(x).treppe.gewinn - r.treppe.gewinn, daten: x });
}
}
if (a.subEinkauf > 0) {
const p = suche(Math.ceil(a.subAufschlag), 1, (x, w) => (x.annahmen.subAufschlag = w), 200);
if (p !== null) {
const x = kopie(d);
x.annahmen.subAufschlag = p;
aus.push({ id: "sub", text: `Sub-Aufschlag ${a.subAufschlag} → ${p} %`, name: `Sub +${p} %`, mehrGewinn: rechne(x).treppe.gewinn - r.treppe.gewinn, daten: x });
}
}
return aus;
}
const MONAT_KURZ = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
/** Satz zum knappsten Monat und was ihn verursacht, wie in der Liquidität */
export function knappText(d: PlanDaten, r: Rechnung): { satz: string; grund: string } {
const { monat, kontostand, abstand } = r.tief;
const name = MONAT_KURZ[monat - 1]!;
const satz = abstand >= 0
? `Am knappsten wird es Ende ${name} mit ${euroGanz(kontostand)}, ${euroGanz(abstand)} über deiner Mindestgrenze.`
: `Ende ${name} liegt der Kontostand bei ${euroGanz(kontostand)}, ${euroGanz(-abstand)} unter deiner Mindestgrenze.`;
const gruende: string[] = [];
const neue = d.mitarbeiter.filter((m) => m.art === "angestellt" && m.eintritt > 1 && m.eintritt <= monat);
if (neue.length) gruende.push(`${neue.map((m) => m.name).join(" und ")} ${neue.length > 1 ? "fangen" : "fängt"} an`);
const inv = d.investitionen.filter((v) => v.monat <= monat && v.monat >= monat - 2 && (v.art === "kauf" ? v.betrag : v.anzahlung) > 0);
if (inv.length) gruende.push(`${inv.map((v) => v.name).join(" und ")} ${v1(inv.length)} ${inv.some((v) => v.art === "kauf") ? "bezahlt" : "angezahlt"}`);
const saisonBis = d.saison.slice(0, monat);
const schnitt = d.saison.reduce((x, y) => x + y, 0) / 12;
if (saisonBis.at(-1)! < schnitt) gruende.push(`der Umsatz liegt bis dahin bei nur ${Math.round(Math.min(...saisonBis))}–${Math.round(Math.max(...saisonBis))} % je Monat`);
if (monat % 3 === 0 && d.annahmen.steuerQuartal > 0) gruende.push(`die Steuer-Vorauszahlung ist fällig`);
return { satz, grund: gruende.length ? `Grund: ${gruende.join(", ")}.` : "" };
}
const v1 = (n: number) => (n > 1 ? "werden" : "wird");
/** Plan-Zeilen, denen die BWA-Zeilen zugeordnet werden */
export const PLANZEILEN = ["umsatz", "material", "personal", "unternehmerlohn", "werbung", "laufend", "afa", "tilgung", "investition", "steuer"] as const;
export type Planzeile = (typeof PLANZEILEN)[number] | "ignorieren";
export const PLANZEILE_TEXT: Record<Planzeile, string> = {
umsatz: "Umsatz", material: "Material und Subunternehmer", personal: "Personal (Löhne)", unternehmerlohn: "Unternehmerlohn (Privatentnahmen)",
werbung: "Werbung", laufend: "Laufende Kosten", afa: "Abschreibungen", tilgung: "Tilgung", investition: "Investitionen",
steuer: "Steuer-Vorauszahlungen", ignorieren: "nicht im Plan (Steuer, Durchlauf, Summe)",
};
/** Planwerte eines Monats (oder kumuliert bis zum Monat) je Planzeile, Kosten positiv */
export function planWerte(r: Rechnung, monat: number, kumuliert: boolean): Record<(typeof PLANZEILEN)[number], Cent> {
const von = kumuliert ? 0 : monat - 1;
const s = (x: Cent[]) => x.slice(von, monat).reduce((a, b) => a + b, 0);
const m = r.monate;
const investition = r.investitionen.reduce((t, v) => t + v.abfluss.slice(von, monat).reduce((a, b) => a + b, 0), 0);
return {
umsatz: s(m.umsatz), material: s(m.waren), personal: s(m.personal), unternehmerlohn: s(m.unternehmerlohn), werbung: s(m.werbung),
laufend: s(m.laufendKosten), afa: s(m.afa), tilgung: s(m.investition) - investition, investition, steuer: s(m.steuer),
};
}
/**
* Vorschau für die Liquidität (Henning, Entwurf „12 Monate“): ab dem nächsten Monat zählt der Plan, soweit echte
* Zahlungen fehlen. Einnahmen und Material/Sub nur der Rest über den echten Posten des Monats; dazu Löhne neuer
* Mitarbeiter, neue Investitionen und Steuer-Vorauszahlungen. Laufende Kosten stehen schon echt in der Liquidität.
* Plan-Werte sind netto; echte Posten werden dafür um die Umsatzsteuer bereinigt.
*/
export function planPosten(alle: Posten[], plaene: { jahr: number; daten: PlanDaten }[], heute: string, ustSatz: number): Posten[] {
const aus: Posten[] = [];
const ab = heute.slice(0, 7);
const netto = (b: number) => Math.round(b / (1 + ustSatz / 100));
for (const p of plaene) {
const r = rechne(p.daten);
for (let i = 0; i < 12; i++) {
const monat = `${p.jahr}-${String(i + 1).padStart(2, "0")}`;
if (monat <= ab) continue;
const datum = `${monat}-15`, name = `${MONAT_KURZ[i]} ${p.jahr}`;
const imMonat = alle.filter((x) => x.datum.startsWith(monat));
const ein = imMonat.filter((x) => x.gruppe === "Projekteinnahmen").reduce((s, x) => s + netto(x.betrag), 0);
const kosten = -imMonat.filter((x) => x.gruppe === "Projektkosten").reduce((s, x) => s + netto(x.betrag), 0);
const plus = (bezeichnung: string, betrag: number) => { if (betrag) aus.push({ datum, gruppe: "Jahresplan", bezeichnung, betrag }); };
plus(`Plan: weitere Einnahmen ${name}`, Math.max(0, r.monate.umsatz[i]! - ein));
plus(`Plan: Material und Sub ${name}`, -Math.max(0, r.monate.waren[i]! - kosten));
plus(`Plan: Löhne neue Mitarbeiter ${name}`, -r.monate.personalNeu[i]!);
plus(`Plan: Investitionen ${name}`, -r.investitionen.reduce((s, v) => s + v.abfluss[i]!, 0));
plus(`Plan: Steuer-Vorauszahlung ${name}`, -r.monate.steuer[i]!);
}
}
return aus;
}