Stufe 5: Jahresplanung mit Versionen, 12 Monaten, Plan/Ist und BWA-Import (0.22.0)
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

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:
Claude
2026-10-21 21:20:22 +00:00
parent ee5b468502
commit 1d1ba3ace4
19 changed files with 6595 additions and 12 deletions

164
src/domain/bwa.ts Normal file
View 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(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/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
View 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;
}

View File

@@ -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));

View File

@@ -39,7 +39,8 @@ function recht(methode: string, muster: string | undefined, url: string): Recht
const k = `${methode} ${muster ?? ""}`;
if (OFFEN.has(k)) return "offen";
if (muster?.startsWith("/api/ich/") || muster === "/api/ich" || ALLE.has(k)) return "alle";
if (muster?.startsWith("/api/benutzer") || INHABER.has(k)) return "inhaber";
// Jahresplan und BWA (Stufe 5) nur für den Inhaber
if (muster?.startsWith("/api/benutzer") || muster?.startsWith("/api/jahresplan") || muster?.startsWith("/api/bwa") || muster?.startsWith("/api/finanzmonat") || INHABER.has(k)) return "inhaber";
return muster ? "buero" : "inhaber";
}

View File

@@ -28,6 +28,8 @@ import { registriereUrlaub, zeitraumText } from "./urlaub.js";
import { vorlageAnwenden } from "./vorlage.js";
import { AngebotFehler, pruefeBearbeitbar, registriereAngebote } from "./angebote.js";
import { registriereStammdaten } from "./stammdaten.js";
import { finanzsitzungAnlegen, geltendePlaene, jahresplanStand, registriereJahresplan } from "./jahresplan.js";
import { planPosten } from "../domain/jahresplan.js";
import { type BezugArt, bezugsTage } from "../domain/bezug.js";
import { formatDatum, plusTage } from "../domain/datum.js";
@@ -96,6 +98,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
registriereAngebote(app, pool, ladeEinstellungen, mitOrdner);
registriereStammdaten(app, pool, ladeEinstellungen);
registriereJahresplan(app, pool, { einstellungen: ladeEinstellungen, liquiDaten: () => liquiDaten() });
app.post("/api/projekte/:id/ordner", async (req, reply) => {
const { id } = IdParam.parse(req.params);
@@ -310,7 +313,8 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
offene: z.enum(["0", "1"]).optional(),
});
async function berechneLiquiditaet(q: z.infer<typeof LiquiAnfrage>) {
/** Projekte, Zahlungen, Kosten und laufende Kosten für die Liquidität */
async function liquiDaten() {
const e = await ladeEinstellungen();
const [projekte, vorgaenge, zahlungen, kosten, laufend] = await Promise.all([
pool.query("select * from projekt"),
@@ -319,7 +323,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
pool.query("select * from kosten"),
pool.query("select * from laufende_kosten"),
]);
const daten = liquiditaetsDaten(
return liquiditaetsDaten(
{
projekte: projekte.rows,
vorgaenge: vorgaenge.rows,
@@ -331,9 +335,18 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
},
{ tage: e.arbeitstage },
);
}
async function berechneLiquiditaet(q: z.infer<typeof LiquiAnfrage>) {
const e = await ladeEinstellungen();
const daten = await liquiDaten();
const start = q.start ?? new Date().toISOString().slice(0, 10);
// Stufe 5: der geltende Jahresplan als Vorschau, wo echte Zahlungen fehlen
const jahr = Number(start.slice(0, 4));
const plaene = e.jahresplanVorschau ? await geltendePlaene(pool, jahr, jahr + 3) : [];
return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust,
offeneAb: q.offene === "1" ? start : undefined });
offeneAb: q.offene === "1" ? start : undefined,
ergaenzen: plaene.length ? (alle) => planPosten(alle, plaene, new Date().toISOString().slice(0, 10), e.ust.satz) : undefined });
}
app.get("/api/liquiditaet", async (req) => berechneLiquiditaet(LiquiAnfrage.parse(req.query)));
@@ -349,7 +362,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
const mindestgrenze = e.mindestgrenzeArt === "fest" ? e.mindestreserve : laufendMonat;
return {
heute, wochen, kontostand: e.startsaldo, kontostandDatum: e.startsaldoDatum,
mindestgrenze, mindestgrenzeArt: e.mindestgrenzeArt, festerBetrag: e.mindestreserve, laufendMonat,
mindestgrenze, mindestgrenzeArt: e.mindestgrenzeArt, festerBetrag: e.mindestreserve, laufendMonat, jahresplanVorschau: e.jahresplanVorschau,
lage: lage(wochen, e.startsaldo, mindestgrenze),
};
}
@@ -363,16 +376,19 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
const heute = z.object({ heute: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional() }).parse(req.query).heute ?? new Date().toISOString().slice(0, 10);
const e = await ladeEinstellungen();
const woche = { tage: e.arbeitstage };
const [tp, aufgaben, liqui] = await Promise.all([
// Stufe 5: Finanzsitzung am ersten Freitag im Monat, sobald es einen Jahresplan gibt
if (e.finanzsitzung) await transaktion(pool, benutzer(req), (c) => finanzsitzungAnlegen(c, heute));
const [tp, aufgaben, liqui, jahresplan] = await Promise.all([
terminplan(pool, woche, e.stundenProTag),
pool.query(`select a.*, p.nummer as projekt_nummer, p.bezeichnung as projekt_name, k.name as kontakt_name, g.name as kategorie
from aufgabe a left join projekt p on p.id = a.projekt_id left join kontakt k on k.id = a.kontakt_id
left join aufgabe_kategorie g on g.id = a.kategorie_id
where a.erledigt_am is null order by a.faellig_am nulls last, a.angelegt_am`),
liquiLage(heute, 4),
req.wer?.rolle === "inhaber" ? jahresplanStand(pool, liquiDaten, heute) : null,
]);
const u = { ...uebersicht({ heute, woche, tp, aufgaben: aufgaben.rows, liqui: liqui.wochen, mindestreserve: liqui.mindestgrenze,
kontostandErfasst: e.startsaldo !== 0 || e.startsaldoDatum !== null }), liquiLage: { ...liqui, wochen: undefined } };
kontostandErfasst: e.startsaldo !== 0 || e.startsaldoDatum !== null }), liquiLage: { ...liqui, wochen: undefined }, jahresplan };
// M10: offene Urlaubsanträge oben in den Warnungen, damit kein Mitarbeiter auf Antwort wartet
const antraege = await pool.query(`select a.von, a.bis, a.kontakt_id, k.name from abwesenheit a join kontakt k on k.id = a.kontakt_id
where a.art = 'urlaub' and a.status = 'beantragt' order by a.von`);

View File

