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