// 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 = {}): 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 = { 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; }