Stufe 5: Jahresplanung mit Versionen, 12 Monaten, Plan/Ist und BWA-Import (0.22.0)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
616
src/web/jahresplan.ts
Normal file
616
src/web/jahresplan.ts
Normal 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>`;
|
||||
}
|
||||
Reference in New Issue
Block a user