@@ -47,6 +47,10 @@ export const EinstellungenSchema = z.object({
mindestreserve: z.number().int().default(0),
// Mindestgrenze der Liquidität (Henning, 21.10.2026): automatisch ein Monat laufende Kosten oder fest der Betrag oben
mindestgrenzeArt: z.enum(["auto", "fest"]).default("auto"),
// Stufe 5: der geltende Jahresplan zählt in der Liquidität als Vorschau, wo echte Zahlungen fehlen
jahresplanVorschau: z.boolean().default(true),
// Finanzsitzung am ersten Freitag im Monat als Aufgabe, sobald es einen Jahresplan gibt
finanzsitzung: z.boolean().default(true),
// M3: immer voll abziehen (6:10 → 5:40, Henning 20.10.2026) oder knapp über einer Grenze nur bis zur Grenze (6:10 → 6:00)
pausenabzug: z.enum(["bis_grenze", "voll"]).default("voll"),
// geheimer Teil der Kalender-Links (T11); Outlook classic kann sich nicht anmelden

305
src/server/jahresplan.ts Normal file
View File

@@ -0,0 +1,305 @@
// Jahresfinanzplanung und BWA (Stufe 5, Henning 21.10.2026). Nur für den Inhaber (Rollen im Heft).
// Ein Jahr hat Versionen: die Basis bleibt, eine Version „gilt“ und speist Liquidität, Übersicht und Plan/Ist.
import type { FastifyInstance, FastifyRequest } from "fastify";
import { z } from "zod";
import { type Client, type Pool, transaktion } from "./db.js";
import type { Einstellungen } from "./einstellungen.js";
import { werName } from "./anmeldung.js";
import { type PlanDaten, PLANZEILEN, type Planzeile, SAISON_HANDWERK, leererPlan, rechne, vorschlaege, knappText } from "../domain/jahresplan.js";
import { BwaFehler, istWerte, liesBwa, planIst, zuordnungVorschlag } from "../domain/bwa.js";
import type { Daten, LaufendeKosten } from "../domain/liquiditaet.js";
import { laufendJeMonat } from "../domain/lage.js";
import { type Datum, plusTage, wochentag } from "../domain/datum.js";
const cent = z.number().int().min(0).max(10_000_000_000);
const monat = z.number().int().min(1).max(12);
const PlanSchema = z.object({
mitarbeiter: z.array(z.object({
id: z.string().min(1).max(40), name: z.string().trim().min(1).max(100), art: z.enum(["inhaber", "angestellt"]),
stunden: z.number().min(0).max(4000), brutto: cent, faktor: z.number().min(1).max(3).default(1.25),
eintritt: monat.default(1), austritt: monat.default(12), neu: z.boolean().default(false),
})).max(50).default([]),
investitionen: z.array(z.object({
id: z.string().min(1).max(40), name: z.string().trim().min(1).max(100), betrag: cent, monat: monat.default(1),
art: z.enum(["kauf", "kredit", "leasing"]).default("kauf"), anzahlung: cent.default(0), laufzeit: z.number().int().min(0).max(360).default(60),
zins: z.number().min(0).max(30).default(5), rate: cent.default(0), nutzungsdauer: z.number().min(0).max(50).default(6),
})).max(50).default([]),
annahmen: z.object({
stundensatz: cent, materialEinkauf: cent, materialAufschlag: z.number().min(0).max(500), subEinkauf: cent, subAufschlag: z.number().min(0).max(500),
laufendMonat: cent, preissteigerung: z.number().min(-50).max(100), werbungMonat: cent, afaBisher: cent, tilgungBisher: cent, steuerQuartal: cent,
kontostandStart: z.number().int().min(-10_000_000_000).max(10_000_000_000), mindestgrenze: cent,
}),
saison: z.array(z.number().min(0).max(100)).length(12),
});
const Jahr = z.coerce.number().int().min(2000).max(2100);
/** erster Freitag eines Monats */
export function ersterFreitag(jahr: number, m: number): Datum {
const erster = `${jahr}-${String(m).padStart(2, "0")}-01`;
return plusTage(erster, (5 - wochentag(erster) + 7) % 7);
}
const MONATSNAMEN = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
/**
* Finanzsitzung als wiederkehrende Aufgabe (Roos: monatlich, Henning: erster Freitag = Bürotag). Das Programm legt
* sie für den laufenden Monat an, sobald es einen Jahresplan gibt; erledigt oder gelöscht bleibt sie für diesen Monat weg.
*/
export async function finanzsitzungAnlegen(c: Client | Pool, heute: Datum): Promise<void> {
if (!(await c.query("select 1 from jahresplan limit 1")).rowCount) return;
const jahr = Number(heute.slice(0, 4)), m = Number(heute.slice(5, 7));
const serie = `finanzsitzung-${heute.slice(0, 7)}`;
const vor = m === 1 ? { m: 12, j: jahr - 1 } : { m: m - 1, j: jahr };
// eine gelöschte Aufgabe nicht wieder anlegen: der Monat steht dann im Protokoll
if ((await c.query("select 1 from protokoll where tabelle = 'aufgabe' and aktion = 'loeschen' and vorher->>'serie' = $1 limit 1", [serie])).rowCount) return;
await c.query(`insert into aufgabe (text, faellig_am, serie) values ($1, $2, $3) on conflict (serie) do nothing`,
[`Finanzsitzung: BWA ${MONATSNAMEN[vor.m - 1]} ${vor.j} durchgehen (Jahresplanung → Plan / Ist)`, ersterFreitag(jahr, m), serie]);
}
interface Hilfen {
einstellungen: () => Promise<Einstellungen>;
/** Projekte, Zahlungen und Kosten wie in der Liquidität */
liquiDaten: () => Promise<Daten>;
}
export function registriereJahresplan(app: FastifyInstance, pool: Pool, h: Hilfen): void {
const wer = (req: FastifyRequest) => werName(req);
const heute = () => new Date().toISOString().slice(0, 10);
async function laufend(): Promise<LaufendeKosten[]> {
return (await pool.query("select bezeichnung, kategorie, betrag, rhythmus, start, ende from laufende_kosten")).rows
.map((l) => ({ bezeichnung: l.bezeichnung, kategorie: l.kategorie ?? undefined, betrag: Number(l.betrag), rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined }));
}
/** Was der Plan aus dem Programm übernehmen kann: laufende Kosten (Personal getrennt), Kontostand, Mindestgrenze, BWA des Vorjahres */
async function vorlagen(jahr: number) {
const e = await h.einstellungen();
const lk = await laufend();
// im Planjahr laufende Posten, jeder Rhythmus auf den Monat umgerechnet (einmalige zählen nicht)
const imJahr = (k: LaufendeKosten) => k.rhythmus !== "einmalig" && k.start <= `${jahr}-12-31` && (!k.ende || k.ende >= `${jahr}-01-01`);
const jeMonat = (k: LaufendeKosten) => (imJahr(k) ? Math.round(k.betrag / ({ monatlich: 1, vierteljaehrlich: 3, jaehrlich: 12, einmalig: 1 } as const)[k.rhythmus]) : 0);
const istPersonal = (k: LaufendeKosten) => /personal|lohn|gehalt/i.test(`${k.kategorie ?? ""} ${k.bezeichnung}`);
const posten = lk.filter(imJahr).map((k) => ({ bezeichnung: k.bezeichnung, kategorie: k.kategorie ?? "", monat: jeMonat(k), personal: istPersonal(k) }));
const ohnePersonal = posten.filter((k) => !k.personal).reduce((x, k) => x + k.monat, 0);
const personal = posten.filter((k) => k.personal).reduce((x, k) => x + k.monat, 0);
const mindestgrenze = e.mindestgrenzeArt === "fest" ? e.mindestreserve : laufendJeMonat(lk, heute());
// BWA des Vorjahres: jüngster Monat mit kumulierten Werten, aufs Jahr hochgerechnet
const zu = await zuordnung();
const vj = (await pool.query("select monat, zeilen from finanz_monat where jahr = $1 and zeilen is not null order by monat desc limit 1", [jahr - 1])).rows[0];
let vorjahr = null;
if (vj) {
const ist = istWerte(vj.zeilen, zu, true);
const f = 12 / vj.monat;
vorjahr = { monate: vj.monat, umsatz: Math.round(ist.umsatz! * f), material: Math.round(ist.material! * f), laufendMonat: Math.round((ist.laufend! / vj.monat)),
werbungMonat: Math.round(ist.werbung! / vj.monat), afa: Math.round(ist.afa! * f), tilgungMonat: Math.round(ist.tilgung! / vj.monat),
steuerQuartal: Math.round((ist.steuer! / vj.monat) * 3), unternehmerlohnMonat: Math.round(ist.unternehmerlohn! / vj.monat) };
}
// Saison aus dem Vorjahr: Erlöse je Monat aus den eingelesenen BWA (Monatswerte)
const monate = (await pool.query("select monat, zeilen from finanz_monat where jahr = $1 and zeilen is not null order by monat", [jahr - 1])).rows;
const saisonVorjahr = monate.map((r) => ({ monat: r.monat as number, umsatz: istWerte(r.zeilen, zu, false).umsatz! }));
const personalListe = (await pool.query(`select k.name, m.angestellt, m.lohn_cent, m.eintritt, m.austritt from mitarbeiter m join kontakt k on k.id = m.kontakt_id
where m.austritt is null or m.austritt >= $1 order by m.angestellt, k.name`, [`${jahr}-01-01`])).rows;
return { laufend: { ohnePersonal, personal, posten }, kontostand: e.startsaldo, mindestgrenze, vorjahr, saisonVorjahr, personal: personalListe,
stundensatzEk: e.kalkulation.stundensaetze.geselle };
}
async function zuordnung(): Promise<Map<number, Planzeile>> {
return new Map((await pool.query("select zeile, planzeile from bwa_zuordnung")).rows.map((r) => [r.zeile as number, r.planzeile as Planzeile]));
}
/** neuer Plan: Annahmen aus laufenden Kosten, Kontostand, Mindestgrenze und, wenn da, der BWA des Vorjahres */
async function startPlan(jahr: number): Promise<PlanDaten> {
const v = await vorlagen(jahr);
const d = leererPlan({
laufendMonat: v.laufend.ohnePersonal, kontostandStart: v.kontostand, mindestgrenze: v.mindestgrenze,
...(v.vorjahr ? { materialEinkauf: v.vorjahr.material, werbungMonat: v.vorjahr.werbungMonat, afaBisher: v.vorjahr.afa,
tilgungBisher: v.vorjahr.tilgungMonat, steuerQuartal: v.vorjahr.steuerQuartal } : {}),
});
d.mitarbeiter.push({ id: "inhaber", name: "Inhaber", art: "inhaber", stunden: 900, brutto: v.laufend.personal || v.vorjahr?.unternehmerlohnMonat || 0, faktor: 1, eintritt: 1, austritt: 12, neu: false });
v.personal.filter((p) => p.angestellt).forEach((p, i) => {
const ein = p.eintritt && p.eintritt.slice(0, 4) === String(jahr) ? Number(p.eintritt.slice(5, 7)) : 1;
const aus = p.austritt && p.austritt.slice(0, 4) === String(jahr) ? Number(p.austritt.slice(5, 7)) : 12;
// Stundenlohn aus Personal × 173 Stunden im Monat
d.mitarbeiter.push({ id: `m${i + 1}`, name: p.name, art: "angestellt", stunden: 1400, brutto: Math.round(Number(p.lohn_cent ?? 0) * 173), faktor: 1.25, eintritt: ein, austritt: aus, neu: false });
});
if (v.saisonVorjahr.length === 12) d.saison = saisonAus(v.saisonVorjahr.map((x) => x.umsatz));
return d;
}
const zeile = (r: Record<string, any>) => ({ id: r.id, jahr: r.jahr, name: r.name, basis: r.basis, gilt: r.gilt, daten: r.daten as PlanDaten, geaendert_am: r.geaendert_am });
const beauftragt = async (jahr: number) => beauftragtJeMonat(await h.liquiDaten(), jahr);
app.get("/api/jahresplan", async (req) => {
const q = z.object({ jahr: Jahr.optional() }).parse(req.query);
const jahre = (await pool.query("select distinct jahr from jahresplan order by jahr")).rows.map((r) => r.jahr as number);
const jetzt = Number(heute().slice(0, 4));
// ohne Angabe: das nächste Jahr ab Oktober, sonst das laufende
const jahr = q.jahr ?? (jahre.includes(jetzt) && heute().slice(5, 7) < "10" ? jetzt : jahre.find((j) => j > jetzt) ?? (heute().slice(5, 7) >= "10" ? jetzt + 1 : jetzt));
await finanzsitzungAnlegen(pool, heute());
const versionen = (await pool.query("select * from jahresplan where jahr = $1 order by basis desc, angelegt_am", [jahr])).rows.map(zeile);
return { jahr, jahre, versionen, vorlagen: await vorlagen(jahr), beauftragt: await beauftragt(jahr) };
});
app.post("/api/jahresplan", async (req, reply) => {
const q = z.object({ jahr: Jahr, name: z.string().trim().min(1).max(80).optional(), von: z.uuid().optional(), daten: PlanSchema.optional() }).parse(req.body);
const daten = q.daten ?? (q.von ? (await pool.query("select daten from jahresplan where id = $1", [q.von])).rows[0]?.daten : await startPlan(q.jahr));
if (!daten) return reply.status(404).send({ fehler: "Version nicht gefunden" });
const neu = await transaktion(pool, wer(req), async (c) => {
const erste = !(await c.query("select 1 from jahresplan where jahr = $1", [q.jahr])).rowCount;
const r = (await c.query("insert into jahresplan (jahr, name, basis, gilt, daten) values ($1, $2, $3, $3, $4) returning *",
[q.jahr, q.name ?? (erste ? "Basis" : "Neue Version"), erste, PlanSchema.parse(daten)])).rows[0];
await finanzsitzungAnlegen(c, heute());
return r;
});
return reply.status(201).send(zeile(neu));
});
app.patch("/api/jahresplan/:id", async (req, reply) => {
const { id } = z.object({ id: z.uuid() }).parse(req.params);
const q = z.object({ name: z.string().trim().min(1).max(80).optional(), daten: PlanSchema.optional(), gilt: z.literal(true).optional() }).parse(req.body);
const r = await transaktion(pool, wer(req), async (c) => {
const alt = (await c.query("select * from jahresplan where id = $1", [id])).rows[0];
if (!alt) return null;
if (q.gilt) await c.query("update jahresplan set gilt = false where jahr = $1 and gilt and id <> $2", [alt.jahr, id]);
return (await c.query("update jahresplan set name = coalesce($2, name), daten = coalesce($3, daten), gilt = gilt or coalesce($4, false) where id = $1 returning *",
[id, q.name ?? null, q.daten ?? null, q.gilt ?? null])).rows[0];
});
return r ? zeile(r) : reply.status(404).send({ fehler: "Nicht gefunden" });
});
app.delete("/api/jahresplan/:id", async (req, reply) => {
const { id } = z.object({ id: z.uuid() }).parse(req.params);
const r = await transaktion(pool, wer(req), async (c) => {
const alt = (await c.query("select * from jahresplan where id = $1", [id])).rows[0];
if (!alt) return 404;
if (alt.basis) return 409;
await c.query("delete from jahresplan where id = $1", [id]);
if (alt.gilt) await c.query("update jahresplan set gilt = true where jahr = $1 and basis", [alt.jahr]);
return 204;
});
if (r === 409) return reply.status(409).send({ fehler: "Die Basis bleibt immer erhalten." });
return r === 204 ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
});
/** Vorschläge, um die Lücke zum Gewinnziel zu schließen; ein Klick legt die Version an */
app.get("/api/jahresplan/:id/vorschlaege", async (req, reply) => {
const { id } = z.object({ id: z.uuid() }).parse(req.params);
const p = (await pool.query("select daten from jahresplan where id = $1", [id])).rows[0];
if (!p) return reply.status(404).send({ fehler: "Nicht gefunden" });
return vorschlaege(PlanSchema.parse(p.daten)).map(({ daten: _, ...v }) => v);
});
// ---------- BWA und Plan/Ist ----------
app.post("/api/bwa", async (req, reply) => {
const q = z.object({ dateiname: z.string().max(200).default(""), inhalt: z.string().min(1).max(20_000_000) }).parse(req.body);
let b;
try { b = liesBwa(q.inhalt); } catch (err) {
if (err instanceof BwaFehler) return reply.status(400).send({ fehler: err.message });
throw err;
}
const neu = await transaktion(pool, wer(req), async (c) => {
await c.query(`insert into finanz_monat (jahr, monat, dateiname, bwa_art, eingelesen_am, zeilen) values ($1, $2, $3, $4, now(), $5)
on conflict (jahr, monat) do update set dateiname = $3, bwa_art = $4, eingelesen_am = now(), zeilen = $5`,
[b.jahr, b.monat, q.dateiname, b.art, JSON.stringify(b.zeilen)]);
const da = new Set((await c.query("select zeile from bwa_zuordnung")).rows.map((r) => r.zeile as number));
const neue = [];
for (const z of b.zeilen) {
if (da.has(z.zeile)) continue;
const p = zuordnungVorschlag(z);
await c.query("insert into bwa_zuordnung (zeile, bezeichnung, planzeile) values ($1, $2, $3)", [z.zeile, z.bezeichnung, p]);
if (!z.summe && (z.monat || z.kumuliert)) neue.push({ zeile: z.zeile, bezeichnung: z.bezeichnung, planzeile: p });
}
return neue;
});
return reply.status(201).send({ jahr: b.jahr, monat: b.monat, art: b.art, zeilen: b.zeilen.length, neu: neu });
});
app.delete("/api/bwa/:jahr/:monat", async (req) => {
const p = z.object({ jahr: Jahr, monat: z.coerce.number().int().min(1).max(12) }).parse(req.params);
await transaktion(pool, wer(req), (c) => c.query("update finanz_monat set zeilen = null, dateiname = null, bwa_art = null, eingelesen_am = null where jahr = $1 and monat = $2", [p.jahr, p.monat]));
return { ok: true };
});
app.put("/api/bwa/zuordnung/:zeile", async (req) => {
const { zeile: nr } = z.object({ zeile: z.coerce.number().int().min(0).max(99999) }).parse(req.params);
const { planzeile } = z.object({ planzeile: z.enum([...PLANZEILEN, "ignorieren"]) }).parse(req.body);
await transaktion(pool, wer(req), (c) => c.query(`insert into bwa_zuordnung (zeile, planzeile) values ($1, $2)
on conflict (zeile) do update set planzeile = $2`, [nr, planzeile]));
return { zeile: nr, planzeile };
});
app.put("/api/finanzmonat/:jahr/:monat", async (req) => {
const p = z.object({ jahr: Jahr, monat: z.coerce.number().int().min(1).max(12) }).parse(req.params);
const q = z.object({ notizen: z.record(z.string(), z.string().max(500)).optional(), erledigt: z.array(z.string().max(40)).max(30).optional() }).parse(req.body);
const r = await transaktion(pool, wer(req), async (c) => (await c.query(`insert into finanz_monat (jahr, monat, notizen, erledigt) values ($1, $2, coalesce($3, '{}'::jsonb), coalesce($4, '[]'::jsonb))
on conflict (jahr, monat) do update set notizen = coalesce($3, finanz_monat.notizen), erledigt = coalesce($4, finanz_monat.erledigt) returning notizen, erledigt`,
[p.jahr, p.monat, q.notizen ? JSON.stringify(q.notizen) : null, q.erledigt ? JSON.stringify(q.erledigt) : null])).rows[0]);
return r;
});
app.get("/api/jahresplan/planist", async (req) => {
const q = z.object({ jahr: Jahr, monat: z.coerce.number().int().min(1).max(12).optional(), kumuliert: z.enum(["0", "1"]).default("0") }).parse(req.query);
// ohne Plan für das Jahr zeigt die Seite nur die Ist-Werte (z. B. die BWA des laufenden Jahres)
const plan = (await pool.query("select * from jahresplan where jahr = $1 and gilt", [q.jahr])).rows[0];
const monate = (await pool.query("select monat, dateiname, bwa_art, eingelesen_am, zeilen is not null as bwa, notizen, erledigt from finanz_monat where jahr = $1 order by monat", [q.jahr])).rows;
const mitBwa = monate.filter((m) => m.bwa);
const m = q.monat ?? mitBwa.at(-1)?.monat ?? Math.max(1, Number(heute().slice(5, 7)) - 1);
const fm = (await pool.query("select * from finanz_monat where jahr = $1 and monat = $2", [q.jahr, m])).rows[0];
const zu = await zuordnung();
const kumuliert = q.kumuliert === "1";
const r = rechne(plan ? PlanSchema.parse(plan.daten) : leererPlan());
const ergebnis = planIst(r, fm?.zeilen ? istWerte(fm.zeilen, zu, kumuliert) : null, m, kumuliert);
const alleZeilen = (await pool.query("select zeile, bezeichnung, planzeile from bwa_zuordnung order by zeile")).rows;
const werte = new Map<number, { monat: number; kumuliert: number; summe: boolean; bezeichnung: string }>((fm?.zeilen ?? []).map((z: any) => [z.zeile, z]));
return {
jahr: q.jahr, monat: m, kumuliert, plan: plan ? { id: plan.id, name: plan.name } : null,
monate: monate.map(({ notizen: _n, erledigt: _e, ...x }) => x),
bwa: fm?.zeilen ? { dateiname: fm.dateiname, art: fm.bwa_art, eingelesen_am: fm.eingelesen_am } : null,
notizen: fm?.notizen ?? {}, erledigt: fm?.erledigt ?? [],
...ergebnis,
zuordnung: alleZeilen.filter((z) => !werte.get(z.zeile)?.summe).map((z) => ({ ...z, bezeichnung: werte.get(z.zeile)?.bezeichnung ?? z.bezeichnung,
monatswert: werte.get(z.zeile)?.monat ?? null, kumuliert: werte.get(z.zeile)?.kumuliert ?? null })),
sitzung: ersterFreitag(m === 12 ? q.jahr + 1 : q.jahr, m === 12 ? 1 : m + 1),
};
});
app.get("/api/jahresplan/stand", async () => jahresplanStand(pool, h.liquiDaten, heute()));
}
/** beauftragter Umsatz je Monat (netto, nach Rechnungstermin) aus Projekten ab „beauftragt“ */
function beauftragtJeMonat(d: Daten, jahr: number): number[] {
const m = Array(12).fill(0);
for (const e of d.einnahmen) if (e.termin.startsWith(`${jahr}-`)) m[Number(e.termin.slice(5, 7)) - 1] += e.netto;
return m;
}
/** Übersicht: wie viel Umsatz im Planjahr noch verkauft werden muss (Stufe-5-Abnahme) */
export async function jahresplanStand(pool: Pool, liquiDaten: () => Promise<Daten>, heute: Datum) {
const p = (await pool.query("select jahr, name, daten from jahresplan where gilt and jahr >= $1 order by jahr limit 1", [Number(heute.slice(0, 4))])).rows[0];
if (!p) return null;
const daten = PlanSchema.parse(p.daten);
const r = rechne(daten);
const b = beauftragtJeMonat(await liquiDaten(), p.jahr).reduce((x, y) => x + y, 0);
return { jahr: p.jahr as number, name: p.name as string, umsatz: r.treppe.umsatz, beauftragt: b, offen: Math.max(0, r.treppe.umsatz - b),
knapp: knappText(daten, r).satz, gewinnQuote: r.treppe.quoteGewinn };
}
/** gilt-Versionen der Jahre, die die Liquidität als Vorschau braucht */
export async function geltendePlaene(pool: Pool, vonJahr: number, bisJahr: number): Promise<{ jahr: number; daten: PlanDaten }[]> {
return (await pool.query("select jahr, daten from jahresplan where gilt and jahr between $1 and $2", [vonJahr, bisJahr])).rows
.map((r) => ({ jahr: r.jahr as number, daten: PlanSchema.parse(r.daten) }));
}
/** Saison in % aus Umsätzen je Monat, auf ganze Prozent, Summe 100 */
export function saisonAus(umsaetze: number[]): number[] {
const s = umsaetze.reduce((a, b) => a + Math.max(0, b), 0);
if (!s) return [...SAISON_HANDWERK];
const roh = umsaetze.map((u) => (Math.max(0, u) / s) * 100);
const ganz = roh.map(Math.floor);
let rest = 100 - ganz.reduce((a, b) => a + b, 0);
roh.map((x, i) => [x - Math.floor(x), i] as const).sort((a, b) => b[0] - a[0]).forEach(([, i]) => { if (rest-- > 0) ganz[i]! += 1; });
return ganz;
}

View File

@@ -0,0 +1,56 @@
-- Jahresfinanzplanung und BWA (Stufe 5, Henning 21.10.2026): Versionen eines Jahresplans (Bausteine als JSON,
-- die Basis bleibt, eine Version „gilt“ für Liquidität und Übersicht), je Monat die eingelesene BWA mit Notizen und
-- der Checkliste der Finanzsitzung, und die einmalige Zuordnung der BWA-Zeilen zu den Planzeilen.
create table jahresplan (
id uuid primary key default gen_random_uuid(),
jahr integer not null check (jahr between 2000 and 2100),
name text not null check (trim(name) <> ''),
basis boolean not null default false,
gilt boolean not null default false,
daten jsonb not null default '{}',
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
create unique index jahresplan_basis on jahresplan (jahr) where basis;
create unique index jahresplan_gilt on jahresplan (jahr) where gilt;
create trigger jahresplan_protokoll before insert or update or delete on jahresplan
for each row execute function stempel_und_protokoll();
create table finanz_monat (
id uuid primary key default gen_random_uuid(),
jahr integer not null check (jahr between 2000 and 2100),
monat integer not null check (monat between 1 and 12),
-- eingelesene BWA: Zeilen mit Monats- und kumulierten Werten (Cent) und ihren Konten
dateiname text,
bwa_art text,
eingelesen_am timestamptz,
zeilen jsonb,
-- Notiz je Planzeile zur Abweichung, z. B. „Holz teurer“
notizen jsonb not null default '{}',
-- abgehakte Punkte der Finanzsitzung
erledigt jsonb not null default '[]',
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system',
unique (jahr, monat)
);
create trigger finanz_monat_protokoll before insert or update or delete on finanz_monat
for each row execute function nur_stempel();
create table bwa_zuordnung (
id uuid primary key default gen_random_uuid(),
zeile integer not null unique,
bezeichnung text not null default '',
planzeile text not null check (planzeile in ('umsatz', 'material', 'personal', 'unternehmerlohn', 'werbung', 'laufend', 'afa',
'tilgung', 'investition', 'steuer', 'ignorieren')),
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
create trigger bwa_zuordnung_protokoll before insert or update or delete on bwa_zuordnung
for each row execute function stempel_und_protokoll();
-- wiederkehrende Aufgaben, die das Programm selbst anlegt (Finanzsitzung am ersten Freitag im Monat)
alter table aufgabe add column serie text unique;

View File

@@ -473,4 +473,8 @@ export const NUR_SICHERUNG: { name: string; pfad: string; sortierung: string }[]
{ name: "zeiteintrag", pfad: "zeiteintraege", sortierung: "datum, kontakt_id" },
{ name: "zeitanteil", pfad: "zeitanteile", sortierung: "zeiteintrag_id, reihenfolge" },
{ name: "projekt_vorlage", pfad: "projekt_vorlagen", sortierung: "projekt_id, vorlage" },
// Stufe 5: Jahresplan-Versionen, BWA je Monat und die Zuordnung der BWA-Zeilen
{ name: "jahresplan", pfad: "jahresplaene", sortierung: "jahr, basis desc, angelegt_am" },
{ name: "finanz_monat", pfad: "finanz_monate", sortierung: "jahr, monat" },
{ name: "bwa_zuordnung", pfad: "bwa_zuordnungen", sortierung: "zeile" },
];

View File

@@ -16,6 +16,7 @@ import { angebotSeite, angeboteHtml, angeboteSeite, mengenblattSeite, neuesAngeb
import { vorlageSeite } from "./mengenblatt.js";
import { leistungSeite, stammdatenSeite } from "./stammdaten.js";
import { lageKopfHtml, liquiditaetSeite } from "./liquiditaet.js";
import { jahresplanSeite } from "./jahresplan.js";
// ---------- Reiter ----------
@@ -710,7 +711,8 @@ async function uebersicht(): Promise<void> {
<section class="karte breit"><div class="karte-kopf"><h2>Wer macht was</h2><a class="neben" href="#terminplan">Terminplan</a></div>${einsatzHtml(u.einsatz)}</section>
<section class="karte breit"><div class="karte-kopf"><h2>Liquidität 4 Wochen</h2><a class="neben" href="#liquiditaet">Details</a></div>
${u.liquiLage ? lageKopfHtml(u.liquiLage, "4 Wochen") : ""}
<div class="liqui">${u.liquiditaet.map((p: Zeile) => `<div><small>ab ${dat(p.von).slice(0, 6)}</small><b class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</b><small>Saldo ${euro(p.saldo)}</small></div>`).join("")}</div></section>`;
<div class="liqui">${u.liquiditaet.map((p: Zeile) => `<div><small>ab ${dat(p.von).slice(0, 6)}</small><b class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</b><small>Saldo ${euro(p.saldo)}</small></div>`).join("")}</div>
${u.jahresplan ? jahresplanZeile(u.jahresplan) : ""}</section>`;
inhalt.appendChild(raster);
raster.addEventListener("change", async (ev) => {
@@ -724,6 +726,15 @@ async function uebersicht(): Promise<void> {
};
}
/** Stufe 5: wie viel Umsatz im Planjahr noch verkauft werden muss */
function jahresplanZeile(j: Zeile): string {
const ganz = (c: number) => euro(Math.round(c / 100) * 100).replace(",00 €", " €");
const anteil = j.umsatz ? Math.min(100, Math.round((j.beauftragt / j.umsatz) * 100)) : 0;
return `<div class="start-jahresplan"><a href="#jahresplanung"><b>Jahresplan ${j.jahr}:</b> noch <b>${ganz(j.offen)}</b> Umsatz zu verkaufen</a>
<span class="hinweis">Ziel ${ganz(j.umsatz)}, beauftragt ${ganz(j.beauftragt)} (${anteil} %)</span>
<span class="jp-balken" role="img" aria-label="${anteil} % beauftragt"><i style="width:${anteil}%"></i></span></div>`;
}
function einsatzHtml(e: Zeile): string {
if (!e.zeilen.length && e.ohne.tage.every((t: Zeile[]) => !t.length)) return '<p class="hinweis">In den nächsten zwei Wochen ist nichts eingeplant.</p>';
const zeilen = [...e.zeilen, ...(e.ohne.tage.some((t: Zeile[]) => t.length) ? [e.ohne] : [])];
@@ -965,7 +976,8 @@ function reiterFuer(s: Sitzung): Reiter[] {
["terminplan", "Terminplan", terminplan], ["personal", "Personal", () => personalSeite()], ["stunden", "Stunden", stundenSeite], ["kontakte", "Kontakte", kontakte],
["stammdaten", "Stammdaten", () => stammdatenSeite()], ["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten],
];
if (rolle === "inhaber") alle.push(["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]);
// Jahresplan und BWA (Stufe 5) nur für den Inhaber
if (rolle === "inhaber") alle.push(["jahresplanung", "Jahresplanung", () => jahresplanSeite()], ["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]);
return alle;
}
@@ -979,6 +991,7 @@ const SYMBOLE: Record<string, string> = {
stammdaten: '<rect x="4" y="3" width="16" height="18" rx="1"/><path d="M8 7h8M8 11h8M8 15h5"/>',
liquiditaet: '<path d="M3 17l6-6 4 4 8-8"/><path d="M15 7h6v6"/>',
"laufende-kosten": '<rect x="3" y="6" width="18" height="13" rx="1"/><path d="M3 10h18M7 15h4"/>',
jahresplanung: '<path d="M4 20V10M10 20V4M16 20v-7M22 20H2"/>',
benutzer: '<circle cx="9" cy="8" r="3.5"/><path d="M2.5 20c.8-3.6 3.3-5.5 6.5-5.5s5.7 1.9 6.5 5.5"/><circle cx="17" cy="9" r="2.5"/><path d="M16 14.6c2.8.1 4.8 1.9 5.5 5.4"/>',
stunden: '<circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/>',
urlaub: '<circle cx="12" cy="12" r="4"/><path d="M12 2v2M12 20v2M4.9 4.9l1.4 1.4M17.7 17.7l1.4 1.4M2 12h2M20 12h2M4.9 19.1l1.4-1.4M17.7 6.3l1.4-1.4"/>',

616
src/web/jahresplan.ts Normal file
View File

@@ -0,0 +1,616 @@
// Jahresplanung (Stufe 5, Henning 21.10.2026, Entwurf finanzen/entwurf-jahresplan): drei Reiter.
// „Plan aufbauen“: Bausteine in vier Schritten links, rechts die Treppe bis zum Gewinn mit Ampeln und Vorschlägen.
// „12 Monate“: knappster Monat, Saison zum Ziehen, Monatsplan bis zum Kontostand. „Plan / Ist“: BWA einlesen,
// Kennzahlen, Abweichungen ab 5 %, Zuordnung der BWA-Zeilen und die Checkliste der Finanzsitzung.
// Versionen: die Basis bleibt, jede Änderung zum Ausprobieren ist eine neue Version; eine Version „gilt“.
import { type Zeile, MONATSNAMEN, api, bestaetigen, dat, esc, inhalt, lies, merke, seite } from "./ui.js";
import { liste } from "./liste.js";
import { type PlanDaten, type PlanInvestition, type PlanMitarbeiter, type Rechnung, PLANZEILE_TEXT, PLANZEILEN, SAISON_GLEICH, SAISON_HANDWERK,
ZIEL_GEWINN, ZIEL_PERSONAL, knappText, monateAktiv, personalMonat, rechne, stundenImJahr, vorschlaege } from "../domain/jahresplan.js";
import { dateiText } from "../domain/kodierung.js";
import { formatEuro, parseEuro } from "../domain/geld.js";
type Reiter = "aufbauen" | "monate" | "planist";
interface Version { id: string; jahr: number; name: string; basis: boolean; gilt: boolean; daten: PlanDaten }
const KURZ = ["Jan", "Feb", "Mär", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"];
let reiter: Reiter = (["aufbauen", "monate", "planist"] as const).find((r) => r === lies("jp-reiter")) ?? "aufbauen";
let jahr: number | null = null;
let offen: string | null = null;
let piMonat: number | null = null;
let piKum = false;
let zuordnungOffen = false;
/** ganze Euro wie im Entwurf: 54.000 € */
const eur = (c: number) => formatEuro(Math.sign(c) * Math.round(Math.abs(c) / 100) * 100).replace(",00 €", " €");
const zahl = (c: number) => eur(c).replace(" €", "");
const pct = (p: number) => `${p.toLocaleString("de-DE", { maximumFractionDigits: 1 })} %`;
const k = (c: number) => (Math.abs(c) >= 100_000 ? `${Math.round(c / 100_000)}k` : zahl(c));
/** Eingabefeld: Euro ohne Zeichen, Zahlen deutsch */
const euroWert = (c: number) => (c ? zahl(c) : "");
const zahlWert = (n: number) => (n ? n.toLocaleString("de-DE", { maximumFractionDigits: 2 }) : "");
const leseZahl = (t: string) => {
const s = t.trim().replace(/\./g, "").replace(",", ".").replace(/[^\d.-]/g, "");
if (!s) return 0;
const n = Number(s);
if (!Number.isFinite(n)) throw new Error("Bitte eine Zahl eingeben.");
return n;
};
const monatAuswahl = (feld: string, wert: number) => `<select data-f="${feld}" data-t="monat">${KURZ.map((m, i) => `<option value="${i + 1}"${wert === i + 1 ? " selected" : ""}>${MONATSNAMEN[i]}</option>`).join("")}</select>`;
let d: Zeile;
let versionen: Version[] = [];
let plan: Version | null = null;
let speichernNach: ReturnType<typeof setTimeout> | undefined;
const aktivSchluessel = () => `jp-version-${jahr}`;
export async function jahresplanSeite(): Promise<void> {
d = await api<Zeile>(`jahresplan${jahr ? `?jahr=${jahr}` : ""}`);
jahr = d.jahr;
versionen = d.versionen;
plan = versionen.find((v) => v.id === lies(aktivSchluessel())) ?? versionen.find((v) => v.gilt) ?? versionen[0] ?? null;
const leiste = seite(`Jahresplan ${jahr}`);
const kopf = inhalt.querySelector(".kopf")!;
kopf.insertAdjacentHTML("beforeend", `<div class="jp-jahre" role="group" aria-label="Jahr"><button class="neben" data-jahr="${jahr! - 1}" aria-label="Jahr ${jahr! - 1}">‹ ${jahr! - 1}</button><button class="neben" data-jahr="${jahr! + 1}" aria-label="Jahr ${jahr! + 1}">${jahr! + 1} ›</button></div>`);
kopf.querySelectorAll<HTMLElement>("[data-jahr]").forEach((b) => (b.onclick = () => { jahr = Number(b.dataset.jahr); offen = null; piMonat = null; void jahresplanSeite(); }));
leiste.classList.add("jp-leiste");
leiste.innerHTML = `${plan ? versionenHtml() : '<span class="hinweis">Noch kein Plan für dieses Jahr</span>'}
<div class="liqui-reiter" role="tablist">${([["aufbauen", "Plan aufbauen"], ["monate", "12 Monate"], ["planist", "Plan / Ist"]] as [Reiter, string][]).map(([r, t]) =>
`<button role="tab" class="${r === reiter ? "haupt" : "neben"}" data-reiter="${r}" aria-selected="${r === reiter}">${t}</button>`).join("")}</div>
<div class="jp-werkzeug" hidden></div>`;
leiste.onclick = (ev) => void leisteKlick(ev, leiste);
if (reiter === "planist") return planIstZeigen();
if (!plan) return leerZeigen();
if (reiter === "aufbauen") aufbauenZeigen();
else monateZeigen();
}
function versionenHtml(): string {
return `<div class="jp-versionen" role="group" aria-label="Version"><span class="hinweis">Version:</span>${versionen.map((v) =>
`<button class="chip-knopf${v.id === plan?.id ? " an" : ""}" data-version="${v.id}" aria-pressed="${v.id === plan?.id}" title="${v.gilt ? "Diese Version gilt für Liquidität, Übersicht und Plan / Ist" : ""}">${esc(v.name)}${v.gilt ? ' <span class="jp-gilt">gilt</span>' : ""}</button>`).join("")}
<button class="chip-knopf" data-a="neue-version" title="Kopie der gewählten Version zum Ausprobieren">+ neue Version</button>
<button class="verweis" data-a="werkzeug" aria-label="Version umbenennen, gelten lassen oder löschen">⋯</button></div>`;
}
async function leisteKlick(ev: Event, leiste: HTMLElement): Promise<void> {
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-version], [data-reiter], [data-a]");
if (!b) return;
if (b.dataset.version) { merke(aktivSchluessel(), b.dataset.version); offen = null; return jahresplanSeite(); }
if (b.dataset.reiter) { reiter = b.dataset.reiter as Reiter; merke("jp-reiter", reiter); return jahresplanSeite(); }
const w = leiste.querySelector<HTMLElement>(".jp-werkzeug")!;
if (b.dataset.a === "neue-version" && plan) return neueVersion(plan.daten, `Version ${versionen.length + 1}`);
if (b.dataset.a === "werkzeug" && plan) {
w.hidden = !w.hidden;
w.innerHTML = `<form class="jp-umbenennen"><label>Name <input name="name" value="${esc(plan.name)}" maxlength="80"></label><button class="neben">Umbenennen</button></form>
${plan.gilt ? '<span class="hinweis">Diese Version gilt für Liquidität, Übersicht und Plan / Ist.</span>' : '<button class="neben" data-a="gilt">Diese Version gilt</button>'}
${plan.basis ? '<span class="hinweis">Die Basis bleibt immer erhalten.</span>' : '<button class="neben gefahr" data-a="loeschen">Version löschen</button>'}`;
w.querySelector("form")!.onsubmit = async (e) => {
e.preventDefault();
const name = (w.querySelector("[name=name]") as HTMLInputElement).value.trim();
if (name) { await api(`jahresplan/${plan!.id}`, "PATCH", { name }); void jahresplanSeite(); }
};
return;
}
if (b.dataset.a === "gilt" && plan) { await api(`jahresplan/${plan.id}`, "PATCH", { gilt: true }); return jahresplanSeite(); }
if (b.dataset.a === "loeschen" && plan && (await bestaetigen(`Version „${plan.name}“ löschen?`))) {
await api(`jahresplan/${plan.id}`, "DELETE");
merke(aktivSchluessel(), null);
return jahresplanSeite();
}
}
async function neueVersion(daten: PlanDaten, name: string): Promise<void> {
await speichernJetzt();
const v = await api<Version>("jahresplan", "POST", { jahr, name, daten });
merke(aktivSchluessel(), v.id);
offen = null;
void jahresplanSeite();
}
function leerZeigen(): void {
const v = d.vorlagen as Zeile;
const karte = document.createElement("section");
karte.className = "karte jp-leer";
karte.innerHTML = `<h2>Für ${jahr} gibt es noch keinen Plan</h2>
<p>Das Programm füllt den ersten Plan, die <b>Basis</b>, mit dem, was es schon weiß. Danach passt du Leute, Stundensatz und Kosten an.</p>
<ul class="jp-liste">
<li>Laufende Kosten ohne Personal: <b>${eur(v.laufend.ohnePersonal)}</b> im Monat, Personal daraus als Unternehmerlohn: <b>${eur(v.laufend.personal)}</b></li>
<li>Kontostand ${eur(v.kontostand)} und Mindestgrenze ${eur(v.mindestgrenze)} aus der Liquidität</li>
<li>${v.vorjahr ? `BWA ${jahr! - 1} (${v.vorjahr.monate} Monate, aufs Jahr hochgerechnet): Material und Sub ${eur(v.vorjahr.material)}, Abschreibungen ${eur(v.vorjahr.afa)}` : `Noch keine BWA aus ${jahr! - 1} eingelesen (Reiter Plan / Ist). Dann schlägt das Programm Material, Abschreibungen und Saison aus dem Vorjahr vor.`}</li>
</ul>
<button class="haupt" data-a="anlegen">Plan ${jahr} anlegen</button>`;
karte.querySelector<HTMLElement>("[data-a=anlegen]")!.onclick = async () => {
const neu = await api<Version>("jahresplan", "POST", { jahr });
merke(aktivSchluessel(), neu.id);
void jahresplanSeite();
};
inhalt.append(karte);
}
// ---------- speichern ----------
function speichernSpaeter(): void {
clearTimeout(speichernNach);
speichernNach = setTimeout(() => void speichernJetzt(), 700);
}
async function speichernJetzt(): Promise<void> {
if (!speichernNach || !plan) return;
clearTimeout(speichernNach);
speichernNach = undefined;
const p = plan;
try {
await api(`jahresplan/${p.id}`, "PATCH", { daten: p.daten });
document.querySelector(".jp-gespeichert")?.replaceChildren("Gespeichert");
} catch (e) {
document.querySelector(".jp-gespeichert")?.replaceChildren(`Nicht gespeichert: ${(e as Error).message}`);
}
}
window.addEventListener("hashchange", () => void speichernJetzt());
/** Wert aus einem Eingabefeld in den Plan schreiben; data-f = "a.stundensatz", "m.<id>.brutto", "i.<id>.betrag", "s.<monat>" */
function setze(feld: string, typ: string, roh: string | boolean): void {
const p = plan!.daten;
const teile = feld.split(".");
const wert = typ === "bool" ? roh : typ === "euro" ? (String(roh).trim() ? parseEuro(String(roh)) : 0) : typ === "text" || typ === "art" ? String(roh) : leseZahl(String(roh));
if (teile[0] === "a") (p.annahmen as unknown as Record<string, unknown>)[teile[1]!] = wert;
if (teile[0] === "m") { const m = p.mitarbeiter.find((x) => x.id === teile[1]); if (m) (m as unknown as Record<string, unknown>)[teile[2]!] = wert; }
if (teile[0] === "i") { const v = p.investitionen.find((x) => x.id === teile[1]); if (v) (v as unknown as Record<string, unknown>)[teile[2]!] = wert; }
if (teile[0] === "s") p.saison[Number(teile[1])] = Math.max(0, Math.min(100, wert as number));
// Austritt nicht vor dem Eintritt
for (const m of p.mitarbeiter) if (m.austritt < m.eintritt) m.austritt = m.eintritt;
}
function eingabenVerbinden(wurzel: HTMLElement, neuZeichnen: () => void, teilweise: () => void): void {
wurzel.addEventListener("input", (ev) => {
const el = ev.target as HTMLInputElement;
if (!el.dataset.f) return;
try {
setze(el.dataset.f, el.dataset.t ?? "zahl", el.type === "checkbox" ? el.checked : el.value);
el.classList.remove("ungueltig");
el.removeAttribute("aria-invalid");
} catch { el.classList.add("ungueltig"); el.setAttribute("aria-invalid", "true"); return; }
speichernSpaeter();
document.querySelector(".jp-gespeichert")?.replaceChildren("Speichert …");
teilweise();
});
wurzel.addEventListener("change", (ev) => {
const el = ev.target as HTMLInputElement;
if (!el.dataset.f || el.classList.contains("ungueltig")) return;
if (el.tagName === "SELECT" || el.type === "checkbox") neuZeichnen();
});
}
// ---------- Plan aufbauen ----------
const SCHRITTE = ["Leute und Stunden", "Stundensatz, Material, Sub", "Kosten und Investitionen", "Auf 12 Monate verteilen"];
function aufbauenZeigen(): void {
const raster = document.createElement("div");
raster.className = "jp-raster";
raster.innerHTML = `<div class="jp-links"></div><div class="jp-rechts"></div>`;
inhalt.append(raster);
const links = raster.querySelector<HTMLElement>(".jp-links")!, rechts = raster.querySelector<HTMLElement>(".jp-rechts")!;
const zeichneRechts = () => { rechts.innerHTML = treppeHtml(plan!.daten) + vergleichHtml(); };
const zeichneLinks = () => { links.innerHTML = bausteineHtml(plan!.daten); };
const alles = () => { zeichneLinks(); zeichneRechts(); };
alles();
eingabenVerbinden(links, alles, () => {
zeichneRechts();
// Zeile über dem offenen Baustein mitziehen
const p = plan!.daten;
links.querySelectorAll<HTMLElement>("[data-zus]").forEach((el) => {
const [art, id] = el.dataset.zus!.split(":");
const m = art === "m" ? p.mitarbeiter.find((x) => x.id === id) : undefined, v = art === "i" ? p.investitionen.find((x) => x.id === id) : undefined;
if (m) el.innerHTML = mitarbeiterZeile(m);
if (v) el.innerHTML = investitionZeile(v);
});
});
raster.addEventListener("click", async (ev) => {
const t = ev.target as HTMLElement;
const b = t.closest<HTMLElement>("[data-a], [data-offen], [data-schritt]");
if (!b) return;
const p = plan!.daten;
if (b.dataset.schritt) {
const s = Number(b.dataset.schritt);
if (s === 4) { reiter = "monate"; merke("jp-reiter", reiter); return void jahresplanSeite(); }
return links.querySelector(`#jp-schritt-${s}`)?.scrollIntoView({ behavior: "smooth", block: "start" });
}
if (b.dataset.offen !== undefined) { offen = offen === b.dataset.offen ? null : b.dataset.offen; zeichneLinks(); links.querySelector<HTMLInputElement>(`[data-zus="${offen?.replace("-", ":")}"] ~ .jp-editor input`)?.focus(); return; }
const a = b.dataset.a;
if (a === "plus-m") {
const id = `m${Date.now().toString(36)}`;
p.mitarbeiter.push({ id, name: `Geselle ${p.mitarbeiter.filter((m) => m.art === "angestellt").length + 1}`, art: "angestellt", stunden: 1400, brutto: 340_000, faktor: 1.25, eintritt: 1, austritt: 12, neu: true });
offen = `m-${id}`;
}
if (a === "plus-i") {
const id = `i${Date.now().toString(36)}`;
p.investitionen.push({ id, name: "Fahrzeug", betrag: 4_500_000, monat: 3, art: "kredit", anzahlung: 900_000, laufzeit: 60, zins: 5, rate: 0, nutzungsdauer: 6 });
offen = `i-${id}`;
}
if (a === "weg-m") { p.mitarbeiter = p.mitarbeiter.filter((m) => `m-${m.id}` !== offen); offen = null; }
if (a === "weg-i") { p.investitionen = p.investitionen.filter((v) => `i-${v.id}` !== offen); offen = null; }
if (a === "fertig") offen = null;
if (a === "lk-uebernehmen") p.annahmen.laufendMonat = d.vorlagen.laufend.ohnePersonal;
if (a === "vj-material") p.annahmen.materialEinkauf = d.vorlagen.vorjahr.material;
if (a === "vorschlag") {
const v = vorschlaege(p).find((x) => x.id === b.dataset.id);
if (v) return neueVersion(v.daten, v.name);
}
if (a && ["plus-m", "plus-i", "weg-m", "weg-i", "fertig", "lk-uebernehmen", "vj-material"].includes(a)) {
if (a !== "fertig") speichernSpaeter();
alles();
links.querySelector<HTMLInputElement>(".jp-editor input")?.focus();
}
});
}
function mitarbeiterZeile(m: PlanMitarbeiter): string {
const std = stundenImJahr(m), mon = monateAktiv(m);
const zeit = m.eintritt > 1 || m.austritt < 12 ? `${m.eintritt > 1 ? `ab 01.${String(m.eintritt).padStart(2, "0")}.` : ""}${m.austritt < 12 ? ` bis ${MONATSNAMEN[m.austritt - 1]}` : ""} · ` : "";
const unter = m.art === "inhaber"
? `${zeit}${zahl(std * 100)} verkaufbare Std · Unternehmerlohn ${eur(m.brutto)}/Mon`
: `${zeit}${zahl(std * 100)} Std · ${eur(m.brutto)} brutto × ${zahlWert(m.faktor)}${m.neu ? " · neu" : ""}`;
return `<span class="jp-sym" aria-hidden="true">👷</span><span class="jp-was"><b>${esc(m.name)}${m.art === "inhaber" ? " (Chef)" : ""}</b><small>${unter}</small></span><span class="jp-betrag">${eur(personalMonat(m) * mon)}</span>`;
}
function investitionZeile(v: PlanInvestition): string {
const r = rechne({ ...plan!.daten, investitionen: [v], mitarbeiter: [] }).investitionen[0]!;
const fin = v.art === "kauf" ? "Kauf" : v.art === "kredit" ? `${eur(v.anzahlung)} Anzahlung, Rest Kredit ${zahlWert(v.laufzeit / 12)} J. (${eur(r.rate)}/Mon)` : `Leasing ${eur(v.rate)}/Mon${v.anzahlung ? `, Sonderzahlung ${eur(v.anzahlung)}` : ""}`;
return `<span class="jp-sym" aria-hidden="true">🚐</span><span class="jp-was"><b>${esc(v.name)} ${MONATSNAMEN[v.monat - 1]}</b><small>${eur(v.betrag)} · ${fin}</small></span><span class="jp-betrag">${v.art === "leasing" ? "keine AfA" : `AfA ${eur(r.afaJahr)}`}</span>`;
}
const f = (label: string, feld: string, typ: string, wert: string, zusatz = "", hilfe = "") =>
`<label class="jp-f"><span>${label}</span><span class="jp-ein">${typ === "monat" ? monatAuswahl(feld, Number(wert)) : `<input data-f="${feld}" data-t="${typ}" value="${esc(wert)}" inputmode="${typ === "text" ? "text" : "decimal"}"${typ === "text" ? ' maxlength="100"' : ""}>`}${zusatz ? `<i>${zusatz}</i>` : ""}</span>${hilfe ? `<small class="hinweis">${hilfe}</small>` : ""}</label>`;
function mitarbeiterEditor(m: PlanMitarbeiter): string {
const p = `m.${m.id}`;
return `<div class="jp-editor">${f("Name", `${p}.name`, "text", m.name)}
<label class="jp-f"><span>Art</span><span class="jp-ein"><select data-f="${p}.art" data-t="art"><option value="inhaber"${m.art === "inhaber" ? " selected" : ""}>Inhaber (Unternehmerlohn)</option><option value="angestellt"${m.art === "angestellt" ? " selected" : ""}>angestellt</option></select></span></label>
${f("Verkaufbare Stunden", `${p}.stunden`, "zahl", zahlWert(m.stunden), "Std/Jahr", "bei vollem Jahr; ohne Urlaub, Krankheit, Büro und Fahrten")}
${f(m.art === "inhaber" ? "Unternehmerlohn" : "Bruttolohn", `${p}.brutto`, "euro", euroWert(m.brutto), "€/Mon")}
${m.art === "angestellt" ? f("Faktor Lohnnebenkosten", `${p}.faktor`, "zahl", zahlWert(m.faktor), "×", "Arbeitgeberanteile, BG, SOKA; Vorschlag 1,25") : ""}
${f("Ab", `${p}.eintritt`, "monat", String(m.eintritt))}${f("Bis", `${p}.austritt`, "monat", String(m.austritt))}
${m.art === "angestellt" ? `<label class="schalter jp-breit"><input type="checkbox" data-f="${p}.neu" data-t="bool"${m.neu ? " checked" : ""}> kommt neu dazu <span class="hinweis">(steht noch nicht in den laufenden Kosten, die Liquidität rechnet den Lohn aus dem Plan)</span></label>` : ""}
<div class="knoepfe jp-breit"><button class="neben gefahr" data-a="weg-m">Entfernen</button><button class="haupt" data-a="fertig">Fertig</button></div></div>`;
}
function investitionEditor(v: PlanInvestition): string {
const p = `i.${v.id}`;
return `<div class="jp-editor">${f("Was", `${p}.name`, "text", v.name)}${f("Betrag netto", `${p}.betrag`, "euro", euroWert(v.betrag), "€")}
${f("Monat", `${p}.monat`, "monat", String(v.monat))}
<label class="jp-f"><span>Bezahlung</span><span class="jp-ein"><select data-f="${p}.art" data-t="art">${([["kauf", "Kauf aus eigenem Geld"], ["kredit", "Anzahlung + Kredit"], ["leasing", "Leasing"]] as const).map(([w, t]) => `<option value="${w}"${v.art === w ? " selected" : ""}>${t}</option>`).join("")}</select></span></label>
${v.art !== "kauf" ? f(v.art === "kredit" ? "Anzahlung" : "Sonderzahlung", `${p}.anzahlung`, "euro", euroWert(v.anzahlung), "€") + f("Laufzeit", `${p}.laufzeit`, "zahl", zahlWert(v.laufzeit), "Monate") : ""}
${v.art === "kredit" ? f("Zins", `${p}.zins`, "zahl", zahlWert(v.zins), "% im Jahr") : ""}
${v.art === "leasing" ? f("Leasingrate", `${p}.rate`, "euro", euroWert(v.rate), "€/Mon") : f("Nutzungsdauer", `${p}.nutzungsdauer`, "zahl", zahlWert(v.nutzungsdauer), "Jahre", "AfA-Tabelle: Transporter 6, Maschinen 8–10, Werkzeug 5")}
<div class="knoepfe jp-breit"><button class="neben gefahr" data-a="weg-i">Entfernen</button><button class="haupt" data-a="fertig">Fertig</button></div></div>`;
}
function bausteineHtml(p: PlanDaten): string {
const a = p.annahmen, v = d.vorlagen as Zeile;
const baustein = (art: "m" | "i", id: string, zeile: string, editor: string) => {
const key = `${art}-${id}`, auf = offen === key;
return `<div class="jp-baustein${auf ? " auf" : ""}"><button class="jp-zeile" data-offen="${key}" data-zus="${art}:${id}" aria-expanded="${auf}">${zeile}</button>${auf ? editor : ""}</div>`;
};
const schritt = (n: number, inhaltHtml: string) => `<section class="karte jp-schritt" id="jp-schritt-${n}"><h2><span class="jp-nr">${n}</span>${SCHRITTE[n - 1]}</h2>${inhaltHtml}</section>`;
return `<nav class="jp-schritte" aria-label="Schritte">${SCHRITTE.map((s, i) => `<button class="neben" data-schritt="${i + 1}"><span class="jp-nr">${i + 1}</span>${s}</button>`).join("")}</nav>
${schritt(1, `<div class="jp-bausteine">${p.mitarbeiter.map((m) => baustein("m", m.id, mitarbeiterZeile(m), mitarbeiterEditor(m))).join("")}</div>
<button class="verweis" data-a="plus-m">+ Mitarbeiter</button>`)}
${schritt(2, `<div class="jp-felder">${f("Stundensatz", "a.stundensatz", "euro", euroWert(a.stundensatz), "€/Std", `Verkaufspreis je Stunde${v.stundensatzEk ? `; Kalkulation: Geselle ${eur(v.stundensatzEk)} Kosten` : ""}`)}
${f("Material Einkauf", "a.materialEinkauf", "euro", euroWert(a.materialEinkauf), "€/Jahr", v.vorjahr ? `BWA ${jahr! - 1} hochgerechnet: Material und Sub ${eur(v.vorjahr.material)} · <button class="verweis" data-a="vj-material">übernehmen</button>` : "")}
${f("Aufschlag Material", "a.materialAufschlag", "zahl", zahlWert(a.materialAufschlag), "%")}
${f("Subunternehmer Einkauf", "a.subEinkauf", "euro", euroWert(a.subEinkauf), "€/Jahr")}
${f("Aufschlag Sub", "a.subAufschlag", "zahl", zahlWert(a.subAufschlag), "%")}</div>`)}
${schritt(3, `<div class="jp-felder">${f("Laufende Kosten ohne Personal", "a.laufendMonat", "euro", euroWert(a.laufendMonat), "€/Mon",
`aus „Laufende Kosten“: ${eur(v.laufend.ohnePersonal)}${a.laufendMonat !== v.laufend.ohnePersonal ? ` · <button class="verweis" data-a="lk-uebernehmen">übernehmen</button>` : ""}`)}
${f("Preissteigerung", "a.preissteigerung", "zahl", zahlWert(a.preissteigerung), "%")}
${f("Werbung", "a.werbungMonat", "euro", euroWert(a.werbungMonat), "€/Mon")}
${f("Abschreibungen bisher", "a.afaBisher", "euro", euroWert(a.afaBisher), "€/Jahr", "auf das, was schon da ist (BWA Zeile Abschreibungen)")}
${f("Tilgung laufender Kredite", "a.tilgungBisher", "euro", euroWert(a.tilgungBisher), "€/Mon")}
${f("Steuer-Vorauszahlungen", "a.steuerQuartal", "euro", euroWert(a.steuerQuartal), "€/Quartal", "Einkommen- und Gewerbesteuer, März/Juni/Sept./Dez.")}
${f("Kontostand am 1. Januar", "a.kontostandStart", "euro", euroWert(a.kontostandStart), "€")}
${f("Mindestgrenze", "a.mindestgrenze", "euro", euroWert(a.mindestgrenze), "€")}</div>
<h3 class="jp-unter">Investitionen</h3><div class="jp-bausteine">${p.investitionen.map((i) => baustein("i", i.id, investitionZeile(i), investitionEditor(i))).join("") || '<p class="hinweis">Keine Investitionen geplant.</p>'}</div>
<button class="verweis" data-a="plus-i">+ Investition</button>`)}
${schritt(4, `<p>Den Umsatz nach Saison auf die Monate verteilen und sehen, wann es knapp wird.</p><button class="neben" data-schritt="4">Weiter zu „12 Monate“ ›</button>`)}
<p class="hinweis jp-gespeichert" role="status"></p>`;
}
function treppeHtml(p: PlanDaten): string {
const r = rechne(p), t = r.treppe, a = p.annahmen;
const ampel = (x: string, text: string) => `<span class="ampel-chip ${x === "gruen" ? "" : x}">${text}</span>`;
const std = p.mitarbeiter.filter((m) => stundenImJahr(m) > 0).map((m) => zahl(stundenImJahr(m) * 100)).join(" + ");
const zeile = (zeichen: string, text: string, unter: string, mitte: string, betrag: number, rechts = "", klasse = "") =>
`<tr class="${klasse}"><td class="jp-z">${zeichen}</td><td>${text}${unter ? `<small>${unter}</small>` : ""}</td><td class="jp-mitte">${mitte}</td><td class="zahl">${eur(betrag)}</td><td class="jp-q">${rechts}</td></tr>`;
const vs = t.luecke > 0 ? vorschlaege(p) : [];
return `<section class="karte jp-treppe"><h2>So rechnet sich dein Jahr</h2>
<table><tbody>
${zeile("", "Verkaufbare Stunden", std, `${zahl(t.stunden * 100)} Std × ${eur(a.stundensatz)}`, t.stundenUmsatz)}
${zeile("+", "Material mit Aufschlag", "", `Einkauf ${eur(a.materialEinkauf)}`, t.materialUmsatz)}
${zeile("+", "Subunternehmer mit Aufschlag", "", `Einkauf ${eur(a.subEinkauf)}`, t.subUmsatz)}
${zeile("=", "<b>Umsatz</b>", "", "", t.umsatz, "", "summe")}
${zeile("−", "Material und Subunternehmer (Einkauf)", "", "", -t.wareneinsatz)}
${zeile("=", "<b>Rohertrag</b>", "das, was dein Betrieb selbst erwirtschaftet", "", t.rohertrag, "100 %", "summe")}
${zeile("−", "Personal inkl. Unternehmerlohn + Werbung", "", "", -t.personalWerbung, `${pct(t.quotePersonal)} · Ziel ≤ ${ZIEL_PERSONAL} % ${ampel(t.ampelPersonal, t.ampelPersonal === "gruen" ? "passt" : "zu hoch")}`)}
${zeile("−", "Laufende Kosten", "inkl. Zinsen und Leasing", "", -t.laufend, pct(t.quoteLaufend))}
${zeile("−", "Abschreibungen", "", "", -t.afa, pct(t.quoteAfa))}
${zeile("=", "<b>Gewinn vor Steuern</b>", "", "", t.gewinn, `${pct(t.quoteGewinn)} · Ziel ${ZIEL_GEWINN} % ${ampel(t.ampelGewinn, t.ampelGewinn === "gruen" ? "erreicht" : "darunter")}`, `summe gewinn ${t.ampelGewinn}`)}
</tbody></table>
${t.luecke > 0 ? `<div class="jp-luecke"><p>Bis zum Ziel fehlen <b>${eur(t.luecke)}</b> Gewinn. Möglichkeiten zum Ausprobieren:</p>
<div class="jp-vorschlaege">${vs.map((v) => `<button class="chip-knopf" data-a="vorschlag" data-id="${v.id}">${esc(v.text)} <small>(+${eur(v.mehrGewinn)})</small></button>`).join("") || '<span class="hinweis">Mehr Stunden, höherer Satz oder weniger Kosten.</span>'}</div>
<p class="hinweis">Ein Klick legt eine neue Version an. Deine ${esc(plan!.name)} bleibt unverändert, Versionen lassen sich unten nebeneinander vergleichen.</p></div>`
: `<p class="jp-ok">Gewinnziel erreicht: ${pct(t.quoteGewinn)} vom Rohertrag.</p>`}
<p class="hinweis">Ziele nach Roos („Finanzen einfach machen“): Personal und Werbung höchstens ${ZIEL_PERSONAL} %, Gewinn ${ZIEL_GEWINN} % vom Rohertrag. Alle Werte netto.</p></section>`;
}
function vergleichHtml(): string {
if (versionen.length < 2) return "";
const rs = versionen.map((v) => ({ v, r: v.id === plan!.id ? rechne(plan!.daten) : rechne(v.daten) }));
const z = (titel: string, wert: (r: Rechnung) => string) => `<tr><th scope="row">${titel}</th>${rs.map(({ v, r }) => `<td class="zahl${v.id === plan!.id ? " an" : ""}">${wert(r)}</td>`).join("")}</tr>`;
return `<section class="karte jp-vergleich"><h2>Versionen nebeneinander</h2><div class="jp-scroll"><table><thead><tr><th></th>${rs.map(({ v }) => `<th class="zahl${v.id === plan!.id ? " an" : ""}">${esc(v.name)}${v.gilt ? ' <span class="jp-gilt">gilt</span>' : ""}</th>`).join("")}</tr></thead><tbody>
${z("Umsatz", (r) => eur(r.treppe.umsatz))}${z("Rohertrag", (r) => eur(r.treppe.rohertrag))}
${z("Personal + Werbung", (r) => `${pct(r.treppe.quotePersonal)}`)}${z("Gewinn", (r) => eur(r.treppe.gewinn))}
${z("Gewinn vom Rohertrag", (r) => `<span class="ampel-chip ${r.treppe.ampelGewinn === "gruen" ? "" : r.treppe.ampelGewinn}">${pct(r.treppe.quoteGewinn)}</span>`)}
${z("Knappster Monat", (r) => `${KURZ[r.tief.monat - 1]} ${eur(r.tief.kontostand)}`)}</tbody></table></div></section>`;
}
// ---------- 12 Monate ----------
function monateZeigen(): void {
const wurzel = document.createElement("div");
wurzel.className = "jp-monate";
inhalt.append(wurzel);
const zeichne = () => {
const p = plan!.daten, r = rechne(p);
const kt = knappText(p, r);
const grenze = p.annahmen.mindestgrenze;
const eng = r.tief.abstand < Math.max(grenze * 0.5, 100_000);
const kk = Math.ceil(Math.max(500_000, grenze * 2 - r.tief.kontostand + grenze) / 500_000) * 500_000;
const inv = p.investitionen.filter((v) => v.monat <= r.tief.monat && (v.art === "kauf" ? v.betrag : v.anzahlung) > 0).at(-1);
const sum = Math.round(p.saison.reduce((x, y) => x + y, 0) * 10) / 10;
const vj = (d.vorlagen.saisonVorjahr as Zeile[]);
wurzel.innerHTML = `<section class="karte jp-knapp ${eng ? "eng" : ""}"><span class="ampel-chip ${r.tief.abstand < 0 ? "rot" : eng ? "gelb" : ""}">${r.tief.abstand < 0 ? "Achtung" : eng ? "Knapp" : "Passt"} ${MONATSNAMEN[r.tief.monat - 1]}</span>
<div><p>${esc(kt.satz)} <span class="hinweis">${esc(kt.grund)}</span></p>
${eng ? `<div class="jp-vorschlaege"><button class="chip-knopf gestrichelt" data-a="kontokorrent" data-betrag="${kk}">Kontokorrent ${eur(kk)} bei der Bank vorsorglich anfragen</button>${inv ? `<button class="chip-knopf gestrichelt" data-a="verschieben" data-id="${inv.id}">${esc(inv.name)} auf ${MONATSNAMEN[Math.min(12, inv.monat + 3) - 1]}</button>` : ""}</div>` : ""}</div></section>
<section class="karte"><div class="karte-kopf"><h2>Umsatz übers Jahr verteilen <span class="hinweis">· Säule ziehen oder Wert eintippen</span></h2>
<div class="jp-vorlagen"><button class="neben" data-a="saison-vj" ${vj.length === 12 ? "" : `disabled title="Dafür braucht es die BWA aller 12 Monate aus ${jahr! - 1}${vj.length ? `, bisher ${vj.length}` : ""}"`}>aus ${jahr! - 1} übernehmen</button>
<button class="neben" data-a="saison-handwerk">Handwerk typisch</button><button class="neben" data-a="saison-gleich">gleichmäßig</button></div></div>
<div class="jp-saison" role="group" aria-label="Anteil am Jahresumsatz je Monat">${p.saison.map((s, i) => {
const h = Math.max(4, Math.min(100, (s / 15) * 100));
return `<div class="jp-monat${i === r.tief.monat - 1 ? " tief" : ""}"><b>${k(r.monate.umsatz[i]!)}</b><div class="jp-saeule-feld"><div class="jp-saeule" data-s="${i}" style="height:${h}%" tabindex="0" role="slider" aria-label="${MONATSNAMEN[i]}" aria-valuemin="0" aria-valuemax="30" aria-valuenow="${s}" aria-valuetext="${pct(s)}"></div></div>
<label><span>${KURZ[i]}</span><input data-f="s.${i}" data-t="zahl" value="${zahlWert(Math.round(s * 10) / 10)}" inputmode="decimal" aria-label="${MONATSNAMEN[i]} in Prozent"><i>%</i></label></div>`;
}).join("")}</div>
${Math.abs(sum - 100) > 0.05 ? `<p class="jp-summe">Summe ${pct(sum)} · das Programm rechnet anteilig · <button class="verweis" data-a="saison-100">auf 100 % ausgleichen</button></p>` : ""}</section>
<section class="karte"><div class="karte-kopf"><h2>Monatsplan <span class="hinweis">· jede Zeile filter- und sortierbar wie überall · Werte in €</span></h2></div><div class="jp-tabelle"></div>
<p class="hinweis">${d.vorlagen && plan!.gilt ? `Die Liquidität übernimmt diese Version ab ${MONATSNAMEN[0]} ${jahr} als Vorschau für alle Monate, in denen noch keine echten Zahlungen stehen: weitere Einnahmen und Material/Sub nur, soweit Zahlungspläne und Eingangsrechnungen sie nicht schon abdecken; dazu Löhne neuer Mitarbeiter, Investitionen und Steuer-Vorauszahlungen. Echte Zahlungen ersetzen den Plan Monat für Monat.` : `Diese Version gilt nicht; die Liquidität rechnet mit „${esc(versionen.find((v) => v.gilt)?.name ?? "")}“.`}</p>
<p class="hinweis jp-gespeichert" role="status"></p></section>`;
wurzel.querySelector(".jp-tabelle")!.append(monatsTabelle(p, r));
};
zeichne();
eingabenVerbinden(wurzel, zeichne, () => {
// Säulen und Tabelle nachziehen, das Eingabefeld behält den Fokus
const aktiv = document.activeElement as HTMLInputElement | null;
const feld = aktiv?.dataset.f;
const pos = aktiv?.selectionStart ?? null;
zeichne();
if (feld) { const neu = wurzel.querySelector<HTMLInputElement>(`[data-f="${feld}"]`); neu?.focus(); if (pos !== null) neu?.setSelectionRange(pos, pos); }
});
// Säule ziehen: 100 % Höhe = 15 % Anteil
wurzel.addEventListener("pointerdown", (ev) => {
const s = (ev.target as HTMLElement).closest<HTMLElement>(".jp-saeule-feld");
const saeule = s?.querySelector<HTMLElement>(".jp-saeule");
if (!s || !saeule) return;
ev.preventDefault();
const i = Number(saeule.dataset.s);
const feld = s.getBoundingClientRect();
const setzeAus = (y: number) => {
const anteil = Math.max(0, Math.min(15, ((feld.bottom - y) / feld.height) * 15));
plan!.daten.saison[i] = Math.round(anteil * 2) / 2;
speichernSpaeter();
zeichne();
};
setzeAus(ev.clientY);
const weiter = (e: PointerEvent) => setzeAus(e.clientY);
const ende = () => { window.removeEventListener("pointermove", weiter); window.removeEventListener("pointerup", ende); };
window.addEventListener("pointermove", weiter);
window.addEventListener("pointerup", ende);
});
wurzel.addEventListener("keydown", (ev) => {
const s = (ev.target as HTMLElement).closest<HTMLElement>(".jp-saeule");
if (!s || !["ArrowUp", "ArrowDown"].includes(ev.key)) return;
ev.preventDefault();
const i = Number(s.dataset.s);
plan!.daten.saison[i] = Math.max(0, plan!.daten.saison[i]! + (ev.key === "ArrowUp" ? 0.5 : -0.5));
speichernSpaeter();
zeichne();
wurzel.querySelector<HTMLElement>(`.jp-saeule[data-s="${i}"]`)?.focus();
});
wurzel.addEventListener("click", async (ev) => {
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-a]");
if (!b) return;
const p = plan!.daten;
const a = b.dataset.a;
if (a === "saison-handwerk") p.saison = [...SAISON_HANDWERK];
if (a === "saison-gleich") p.saison = SAISON_GLEICH.map((x) => Math.round(x * 10) / 10);
if (a === "saison-vj") {
const u = (d.vorlagen.saisonVorjahr as Zeile[]).map((x) => Math.max(0, x.umsatz as number));
const s = u.reduce((x, y) => x + y, 0);
if (s) p.saison = u.map((x) => Math.round((x / s) * 1000) / 10);
}
if (a === "saison-100") {
const s = p.saison.reduce((x, y) => x + y, 0);
if (s) p.saison = p.saison.map((x) => Math.round((x / s) * 1000) / 10);
}
if (a?.startsWith("saison")) { speichernSpaeter(); return zeichne(); }
if (a === "kontokorrent") {
await api("aufgaben", "POST", { text: `Kontokorrent ${eur(Number(b.dataset.betrag))} bei der Bank vorsorglich anfragen (Jahresplan ${jahr})`, faellig_am: new Date().toISOString().slice(0, 10) });
b.outerHTML = '<span class="erfolg-text">Als Aufgabe angelegt</span>';
}
if (a === "verschieben") {
const x: PlanDaten = JSON.parse(JSON.stringify(p));
const v = x.investitionen.find((i) => i.id === b.dataset.id)!;
v.monat = Math.min(12, v.monat + 3);
return neueVersion(x, `${v.name} im ${MONATSNAMEN[v.monat - 1]}`);
}
});
}
function monatsTabelle(p: PlanDaten, r: Rechnung): HTMLElement {
const m = r.monate;
const beauftragt = d.beauftragt as number[];
const negativ = (x: number[]) => x.map((v) => -v);
const zeilen: Zeile[] = [
{ id: "umsatz", text: "Umsatz", werte: m.umsatz },
{ id: "beauftragt", text: "davon schon beauftragt", werte: beauftragt, klein: true },
{ id: "offen", text: "noch zu verkaufen", werte: m.umsatz.map((u, i) => Math.max(0, u - beauftragt[i]!)), klein: true },
{ id: "waren", text: "− Material + Sub", werte: negativ(m.waren) },
{ id: "rohertrag", text: "= Rohertrag", werte: m.rohertrag, summe: true },
{ id: "personal", text: "− Personal + Werbung", werte: m.personal.map((x, i) => -(x + m.unternehmerlohn[i]! + m.werbung[i]!)) },
{ id: "laufend", text: "− Laufende Kosten", werte: negativ(m.laufend) },
{ id: "investition", text: "− Investition + Tilgung", werte: negativ(m.investition) },
{ id: "steuer", text: "− Steuer-Vorauszahlung", werte: negativ(m.steuer) },
{ id: "ueberschuss", text: "= Überschuss", werte: m.ueberschuss, summe: true },
{ id: "kontostand", text: "Kontostand Monatsende", werte: m.kontostand, summe: true, stand: true },
{ id: "grenze", text: "Mindestgrenze", werte: Array(12).fill(p.annahmen.mindestgrenze), klein: true, stand: true },
];
const zelle = (z: Zeile, v: number, i: number) =>
`<span class="${v < 0 && !z.stand ? "aus" : ""}${z.id === "ueberschuss" && v > 0 ? " ein" : ""}${z.id === "kontostand" && i === r.tief.monat - 1 ? " jp-tief" : ""}${z.id === "kontostand" && v < p.annahmen.mindestgrenze ? " fehler" : ""}">${v ? zahl(v) : "–"}</span>`;
const el = liste({
schluessel: "jahresplan-monate", klein: true, klasse: "jp-monatsplan",
zeilenKlasse: (z) => `${z.summe ? "jp-summe-zeile" : ""}${z.klein ? " jp-klein" : ""}`,
spalten: [
{ id: "zeile", titel: "", wert: (z) => esc(z.text), text: (z) => z.text, klasse: "jp-erste" },
...KURZ.map((titel, i) => ({ id: `m${i + 1}`, titel, art: "zahl" as const, klasse: "zahl", wert: (z: Zeile) => zelle(z, z.werte[i], i), sortWert: (z: Zeile) => z.werte[i] as number })),
{ id: "jahr", titel: "Jahr", art: "zahl", klasse: "zahl", wert: (z) => (z.stand ? "" : `<b>${zahl((z.werte as number[]).reduce((x, y) => x + y, 0))}</b>`), sortWert: (z) => (z.stand ? null : (z.werte as number[]).reduce((x, y) => x + y, 0)) },
],
zeilen,
});
return el;
}
// ---------- Plan / Ist ----------
const PUNKTE: { id: string; text: string; auto?: boolean; spaeter?: boolean }[] = [
{ id: "vollstaendig", text: "Monat vollständig? Alle Eingangsrechnungen und Löhne bei Herrn Seeler" },
{ id: "bwa", text: "BWA eingelesen", auto: true },
{ id: "kennzahlen", text: "Kennzahlen angesehen" },
{ id: "abweichung", text: "Abweichungen ab 5 % geklärt (Notiz in der Zeile)" },
{ id: "liquiditaet", text: 'Liquidität der nächsten 6 Wochen ansehen · <a href="#liquiditaet">öffnen</a>' },
{ id: "toepfe", text: "Umbuchen in die Töpfe", spaeter: true },
{ id: "plan", text: "Plan anpassen? Bei großen Abweichungen eine neue Version für den Rest des Jahres" },
];
async function planIstZeigen(): Promise<void> {
const q = new URLSearchParams({ jahr: String(jahr), kumuliert: piKum ? "1" : "0", ...(piMonat ? { monat: String(piMonat) } : {}) });
const x = await api<Zeile>(`jahresplan/planist?${q}`);
piMonat = x.monat;
const mitBwa = new Set((x.monate as Zeile[]).filter((m) => m.bwa).map((m) => m.monat as number));
const wurzel = document.createElement("div");
wurzel.className = "jp-planist";
inhalt.append(wurzel);
const ohnePlan = !x.plan;
const monatName = MONATSNAMEN[x.monat - 1];
const bwa = x.bwa as Zeile | null;
const kopf = `<div class="jp-pi-kopf"><div class="jp-monatswahl" role="group" aria-label="Monat">${KURZ.map((m, i) =>
`<button class="chip-knopf${x.monat === i + 1 ? " an" : ""}${mitBwa.has(i + 1) ? " mit" : ""}" data-monat="${i + 1}" aria-pressed="${x.monat === i + 1}" title="${mitBwa.has(i + 1) ? "BWA eingelesen" : "noch keine BWA"}">${m}</button>`).join("")}</div>
<label class="schalter"><input type="checkbox" data-a="kum"${piKum ? " checked" : ""}> bis ${monatName} kumuliert</label>
<label class="haupt knopf-datei">BWA einlesen<input type="file" accept=".xls,.htm,.html" data-a="datei" hidden></label></div>
<p class="fehler" id="jp-bwa-fehler" role="alert"></p>`;
const kz = (x.kennzahlen as Zeile[]).map((k2) => {
const wert = k2.wert === null ? "–" : k2.einheit === "%" ? `${k2.wert} %` : eur(k2.wert);
const unter = k2.einheit === "%" ? `Ziel ${k2.id === "personal" ? "≤ " : ""}${k2.ziel} %${ohnePlan ? "" : ` · Plan ${k2.plan} %`}`
: ohnePlan ? "" : `Plan ${eur(k2.plan)}${k2.wert !== null && k2.plan ? ` · ${k2.wert >= k2.plan ? "+" : "−"}${Math.round(Math.abs(k2.wert - k2.plan) / Math.abs(k2.plan) * 100)} %` : ""}`;
const titel = k2.id === "rohertrag" ? `Rohertrag ${piKum ? `bis ${monatName}` : monatName}` : k2.id === "gewinn" ? `Gewinn vom Rohertrag ${piKum ? `(bis ${monatName})` : `(${monatName})`}` : k2.text;
return `<div class="karte jp-kz ${k2.gut === null ? "" : k2.gut ? "gut" : "schlecht"}"><span class="hinweis">${esc(titel)}</span><b>${wert}</b><small>${unter}</small></div>`;
}).join("");
const notizen = x.notizen as Record<string, string>;
wurzel.innerHTML = `${kopf}${ohnePlan ? `<p class="warnung">Für ${jahr} gibt es keinen Jahresplan; die Tabelle zeigt nur die Ist-Werte. Die BWA dient dem Plan ${jahr! + 1} als Vorjahr.</p>` : ""}
<div class="jp-kennzahlen">${kz}</div>
<section class="karte"><div class="karte-kopf"><h2>${bwa ? `BWA ${monatName} · eingelesen ${dat(String(bwa.eingelesen_am).slice(0, 10))} · ${esc(bwa.art ?? "")}` : `Noch keine BWA für ${monatName} ${jahr}`}</h2>
${bwa ? `<button class="neben" data-a="bwa-weg">BWA entfernen</button>` : ""}</div><div class="jp-pi-tabelle"></div>
<p class="hinweis">Die BWA-Zeilen sind einmal den Planzeilen zugeordnet, danach liest das Programm jede neue BWA-Datei selbst ein. Gelb ab 5 %, rot ab 15 % schlechter als geplant; grün = besser. ${x.plan ? `Plan: Version „${esc(x.plan.name)}“.` : ""}</p></section>
<section class="karte jp-zuordnung"><button class="verweis" data-a="zuordnung" aria-expanded="${zuordnungOffen}">${zuordnungOffen ? "▾" : "▸"} BWA-Zeilen den Planzeilen zuordnen <span class="hinweis">(${(x.zuordnung as Zeile[]).length} Zeilen)</span></button>
${zuordnungOffen ? zuordnungHtml(x.zuordnung, piKum) : ""}</section>
${sitzungHtml(x, bwa !== null)}`;
const tab = liste({
schluessel: "jahresplan-planist", klein: true, klasse: "jp-pi",
zeilenKlasse: (z) => `${z.summe ? "jp-summe-zeile" : ""} ${z.stufe ? `jp-${z.stufe}` : ""}`,
spalten: [
{ id: "zeile", titel: "BWA-Zeile", wert: (z) => esc(z.text), text: (z) => z.text },
...(ohnePlan ? [] : [{ id: "plan", titel: "Plan", art: "zahl" as const, klasse: "zahl", wert: (z: Zeile) => zahl(z.kosten ? -z.plan : z.plan), sortWert: (z: Zeile) => z.plan as number }]),
{ id: "ist", titel: "Ist", art: "zahl", klasse: "zahl", wert: (z) => (z.ist === null ? "–" : zahl(z.kosten ? -z.ist : z.ist)), sortWert: (z) => z.ist },
...(ohnePlan ? [] : [{ id: "abw", titel: "Abweichung", art: "zahl" as const, klasse: "zahl", wert: (z: Zeile) => (z.abweichung === null ? "" : `${z.abweichung > 0 ? "+" : ""}${zahl(z.abweichung)}${z.prozent !== null && z.prozent >= 5 ? ` <small>(${z.prozent.toLocaleString("de-DE")} %)</small>` : ""}`), sortWert: (z: Zeile) => z.abweichung }]),
{ id: "notiz", titel: "Notiz", fest: true, wert: (z) => (z.summe ? "" : `<input class="jp-notiz" data-notiz="${z.id}" value="${esc(notizen[z.id] ?? "")}" maxlength="500" placeholder="${z.stufe === "gelb" || z.stufe === "rot" ? "Warum?" : ""}" aria-label="Notiz zu ${esc(z.text)}">`) },
],
zeilen: x.zeilen,
});
wurzel.querySelector(".jp-pi-tabelle")!.append(tab);
wurzel.addEventListener("change", async (ev) => {
const t = ev.target as HTMLInputElement | HTMLSelectElement;
if (t.dataset.a === "kum") { piKum = (t as HTMLInputElement).checked; return void jahresplanSeite(); }
if (t.dataset.a === "datei") return einlesen(t as HTMLInputElement);
if (t.dataset.notiz) { await api(`finanzmonat/${jahr}/${x.monat}`, "PUT", { notizen: { ...notizen, [t.dataset.notiz]: t.value.trim() } }); notizen[t.dataset.notiz] = t.value.trim(); return; }
if (t.dataset.zeile) { await api(`bwa/zuordnung/${t.dataset.zeile}`, "PUT", { planzeile: t.value }); return void jahresplanSeite(); }
if (t.dataset.punkt) {
const erledigt = new Set(x.erledigt as string[]);
(t as HTMLInputElement).checked ? erledigt.add(t.dataset.punkt) : erledigt.delete(t.dataset.punkt);
x.erledigt = [...erledigt];
await api(`finanzmonat/${jahr}/${x.monat}`, "PUT", { erledigt: x.erledigt });
}
});
wurzel.addEventListener("click", async (ev) => {
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-monat], [data-a]");
if (!b) return;
if (b.dataset.monat) { piMonat = Number(b.dataset.monat); return void jahresplanSeite(); }
if (b.dataset.a === "zuordnung") { zuordnungOffen = !zuordnungOffen; return void jahresplanSeite(); }
if (b.dataset.a === "bwa-weg" && (await bestaetigen(`BWA ${monatName} ${jahr} entfernen? Notizen und Checkliste bleiben.`))) {
await api(`bwa/${jahr}/${x.monat}`, "DELETE");
return void jahresplanSeite();
}
});
}
async function einlesen(input: HTMLInputElement): Promise<void> {
const datei = input.files?.[0];
if (!datei) return;
const fehler = document.getElementById("jp-bwa-fehler")!;
fehler.textContent = "";
try {
const r = await api<Zeile>("bwa", "POST", { dateiname: datei.name, inhalt: dateiText(new Uint8Array(await datei.arrayBuffer())) });
jahr = r.jahr;
piMonat = r.monat;
zuordnungOffen = (r.neu as Zeile[]).length > 0;
await jahresplanSeite();
const fertig = document.createElement("div");
fertig.className = "erfolg";
fertig.setAttribute("role", "status");
fertig.textContent = `BWA ${MONATSNAMEN[r.monat - 1]} ${r.jahr} eingelesen (${r.zeilen} Zeilen).${(r.neu as Zeile[]).length ? ` ${(r.neu as Zeile[]).length} Zeilen sind neu und vorgeschlagen zugeordnet, bitte unten kurz prüfen.` : ""}`;
inhalt.querySelector(".kopf")!.after(fertig);
} catch (e) {
fehler.textContent = (e as Error).message;
} finally {
input.value = "";
}
}
function zuordnungHtml(zeilen: Zeile[], kum: boolean): string {
const optionen = [...PLANZEILEN, "ignorieren" as const];
return `<div class="jp-scroll"><table class="jp-zu"><thead><tr><th>Zeile</th><th>Bezeichnung</th><th class="zahl">${kum ? "kumuliert" : "Monat"}</th><th>gehört zu</th></tr></thead><tbody>
${zeilen.map((z) => { const w = kum ? z.kumuliert : z.monatswert; return `<tr class="${z.planzeile === "ignorieren" ? "leise" : ""}"><td>${z.zeile}</td><td>${esc(z.bezeichnung)}</td><td class="zahl">${w === null ? "" : zahl(w)}</td>
<td><select data-zeile="${z.zeile}" aria-label="Zeile ${z.zeile} gehört zu">${optionen.map((o) => `<option value="${o}"${o === z.planzeile ? " selected" : ""}>${PLANZEILE_TEXT[o]}</option>`).join("")}</select></td></tr>`; }).join("")}
</tbody></table></div>`;
}
function sitzungHtml(x: Zeile, mitBwa: boolean): string {
const erledigt = new Set(x.erledigt as string[]);
const schlimmste = (x.zeilen as Zeile[]).filter((z) => z.stufe === "rot" || z.stufe === "gelb").sort((a, b) => a.abweichung - b.abweichung)[0];
return `<section class="karte jp-sitzung"><h2>Finanzsitzung ${MONATSNAMEN[x.monat - 1]} <span class="hinweis">· 1. Freitag im Monat, nächste am ${dat(x.sitzung)}</span></h2>
<ul>${PUNKTE.map((p) => {
const an = p.auto ? mitBwa : erledigt.has(p.id);
const zusatz = p.id === "abweichung" && schlimmste ? ` <span class="hinweis">größte: ${esc(schlimmste.text)} ${zahl(schlimmste.abweichung)} €</span>` : "";
return `<li class="${p.spaeter ? "spaeter" : ""}"><label><input type="checkbox" data-punkt="${p.id}"${an ? " checked" : ""}${p.auto || p.spaeter ? " disabled" : ""}> <span>${p.text}${zusatz}${p.spaeter ? ' <span class="hinweis">(kommt mit den Töpfen)</span>' : ""}</span></label></li>`;
}).join("")}</ul>
<p class="hinweis">Steht als Aufgabe am ersten Freitag jedes Monats in „Aufgaben“, sobald es einen Jahresplan gibt.</p></section>`;
}

View File

@@ -163,6 +163,7 @@ async function lageZeigen(): Promise<void> {
<div class="kurve-huelle">${kurveSvg(d, bereich.clientWidth - 34, v?.wochen)}</div>
<div class="kurve-legende"><span><i class="k-stand"></i>Kontostand</span><span><i class="k-ein"></i>Einnahmen je Woche</span><span><i class="k-aus"></i>Ausgaben je Woche</span><span><i class="k-grenze"></i>Mindestgrenze</span>${v ? '<span><i class="k-was"></i>Was wäre, wenn</span>' : ""}</div>
<p class="hinweis">Woche anklicken: Zahlungen dieser Woche. Mindestgrenze: ${d.mindestgrenzeArt === "fest" ? `fester Betrag ${glatt(d.mindestgrenze)}` : `1 Monat laufende Kosten (${glatt(d.laufendMonat)})`}.</p>
${planHinweis(d)}
${wocheHtml(wochen.find((w) => w.von === gewaehlt), namen)}</section>
<div class="liqui-modus" role="group" aria-label="Modus der Listen"><span class="hinweis">Modus:</span>
<button class="chip-knopf${modus === "aus" ? " an" : ""}" data-modus="aus" aria-pressed="${modus === "aus"}">👁 Ausblenden</button>
@@ -177,6 +178,11 @@ async function lageZeigen(): Promise<void> {
if (w) { gewaehlt = gewaehlt === w.dataset.woche ? null : w.dataset.woche!; return zeichne(); }
const m = t.closest<HTMLElement>("[data-mehr]");
if (m) { const k = m.dataset.mehr as "ein" | "aus"; mehr[k] = !mehr[k]; return zeichne(); }
const pv = t.closest<HTMLElement>("[data-plan-vorschau]");
if (pv) {
void (async () => { const e = await api<Zeile>("einstellungen"); await api("einstellungen", "PUT", { ...e, jahresplanVorschau: pv.dataset.planVorschau === "an" }); void liquiditaetSeite(); })();
return;
}
const knopf = t.closest<HTMLElement>("[data-modus], [data-ausblenden], [data-zeige-aus], [data-alle-ein], [data-a=probe-weg], [data-verschieben]");
if (knopf?.dataset.modus) { modus = knopf.dataset.modus as "aus" | "was"; return zeichne(); }
if (knopf?.dataset.ausblenden) {
@@ -344,6 +350,15 @@ function listeHtml(art: "ein" | "aus", alle: ListenZeile[], namen: Map<string, s
: `<p class="hinweis">${art === "ein" ? "Im Zeitraum kommt nichts rein." : "Im Zeitraum geht nichts raus."}</p>`}</section>`;
}
/** Stufe 5: Posten aus dem Jahresplan zählen als Vorschau; hier ein- und ausschalten */
function planHinweis(d: Zeile): string {
const plan = (d.wochen as Zeile[]).flatMap((w) => w.posten as Zeile[]).filter((p) => p.gruppe === "Jahresplan");
if (d.jahresplanVorschau && !plan.length) return "";
return `<p class="hinweis liqui-plan-hinweis">${d.jahresplanVorschau
? `Ab ${MONATSNAMEN[Number(plan[0]!.datum.slice(5, 7)) - 1]} ${plan[0]!.datum.slice(0, 4)} rechnet die Liquidität mit dem <a href="#jahresplanung">Jahresplan</a>, soweit echte Zahlungen fehlen (Posten „Plan: …“). <button class="verweis" data-plan-vorschau="aus">Vorschau ausschalten</button>`
: `Die Vorschau aus dem Jahresplan ist ausgeschaltet. <button class="verweis" data-plan-vorschau="an">Einschalten</button>`}</p>`;
}
/** Zahnrad: Mindestgrenze automatisch (1 Monat laufende Kosten) oder fester Betrag */
function grenzeBearbeiten(ziel: HTMLElement, d: Zeile): void {
if (!ziel.hidden) { ziel.hidden = true; return; }

View File

@@ -1335,3 +1335,153 @@ dl.am-kennzahlen dd { margin: 0; text-align: right; font-variant-numeric: tabula
.tag-probe { display: inline-block; font-size: 11px; font-weight: 600; padding: 1px 5px; border-radius: 4px; background: var(--probe-bg); border: 1px solid var(--probe-linie); color: var(--probe-text); }
input.liqui-datum { width: 100%; font: inherit; font-size: 13px; padding: 2px 4px; border: 1px solid var(--akzent); border-radius: 6px; background: var(--fl); color: var(--text); }
.probe-summe { font-weight: 400; color: var(--probe-text); }
/* Jahresplanung (Stufe 5, Entwurf finanzen/entwurf-jahresplan) */
.jp-jahre { display: flex; gap: 6px; }
.jp-leiste .hinweis { margin-left: 0; }
.jp-versionen { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; }
.jp-gilt { font-size: 11px; font-weight: 700; color: var(--gut-text); background: var(--gut-bg); border-radius: 99px; padding: 1px 6px; margin-left: 2px; }
.jp-werkzeug[hidden] { display: none; }
.jp-werkzeug { flex-basis: 100%; display: flex; gap: 10px; align-items: center; flex-wrap: wrap; background: var(--fl); border: 1px solid var(--linie); border-radius: 10px; padding: 10px 12px; }
.jp-umbenennen { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; }
.jp-umbenennen input { padding: 7px 10px; }
.jp-leer { max-width: 760px; }
.jp-leer h2 { margin-top: 0; }
.jp-liste { padding-left: 20px; line-height: 1.6; }
.jp-raster { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1.05fr); gap: 16px; align-items: start; }
.jp-links, .jp-rechts { display: flex; flex-direction: column; gap: 14px; min-width: 0; }
.jp-rechts { position: sticky; top: 12px; }
.jp-schritte { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 6px; }
.jp-schritte button { display: flex; gap: 8px; align-items: center; text-align: left; font-size: 13px; padding: 8px 10px; }
.jp-nr { flex: none; display: inline-grid; place-items: center; width: 22px; height: 22px; border-radius: 99px; background: var(--akzent-hell); color: var(--akzent); font-size: 12px; font-weight: 700; margin-right: 8px; }
.jp-schritte .jp-nr { margin-right: 0; }
.jp-schritt { scroll-margin-top: 12px; }
.jp-schritt h2 { display: flex; align-items: center; font-size: 17px; margin: 0 0 12px; }
.jp-unter { font-size: 14px; margin: 16px 0 8px; color: var(--leise); text-transform: uppercase; letter-spacing: .04em; }
.jp-bausteine { display: flex; flex-direction: column; gap: 8px; margin-bottom: 8px; }
.jp-baustein { border: 1px solid var(--linie); border-radius: 10px; background: var(--fl); }
.jp-baustein.auf { border-color: var(--akzent); box-shadow: 0 0 0 2px var(--akzent-hell); }
.jp-zeile { all: unset; box-sizing: border-box; display: flex; align-items: center; gap: 12px; width: 100%; padding: 10px 12px; cursor: pointer; border-radius: 10px; }
.jp-zeile:hover { background: var(--titel-bg); }
.jp-zeile:focus-visible { outline: 2px solid var(--akzent); }
.jp-sym { font-size: 20px; }
.jp-was { flex: 1; min-width: 0; display: flex; flex-direction: column; }
.jp-was small { color: var(--leise); font-size: 13px; }
.jp-betrag { font-weight: 600; white-space: nowrap; font-variant-numeric: tabular-nums; }
.jp-editor, .jp-felder { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 10px 14px; }
.jp-editor { padding: 4px 12px 12px; border-top: 1px solid var(--linie); padding-top: 12px; }
.jp-breit { grid-column: 1 / -1; }
.jp-editor .knoepfe { display: flex; justify-content: space-between; gap: 8px; }
.jp-f { display: flex; flex-direction: column; gap: 4px; font-size: 13px; color: var(--leise); min-width: 0; }
.jp-f > span:first-child { font-weight: 600; color: var(--text); }
.jp-ein { display: flex; align-items: center; border: 1px solid var(--eingabe-linie); background: var(--eingabe-bg); border-radius: 8px; overflow: hidden; }
.jp-ein input, .jp-ein select { flex: 1; min-width: 0; border: 0; background: transparent; color: var(--eingabe-text); font: inherit; font-size: 15px; padding: 8px 10px; text-align: right; font-variant-numeric: tabular-nums; }
.jp-ein select { text-align: left; color: var(--text); background: var(--fl); }
.jp-ein input[data-t="text"] { text-align: left; }
.jp-ein i { font-style: normal; padding: 0 10px; color: var(--leise); font-size: 13px; white-space: nowrap; }
.jp-ein:focus-within { outline: 2px solid var(--akzent); }
.jp-ein input.ungueltig { background: var(--warnung-bg); color: var(--warnung-text); }
.jp-f small.hinweis { font-size: 12px; }
.jp-treppe h2, .jp-vergleich h2 { margin: 0 0 10px; font-size: 17px; }
.jp-treppe table { width: 100%; border-collapse: collapse; font-variant-numeric: tabular-nums; }
.jp-treppe td { padding: 7px 6px; border-bottom: 1px solid var(--linie); vertical-align: top; }
.jp-treppe td small { display: block; color: var(--leise); font-size: 12px; }
.jp-z { width: 16px; color: var(--leise); font-weight: 700; }
.jp-mitte { color: var(--leise); font-size: 12.5px; }
.jp-q { font-size: 12px; color: var(--leise); text-align: right; width: 118px; }
.jp-treppe td.zahl { white-space: nowrap; text-align: right; }
.jp-q .ampel-chip { margin-left: 4px; }
.jp-treppe tr.summe td { font-weight: 600; border-top: 2px solid var(--linie); }
.jp-treppe tr.gewinn td { font-size: 16px; }
.jp-treppe tr.gewinn.rot td.zahl { color: var(--warn); }
.jp-treppe tr.gewinn.gruen td.zahl { color: var(--gut-text); }
.jp-luecke { margin-top: 12px; padding: 10px 12px; border-radius: 10px; background: var(--titel-bg); border: 1px dashed var(--linie); }
.jp-luecke p { margin: 0 0 8px; }
.jp-vorschlaege { display: flex; gap: 6px; flex-wrap: wrap; margin-bottom: 6px; }
.jp-vorschlaege .chip-knopf, .chip-knopf.gestrichelt { border-style: dashed; border-color: var(--akzent); color: var(--akzent); font-size: 13.5px; }
.jp-ok { color: var(--gut-text); font-weight: 600; }
.jp-scroll { overflow-x: auto; }
.jp-vergleich table { width: 100%; border-collapse: collapse; font-variant-numeric: tabular-nums; font-size: 14px; }
.jp-vergleich th, .jp-vergleich td { padding: 6px 8px; border-bottom: 1px solid var(--linie); text-align: right; white-space: nowrap; }
.jp-vergleich th[scope=row], .jp-vergleich thead th:first-child { text-align: left; font-weight: 500; color: var(--leise); }
.jp-vergleich .an { background: var(--akzent-hell); }
.jp-gespeichert { min-height: 1em; margin: 0; }
.jp-monate, .jp-planist { display: flex; flex-direction: column; gap: 14px; }
.jp-knapp { display: flex; gap: 14px; align-items: flex-start; border-left: 5px solid var(--gut-text); }
.jp-knapp.eng { border-left-color: var(--eingabe-linie); }
.jp-knapp p { margin: 0 0 8px; }
.jp-vorlagen { display: flex; gap: 6px; flex-wrap: wrap; }
.jp-saison { display: grid; grid-template-columns: repeat(12, minmax(0, 1fr)); gap: 8px; margin-top: 10px; }
.jp-monat { display: flex; flex-direction: column; align-items: stretch; gap: 4px; text-align: center; font-size: 12.5px; min-width: 0; }
.jp-monat b { font-size: 12px; font-variant-numeric: tabular-nums; }
.jp-saeule-feld { height: 120px; display: flex; align-items: flex-end; cursor: ns-resize; touch-action: none; border-bottom: 1px solid var(--linie); }
.jp-saeule { width: 100%; background: var(--g-vorgang-rand); border-radius: 5px 5px 0 0; }
.jp-monat.tief .jp-saeule { background: var(--akzent); }
.jp-saeule:focus-visible { outline: 2px solid var(--akzent); outline-offset: 2px; }
.jp-monat label { display: flex; flex-direction: column; gap: 2px; color: var(--leise); }
.jp-monat input { width: 100%; text-align: center; border: 1px solid var(--eingabe-linie); background: var(--eingabe-bg); color: var(--eingabe-text); border-radius: 6px; padding: 3px 2px; font: inherit; font-size: 12.5px; }
.jp-monat label i { display: none; }
.jp-summe { color: var(--warnung-text); margin: 10px 0 0; font-size: 14px; }
.jp-tabelle .liste { overflow-x: auto; }
.jp-monatsplan td, .jp-monatsplan th { white-space: nowrap; font-variant-numeric: tabular-nums; font-size: 13.5px; padding: 6px 7px; }
.jp-monatsplan tr.jp-summe-zeile td { font-weight: 600; border-top: 2px solid var(--linie); }
.jp-monatsplan tr.jp-klein td { color: var(--leise); font-size: 13px; }
.jp-monatsplan .aus { color: var(--warn); }
.jp-monatsplan .ein { color: var(--gut-text); }
.jp-monatsplan .jp-tief { background: var(--warnung-bg); color: var(--warnung-text); padding: 2px 4px; border-radius: 4px; }
.jp-pi-kopf { display: flex; gap: 12px; align-items: center; flex-wrap: wrap; }
.jp-monatswahl { display: flex; gap: 4px; flex-wrap: wrap; }
.jp-monatswahl .chip-knopf { font-size: 13px; padding: 4px 9px; color: var(--leise); }
.jp-monatswahl .chip-knopf.mit { color: var(--text); font-weight: 600; }
.jp-monatswahl .chip-knopf.an { color: var(--akzent); }
.knopf-datei { margin-left: auto; cursor: pointer; }
label.haupt { display: inline-block; background: var(--akzent); color: var(--akzent-text); border-radius: 8px; padding: 10px 18px; font-weight: 600; }
label.haupt:hover { background: var(--akzent-hover); }
label.haupt:focus-within { outline: 2px solid var(--akzent); outline-offset: 2px; }
#jp-bwa-fehler:empty { display: none; }
.jp-kennzahlen { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 12px; }
.jp-kz { display: flex; flex-direction: column; gap: 2px; border-top: 4px solid var(--linie); }
.jp-kz b { font-size: 26px; font-variant-numeric: tabular-nums; }
.jp-kz small { color: var(--leise); }
.jp-kz.gut { border-top-color: var(--gut-text); }
.jp-kz.schlecht { border-top-color: var(--warn); }
.jp-kz.schlecht b { color: var(--warn); }
.jp-pi td { font-variant-numeric: tabular-nums; }
.jp-pi tr.jp-summe-zeile td { font-weight: 600; border-top: 2px solid var(--linie); }
.jp-pi tr.jp-gelb td { background: var(--eingabe-bg); color: var(--eingabe-text); }
.jp-pi tr.jp-rot td { background: var(--warnung-bg); color: var(--warnung-text); }
.jp-pi tr.jp-gut td.zahl:nth-last-child(2) { color: var(--gut-text); }
input.jp-notiz { width: 100%; min-width: 140px; border: 1px solid var(--linie); border-radius: 6px; padding: 5px 8px; background: var(--fl); color: var(--text); font: inherit; font-size: 13.5px; }
.jp-zu { width: 100%; border-collapse: collapse; font-size: 14px; margin-top: 10px; }
.jp-zu th, .jp-zu td { padding: 5px 8px; border-bottom: 1px solid var(--linie); text-align: left; }
.jp-zu td.zahl, .jp-zu th.zahl { text-align: right; font-variant-numeric: tabular-nums; }
.jp-zu tr.leise td { color: var(--leise); }
.jp-zu select { padding: 5px 8px; border: 1px solid var(--linie); border-radius: 6px; background: var(--fl); color: var(--text); font: inherit; font-size: 13.5px; max-width: 100%; }
.jp-sitzung h2 { font-size: 17px; margin: 0 0 8px; }
.jp-sitzung ul { list-style: none; padding: 0; margin: 0 0 8px; display: flex; flex-direction: column; gap: 6px; }
.jp-sitzung li.spaeter { color: var(--leise); }
.jp-sitzung label { display: flex; gap: 8px; align-items: flex-start; }
.erfolg-text { color: var(--gut-text); font-weight: 600; font-size: 13.5px; }
.start-jahresplan { display: flex; flex-wrap: wrap; gap: 4px 12px; align-items: center; margin-top: 12px; padding-top: 10px; border-top: 1px solid var(--linie); }
.start-jahresplan a { color: var(--text); text-decoration: none; }
.start-jahresplan a:hover { color: var(--akzent); }
.jp-balken { flex-basis: 100%; height: 6px; border-radius: 99px; background: var(--linie); overflow: hidden; }
.jp-balken i { display: block; height: 100%; background: var(--gut-text); }
.liqui-plan-hinweis { margin-top: 4px; }
@media (max-width: 1100px) {
.jp-raster { grid-template-columns: minmax(0, 1fr); }
.jp-rechts { position: static; }
}
@media (max-width: 800px) {
.jp-schritte { grid-template-columns: repeat(2, minmax(0, 1fr)); }
.jp-editor, .jp-felder { grid-template-columns: minmax(0, 1fr); }
.jp-kennzahlen { grid-template-columns: minmax(0, 1fr); }
.jp-saison { grid-template-columns: repeat(6, minmax(0, 1fr)); }
.jp-saeule-feld { height: 80px; }
.jp-treppe td { padding: 6px 3px; }
.jp-mitte { display: none; }
.jp-q { white-space: normal; }
.jp-knapp { flex-direction: column; }
.knopf-datei { margin-left: 0; }
}
.jp-monate .karte-kopf { flex-wrap: wrap; gap: 8px; }