`;
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 `
Version:${versionen.map((v) =>
``).join("")}
`;
}
async function leisteKlick(ev: Event, leiste: HTMLElement): Promise {
const b = (ev.target as HTMLElement).closest("[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(".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 = `
${plan.gilt ? 'Diese Version gilt für Liquidität, Übersicht und Plan / Ist.' : ''}
${plan.basis ? 'Die Basis bleibt immer erhalten.' : ''}`;
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 {
await speichernJetzt();
const v = await api("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 = `
Für ${jahr} gibt es noch keinen Plan
Das Programm füllt den ersten Plan, die Basis, mit dem, was es schon weiß. Danach passt du Leute, Stundensatz und Kosten an.
Laufende Kosten ohne Personal: ${eur(v.laufend.ohnePersonal)} im Monat, Personal daraus als Unternehmerlohn: ${eur(v.laufend.personal)}
Kontostand ${eur(v.kontostand)} und Mindestgrenze ${eur(v.mindestgrenze)} aus der Liquidität
${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.`}
`;
karte.querySelector("[data-a=anlegen]")!.onclick = async () => {
const neu = await api("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 {
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..brutto", "i..betrag", "s." */
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)[teile[1]!] = wert;
if (teile[0] === "m") { const m = p.mitarbeiter.find((x) => x.id === teile[1]); if (m) (m as unknown as Record)[teile[2]!] = wert; }
if (teile[0] === "i") { const v = p.investitionen.find((x) => x.id === teile[1]); if (v) (v as unknown as Record)[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 = ``;
inhalt.append(raster);
const links = raster.querySelector(".jp-links")!, rechts = raster.querySelector(".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("[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("[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(`[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(".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 `👷${esc(m.name)}${m.art === "inhaber" ? " (Chef)" : ""}${unter}${eur(personalMonat(m) * mon)}`;
}
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 `🚐${esc(v.name)} ${MONATSNAMEN[v.monat - 1]}${eur(v.betrag)} · ${fin}${v.art === "leasing" ? "keine AfA" : `AfA ${eur(r.afaJahr)}`}`;
}
const f = (label: string, feld: string, typ: string, wert: string, zusatz = "", hilfe = "") =>
``;
function mitarbeiterEditor(m: PlanMitarbeiter): string {
const p = `m.${m.id}`;
return `
Bis zum Ziel fehlen ${eur(t.luecke)} Gewinn. Möglichkeiten zum Ausprobieren:
${vs.map((v) => ``).join("") || 'Mehr Stunden, höherer Satz oder weniger Kosten.'}
Ein Klick legt eine neue Version an. Deine ${esc(plan!.name)} bleibt unverändert, Versionen lassen sich unten nebeneinander vergleichen.
`
: `
Gewinnziel erreicht: ${pct(t.quoteGewinn)} vom Rohertrag.
`}
Ziele nach Roos („Finanzen einfach machen“): Personal und Werbung höchstens ${ZIEL_PERSONAL} %, Gewinn ${ZIEL_GEWINN} % vom Rohertrag. Alle Werte netto.
`;
}
// ---------- 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 = `${r.tief.abstand < 0 ? "Achtung" : eng ? "Knapp" : "Passt"} ${MONATSNAMEN[r.tief.monat - 1]}
${esc(kt.satz)} ${esc(kt.grund)}
${eng ? `
${inv ? `` : ""}
` : ""}
Umsatz übers Jahr verteilen · Säule ziehen oder Wert eintippen
${p.saison.map((s, i) => {
const h = Math.max(4, Math.min(100, (s / 15) * 100));
return `
${k(r.monate.umsatz[i]!)}
`;
}).join("")}
${Math.abs(sum - 100) > 0.05 ? `
Summe ${pct(sum)} · das Programm rechnet anteilig ·
` : ""}
Monatsplan · jede Zeile filter- und sortierbar wie überall · Werte in €
${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 ?? "")}“.`}
`;
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(`[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(".jp-saeule-feld");
const saeule = s?.querySelector(".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(".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(`.jp-saeule[data-s="${i}"]`)?.focus();
});
wurzel.addEventListener("click", async (ev) => {
const b = (ev.target as HTMLElement).closest("[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 = 'Als Aufgabe angelegt';
}
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) =>
` 0 ? " ein" : ""}${z.id === "kontostand" && i === r.tief.monat - 1 ? " jp-tief" : ""}${z.id === "kontostand" && v < p.annahmen.mindestgrenze ? " fehler" : ""}">${v ? zahl(v) : "–"}`;
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 ? "" : `${zahl((z.werte as number[]).reduce((x, y) => x + y, 0))}`), 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 · öffnen' },
{ 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 {
const q = new URLSearchParams({ jahr: String(jahr), kumuliert: piKum ? "1" : "0", ...(piMonat ? { monat: String(piMonat) } : {}) });
const x = await api(`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 = `
Für ${jahr} gibt es keinen Jahresplan; die Tabelle zeigt nur die Ist-Werte. Die BWA dient dem Plan ${jahr! + 1} als Vorjahr.
` : ""}
${kz}
${bwa ? `BWA ${monatName} · eingelesen ${dat(String(bwa.eingelesen_am).slice(0, 10))} · ${esc(bwa.art ?? "")}` : `Noch keine BWA für ${monatName} ${jahr}`}
${bwa ? `` : ""}
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)}“.` : ""}