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
This commit is contained in:
164
src/domain/bwa.ts
Normal file
164
src/domain/bwa.ts
Normal file
@@ -0,0 +1,164 @@
|
||||
// BWA von Herrn Seeler einlesen (B1): DATEV-Export „BWA-Wertenachweis“, SKR04. Die .xls-Datei ist eine HTML-Tabelle:
|
||||
// Zeile | Bezeichnung | Konto | | Konten-/Zeilenbeschriftung | Fkt. | Monat je Konto | Monat je Zeile | kumuliert je Konto | kumuliert je Zeile.
|
||||
// Summenzeilen nennen statt Konten die Zeilen, aus denen sie bestehen. Beträge in Cent; Kosten stehen positiv.
|
||||
|
||||
import type { Cent } from "./geld.js";
|
||||
import { type Planzeile, PLANZEILEN, type Rechnung, ZIEL_GEWINN, ZIEL_PERSONAL, planWerte } from "./jahresplan.js";
|
||||
|
||||
export interface BwaKonto { konto: string; name: string; monat: Cent; kumuliert: Cent }
|
||||
export interface BwaZeile { zeile: number; bezeichnung: string; monat: Cent; kumuliert: Cent; konten: BwaKonto[]; summe: boolean }
|
||||
export interface Bwa { jahr: number; monat: number; art: string; zeilen: BwaZeile[] }
|
||||
|
||||
export class BwaFehler extends Error {}
|
||||
|
||||
const entities = (s: string) =>
|
||||
s.replace(/ /gi, " ").replace(/&/gi, "&").replace(/</gi, "<").replace(/>/gi, ">").replace(/"/gi, '"')
|
||||
.replace(/&#(\d+);/g, (_, n) => String.fromCharCode(Number(n))).replace(/&#x([0-9a-f]+);/gi, (_, n) => String.fromCharCode(parseInt(n, 16)));
|
||||
const zelle = (s: string) => entities(s.replace(/<br\s*\/?>/gi, " ").replace(/<[^>]+>/g, "")).replace(/\s+/g, " ").trim();
|
||||
|
||||
/** „59.653,91“ oder „-0,01“ in Cent; leer = null */
|
||||
export function betrag(s: string): Cent | null {
|
||||
const t = s.replace(/\s/g, "");
|
||||
if (!/^-?[\d.]*\d(,\d+)?-?$/.test(t)) return null;
|
||||
const minus = t.startsWith("-") || t.endsWith("-");
|
||||
const [ganz, nach = ""] = t.replace(/-/g, "").replace(/\./g, "").split(",");
|
||||
const c = Number(ganz) * 100 + Number((nach + "00").slice(0, 2));
|
||||
return minus ? -c : c;
|
||||
}
|
||||
|
||||
export function liesBwa(html: string): Bwa {
|
||||
const zeilen = [...html.matchAll(/<tr[^>]*>([\s\S]*?)<\/tr>/gi)].map((m) => [...m[1]!.matchAll(/<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/gi)].map((z) => zelle(z[1]!)));
|
||||
if (!zeilen.length) throw new BwaFehler("In der Datei steht keine Tabelle. Bitte die BWA als .xls aus DATEV (BWA-Wertenachweis) nehmen.");
|
||||
const text = zeilen.map((z) => z.join(" ")).join("\n");
|
||||
const stand = /zum\s+(\d{2})\.(\d{2})\.(\d{4})/.exec(text) ?? /(\w{3})\/(\d{4})/.exec(text);
|
||||
let jahr = 0, monat = 0;
|
||||
if (stand && stand.length === 4) { monat = Number(stand[2]); jahr = Number(stand[3]); }
|
||||
if (!jahr) throw new BwaFehler("Monat und Jahr der BWA nicht gefunden (erwartet „… zum 31.08.2026“).");
|
||||
const art = /(Einnahmen-Ausgaben-BWA|Kurzfristige Erfolgsrechnung|Bewegungsbilanz|Statische Liquidität)/.exec(text)?.[1] ?? "BWA";
|
||||
const aus: BwaZeile[] = [];
|
||||
let akt: BwaZeile | null = null;
|
||||
for (const z of zeilen) {
|
||||
const nr = /^\d{3,4}$/.test(z[0] ?? "") ? Number(z[0]) : null;
|
||||
// Werte stehen in den letzten vier Spalten (Monat Konto/Zeile, kumuliert Konto/Zeile)
|
||||
const w = z.slice(-4).map(betrag);
|
||||
if (nr !== null && z.length >= 6) {
|
||||
akt = { zeile: nr, bezeichnung: z[1] || z[4] || "", monat: w[1] ?? w[0] ?? 0, kumuliert: w[3] ?? w[2] ?? 0, konten: [], summe: false };
|
||||
aus.push(akt);
|
||||
} else if (!akt || !z[2] || z.length < 6) continue;
|
||||
const konto = z[2] ?? "";
|
||||
if (!/^\d{3,}$/.test(konto)) continue;
|
||||
// vierstellig = Verweis auf eine andere Zeile, also eine Summenzeile
|
||||
if (konto.length <= 4) { akt.summe = true; continue; }
|
||||
akt.konten.push({ konto, name: z[4] ?? "", monat: w[0] ?? 0, kumuliert: w[2] ?? 0 });
|
||||
}
|
||||
if (!aus.length) throw new BwaFehler("Keine BWA-Zeilen gefunden. Bitte die BWA als .xls aus DATEV (BWA-Wertenachweis) nehmen.");
|
||||
// Summen wie „Vorläufiges Ergebnis“ ohne Konten, aber mit Gleichheitszeichen oder als Ergebniszeile
|
||||
for (const z of aus) if (/^=|ergebnis|summe|liquiditätsbeitrag|über-\/-unterdeckung|betriebseinnahmen$|betriebsausgaben$|einnahmen-ausgaben-bwa/i.test(z.bezeichnung)) z.summe = true;
|
||||
return { jahr, monat, art, zeilen: aus };
|
||||
}
|
||||
|
||||
// Zuordnung für die Einnahmen-Ausgaben-BWA (Form 43, SKR04), wie in Hennings Muster von Herrn Seeler
|
||||
const VORGABE: Record<number, Planzeile> = {
|
||||
1040: "umsatz", 1050: "umsatz",
|
||||
1230: "material", 1240: "material",
|
||||
1250: "personal",
|
||||
1260: "laufend", 1270: "laufend", 1280: "laufend", 1300: "laufend", 1310: "laufend", 1330: "laufend", 1410: "laufend",
|
||||
1290: "werbung",
|
||||
1320: "afa",
|
||||
1460: "ignorieren", 1681: "ignorieren",
|
||||
1700: "tilgung", 1710: "investition",
|
||||
1800: "unternehmerlohn",
|
||||
1810: "steuer",
|
||||
};
|
||||
|
||||
/** Vorschlag für eine BWA-Zeile: zuerst die bekannte Zeilennummer, sonst nach der Bezeichnung */
|
||||
export function zuordnungVorschlag(z: Pick<BwaZeile, "zeile" | "bezeichnung" | "summe">): Planzeile {
|
||||
if (z.summe) return "ignorieren";
|
||||
if (VORGABE[z.zeile]) return VORGABE[z.zeile]!;
|
||||
const b = z.bezeichnung.toLowerCase();
|
||||
if (/umsatzsteuer|vorsteuer|anzahlung|forderung|verbindlichkeit|privateinlage|darlehen/.test(b)) return "ignorieren";
|
||||
if (/erlös|umsatz/.test(b)) return "umsatz";
|
||||
if (/material|waren|fremdleist/.test(b)) return "material";
|
||||
if (/personal|löhne|gehälter/.test(b)) return "personal";
|
||||
if (/werbe/.test(b)) return "werbung";
|
||||
if (/abschreib|afa/.test(b)) return "afa";
|
||||
if (/privatentnahm/.test(b)) return "unternehmerlohn";
|
||||
if (/tilgung/.test(b)) return "tilgung";
|
||||
if (/raum|fahrzeug|versicherung|beitr|kosten|instandhaltung|werkzeug|zins/.test(b)) return "laufend";
|
||||
return "ignorieren";
|
||||
}
|
||||
|
||||
export interface PlanIstZeile {
|
||||
id: string;
|
||||
text: string;
|
||||
plan: Cent;
|
||||
ist: Cent | null;
|
||||
abweichung: Cent | null;
|
||||
/** in % vom Plan */
|
||||
prozent: number | null;
|
||||
/** Abweichung ab 5 %: gelb, ab 15 % rot; gut = besser als geplant */
|
||||
stufe: "" | "gelb" | "rot" | "gut";
|
||||
/** Kosten: im Plan als negative Zahl gezeigt */
|
||||
kosten: boolean;
|
||||
summe?: boolean;
|
||||
}
|
||||
|
||||
export interface Kennzahl { id: string; text: string; wert: number | null; plan: number; ziel?: number; einheit: "€" | "%"; gut: boolean | null; unter: string }
|
||||
|
||||
/** Ist-Werte je Planzeile aus den BWA-Zeilen: Monat oder kumuliert (Jan bis Monat) */
|
||||
export function istWerte(zeilen: Pick<BwaZeile, "zeile" | "monat" | "kumuliert">[], zuordnung: Map<number, Planzeile>, kumuliert: boolean): Record<string, Cent> {
|
||||
const ist: Record<string, Cent> = Object.fromEntries(PLANZEILEN.map((p) => [p, 0]));
|
||||
for (const z of zeilen) {
|
||||
const p = zuordnung.get(z.zeile);
|
||||
if (!p || p === "ignorieren") continue;
|
||||
ist[p]! += kumuliert ? z.kumuliert : z.monat;
|
||||
}
|
||||
return ist;
|
||||
}
|
||||
|
||||
const ZEILEN: { id: (typeof PLANZEILEN)[number] | "rohertrag" | "ergebnis"; text: string; kosten: boolean; summe?: boolean }[] = [
|
||||
{ id: "umsatz", text: "Umsatzerlöse", kosten: false },
|
||||
{ id: "material", text: "Material und Subunternehmer", kosten: true },
|
||||
{ id: "rohertrag", text: "Rohertrag", kosten: false, summe: true },
|
||||
{ id: "personal", text: "Personalkosten", kosten: true },
|
||||
{ id: "unternehmerlohn", text: "Unternehmerlohn (Privatentnahmen)", kosten: true },
|
||||
{ id: "werbung", text: "Werbekosten", kosten: true },
|
||||
{ id: "laufend", text: "Laufende Kosten (Raum, Fahrzeug, Versicherung, Büro)", kosten: true },
|
||||
{ id: "afa", text: "Abschreibungen", kosten: true },
|
||||
{ id: "ergebnis", text: "Betriebsergebnis", kosten: false, summe: true },
|
||||
{ id: "tilgung", text: "Tilgung Kredite", kosten: true },
|
||||
{ id: "investition", text: "Investitionen", kosten: true },
|
||||
{ id: "steuer", text: "Steuer-Vorauszahlungen (privat)", kosten: true },
|
||||
];
|
||||
|
||||
const ergaenzt = (x: Record<string, Cent>): Record<string, Cent> & { rohertrag: Cent; ergebnis: Cent } => {
|
||||
const rohertrag = x.umsatz! - x.material!;
|
||||
return { ...x, rohertrag, ergebnis: rohertrag - x.personal! - x.unternehmerlohn! - x.werbung! - x.laufend! - x.afa! };
|
||||
};
|
||||
|
||||
export function planIst(r: Rechnung, ist: Record<string, Cent> | null, monat: number, kumuliert: boolean): { zeilen: PlanIstZeile[]; kennzahlen: Kennzahl[] } {
|
||||
const plan = ergaenzt(planWerte(r, monat, kumuliert));
|
||||
const i = ist ? ergaenzt(ist) : null;
|
||||
const zeilen = ZEILEN.map((z): PlanIstZeile => {
|
||||
const p = plan[z.id] ?? 0, w = i ? i[z.id] ?? 0 : null;
|
||||
// Kosten: mehr als geplant ist schlecht; Erlöse und Ergebnis: weniger ist schlecht
|
||||
const abweichung = w === null ? null : z.kosten ? p - w : w - p;
|
||||
const prozent = w === null || !p ? null : Math.round((Math.abs(w - p) / Math.abs(p)) * 1000) / 10;
|
||||
const stufe = abweichung === null || prozent === null || prozent < 5 ? "" : abweichung > 0 ? "gut" : prozent >= 15 ? "rot" : "gelb";
|
||||
return { id: z.id, text: z.text, plan: p, ist: w, abweichung, prozent, stufe, kosten: z.kosten, ...(z.summe ? { summe: true } : {}) };
|
||||
});
|
||||
// Kennzahlen (Roos): Rohertrag, Personal + Werbung vom Rohertrag, Gewinn vom Rohertrag (immer kumuliert)
|
||||
const kum = ergaenzt(planWerte(r, monat, true));
|
||||
const q = (x: Cent, b: Cent) => (b > 0 ? Math.round((x / b) * 100) : null);
|
||||
const pw = (x: Record<string, Cent>) => x.personal! + x.unternehmerlohn! + x.werbung!;
|
||||
const istKum = i && kumuliert ? i : null;
|
||||
const kennzahlen: Kennzahl[] = [
|
||||
{ id: "rohertrag", text: `Rohertrag ${kumuliert ? "bis" : ""}`, wert: i ? i.rohertrag : null, plan: plan.rohertrag, einheit: "€",
|
||||
gut: i ? i.rohertrag >= plan.rohertrag : null, unter: "" },
|
||||
{ id: "personal", text: "Personal + Werbung vom Rohertrag", wert: i ? q(pw(i), i.rohertrag) : null, plan: q(pw(plan), plan.rohertrag) ?? 0, ziel: ZIEL_PERSONAL, einheit: "%",
|
||||
gut: i ? (q(pw(i), i.rohertrag) ?? 999) <= ZIEL_PERSONAL : null, unter: "" },
|
||||
{ id: "gewinn", text: "Gewinn vom Rohertrag", wert: istKum ? q(istKum.ergebnis, istKum.rohertrag) : i ? q(i.ergebnis, i.rohertrag) : null, plan: q(kum.ergebnis, kum.rohertrag) ?? 0, ziel: ZIEL_GEWINN, einheit: "%",
|
||||
gut: i ? (q(i.ergebnis, i.rohertrag) ?? -999) >= ZIEL_GEWINN : null, unter: "" },
|
||||
];
|
||||
return { zeilen, kennzahlen };
|
||||
}
|
||||
422
src/domain/jahresplan.ts
Normal file
422
src/domain/jahresplan.ts
Normal file
@@ -0,0 +1,422 @@
|
||||
// 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;
|
||||
}
|
||||
@@ -11,7 +11,7 @@ import { type Datum, plusTage, plusMonate, montagDerWoche, monatsErster } from "
|
||||
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";
|
||||
export type Gruppe = "Projekteinnahmen" | "Projektkosten" | "Laufende Kosten" | "Umsatzsteuer" | "Jahresplan";
|
||||
export type Kostenart = "material" | "fremd" | "sonstiges";
|
||||
export type Rhythmus = "einmalig" | "monatlich" | "vierteljaehrlich" | "jaehrlich";
|
||||
|
||||
@@ -72,6 +72,8 @@ export interface Vorschau {
|
||||
* 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 {
|
||||
@@ -240,6 +242,7 @@ export function liquiditaet(d: Daten, v: Vorschau): Periode[] {
|
||||
if (p.datum < erster) p.datum = heute;
|
||||
}
|
||||
}
|
||||
if (v.ergaenzen) alle.push(...v.ergaenzen(alle));
|
||||
let kontostand = v.startsaldo;
|
||||
return grenzen.map(({ von, bis }) => {
|
||||
const posten = alle.filter((p) => p.datum >= von && p.datum <= bis).sort((a, b) => a.datum.localeCompare(b.datum));
|
||||
|
||||
Reference in New Issue
Block a user