Files
Betriebsf-hrungssoftware/src/web/jahresplan.ts
Claude 3f64143ee1
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
0.50.0: Umsetzung der UX-Prüfung (Übersicht, Menü, Einstellungen, Projekte, Liquidität, Handy)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-11-08 14:40:57 +00:00

618 lines
46 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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(start?: Reiter): Promise<void> {
if (start) reiter = start;
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>`;
}