diff --git a/CHANGELOG.md b/CHANGELOG.md index 3c830c5..b6142ba 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,19 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.22.0 + +- Jahresplanung (Stufe 5, Henning 21.10.2026, Entwurf finanzen/entwurf-jahresplan), nur für den Inhaber: neuer Menüpunkt mit Reitern Plan aufbauen, 12 Monate und Plan / Ist, Jahr mit ‹ › wählbar. +- Versionen: der erste Plan eines Jahres ist die Basis und bleibt immer erhalten; „+ neue Version“ kopiert die gewählte Version zum Ausprobieren. Eine Version „gilt“ für Liquidität, Übersicht und Plan / Ist. Alle Versionen eines Jahres stehen nebeneinander (Umsatz, Rohertrag, Personal + Werbung, Gewinn, knappster Monat). +- Plan aufbauen in vier Schritten mit Bausteinen: Mitarbeiter (verkaufbare Stunden, Brutto × 1,25, ab/bis Monat; der Inhaber mit Unternehmerlohn), Stundensatz, Material und Sub mit Aufschlag, laufende Kosten (aus „Laufende Kosten“, Personal getrennt) mit Preissteigerung, Werbung, bisherige Abschreibungen und Tilgung, Steuer-Vorauszahlungen, Kontostand und Mindestgrenze, Investitionen (Kauf, Anzahlung + Kredit mit Annuität, Leasing; AfA ab dem Kaufmonat). Der erste Plan übernimmt laufende Kosten, Kontostand, Mindestgrenze und, wenn eingelesen, die BWA des Vorjahres. +- „So rechnet sich dein Jahr“: Stunden × Satz + Material und Sub mit Aufschlag = Umsatz → Rohertrag → Personal inkl. Unternehmerlohn + Werbung (Ziel ≤ 55 %) → laufende Kosten → Abschreibungen → Gewinn (Ziel 20 % vom Rohertrag), mit Ampeln. Fehlt Gewinn, schlägt das Programm Stundensatz, Material- oder Sub-Aufschlag vor; ein Klick legt die Version an. +- 12 Monate: Satz zum knappsten Monat mit Grund, bei Engpass „Kontokorrent … anfragen“ (legt eine Aufgabe an) und „Investition später“ (neue Version). Saison als Säulen zum Ziehen oder Eintippen, Vorlagen Handwerk typisch, gleichmäßig, aus dem Vorjahr (BWA). Monatsplan bis Kontostand Monatsende und Mindestgrenze, mit „davon schon beauftragt“ und „noch zu verkaufen“; filter- und sortierbar wie alle Tabellen. +- Liquidität: die geltende Version zählt ab dem nächsten Monat als Vorschau („Plan: …“), soweit echte Zahlungen fehlen; Einnahmen und Material/Sub nur der Rest über Zahlungsplänen und Eingangsrechnungen, dazu Löhne neuer Mitarbeiter, Investitionen und Steuer-Vorauszahlungen. Auf der Lage ein- und ausschaltbar. +- Plan / Ist: BWA von Herrn Seeler (DATEV-.xls, BWA-Wertenachweis SKR04) einlesen, Monat wählen oder bis zum Monat kumuliert. Drei Kennzahlen (Rohertrag, Personal + Werbung vom Rohertrag, Gewinn vom Rohertrag), Tabelle Plan / Ist / Abweichung mit Notiz je Zeile, gelb ab 5 %, rot ab 15 % schlechter als geplant. Die BWA-Zeilen werden einmal den Planzeilen zugeordnet (Vorschlag fürs Muster), neue Zeilen fallen beim Einlesen auf. +- Finanzsitzung: Checkliste je Monat auf Plan / Ist und eine Aufgabe „Finanzsitzung“ am ersten Freitag jedes Monats, sobald es einen Jahresplan gibt. +- Übersicht: unter der Liquidität „Jahresplan 2027: noch … Umsatz zu verkaufen“ mit beauftragtem Anteil. +- Testversion: Abfragen zählten Zeilen falsch (PGlite meldet bei select 0 betroffene Zeilen); betraf Prüfungen wie „hat schon einen Zahlungsplan“. + ## 0.21.0 - Angebot als Dokument wie der spätere Ausdruck (Henning, 21.10.2026, Entwurf angebote/entwurf-uebersicht): Empfänger, Datum, Bindefrist, Betreff, Leistungsort und Einleitung stehen oben direkt sichtbar, Summe und Schlusstext unter den Positionen. Solange eine Position offen ist, klappt der Kopf zu einer Zeile zusammen. diff --git a/demo/kern.ts b/demo/kern.ts index 0202570..7e3b501 100644 --- a/demo/kern.ts +++ b/demo/kern.ts @@ -20,6 +20,7 @@ import m015 from "../src/server/migrations/015_mengenblatt.sql"; import m016 from "../src/server/migrations/016_fahrt.sql"; import m017 from "../src/server/migrations/017_stammdaten.sql"; import m018 from "../src/server/migrations/018_freitage.sql"; +import m019 from "../src/server/migrations/019_jahresplan.sql"; const MIGRATIONEN: [string, string][] = [ ["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004], @@ -35,6 +36,7 @@ const MIGRATIONEN: [string, string][] = [ ["016_fahrt.sql", m016], ["017_stammdaten.sql", m017], ["018_freitage.sql", m018], + ["019_jahresplan.sql", m019], ]; export async function starte(db: PGlite, v70?: unknown) { diff --git a/demo/pool.ts b/demo/pool.ts index 8deb91a..bd39923 100644 --- a/demo/pool.ts +++ b/demo/pool.ts @@ -14,7 +14,8 @@ export function alsPool(db: PGlite) { return { rows: [], rowCount: 0 }; } const r = await db.query(sql, params ?? []); - return { rows: r.rows as any[], rowCount: r.affectedRows ?? r.rows.length }; + // PGlite meldet bei select affectedRows = 0, pg zählt die Zeilen + return { rows: r.rows as any[], rowCount: Math.max(r.affectedRows ?? 0, r.rows.length) }; }; // PGlite hat nur eine Verbindung: Transaktionen laufen nacheinander let kette: Promise = Promise.resolve(); diff --git a/package.json b/package.json index 6d525ee..84cf780 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.21.0", + "version": "0.22.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/domain/bwa.ts b/src/domain/bwa.ts new file mode 100644 index 0000000..0c5c869 --- /dev/null +++ b/src/domain/bwa.ts @@ -0,0 +1,164 @@ +// BWA von Herrn Seeler einlesen (B1): DATEV-Export „BWA-Wertenachweis“, SKR04. Die .xls-Datei ist eine HTML-Tabelle: +// Zeile | Bezeichnung | Konto | | Konten-/Zeilenbeschriftung | Fkt. | Monat je Konto | Monat je Zeile | kumuliert je Konto | kumuliert je Zeile. +// Summenzeilen nennen statt Konten die Zeilen, aus denen sie bestehen. Beträge in Cent; Kosten stehen positiv. + +import type { Cent } from "./geld.js"; +import { type Planzeile, PLANZEILEN, type Rechnung, ZIEL_GEWINN, ZIEL_PERSONAL, planWerte } from "./jahresplan.js"; + +export interface BwaKonto { konto: string; name: string; monat: Cent; kumuliert: Cent } +export interface BwaZeile { zeile: number; bezeichnung: string; monat: Cent; kumuliert: Cent; konten: BwaKonto[]; summe: boolean } +export interface Bwa { jahr: number; monat: number; art: string; zeilen: BwaZeile[] } + +export class BwaFehler extends Error {} + +const entities = (s: string) => + s.replace(/ /gi, " ").replace(/&/gi, "&").replace(/</gi, "<").replace(/>/gi, ">").replace(/"/gi, '"') + .replace(/&#(\d+);/g, (_, n) => String.fromCharCode(Number(n))).replace(/&#x([0-9a-f]+);/gi, (_, n) => String.fromCharCode(parseInt(n, 16))); +const zelle = (s: string) => entities(s.replace(//gi, " ").replace(/<[^>]+>/g, "")).replace(/\s+/g, " ").trim(); + +/** „59.653,91“ oder „-0,01“ in Cent; leer = null */ +export function betrag(s: string): Cent | null { + const t = s.replace(/\s/g, ""); + if (!/^-?[\d.]*\d(,\d+)?-?$/.test(t)) return null; + const minus = t.startsWith("-") || t.endsWith("-"); + const [ganz, nach = ""] = t.replace(/-/g, "").replace(/\./g, "").split(","); + const c = Number(ganz) * 100 + Number((nach + "00").slice(0, 2)); + return minus ? -c : c; +} + +export function liesBwa(html: string): Bwa { + const zeilen = [...html.matchAll(/]*>([\s\S]*?)<\/tr>/gi)].map((m) => [...m[1]!.matchAll(/]*>([\s\S]*?)<\/t[dh]>/gi)].map((z) => zelle(z[1]!))); + if (!zeilen.length) throw new BwaFehler("In der Datei steht keine Tabelle. Bitte die BWA als .xls aus DATEV (BWA-Wertenachweis) nehmen."); + const text = zeilen.map((z) => z.join(" ")).join("\n"); + const stand = /zum\s+(\d{2})\.(\d{2})\.(\d{4})/.exec(text) ?? /(\w{3})\/(\d{4})/.exec(text); + let jahr = 0, monat = 0; + if (stand && stand.length === 4) { monat = Number(stand[2]); jahr = Number(stand[3]); } + if (!jahr) throw new BwaFehler("Monat und Jahr der BWA nicht gefunden (erwartet „… zum 31.08.2026“)."); + const art = /(Einnahmen-Ausgaben-BWA|Kurzfristige Erfolgsrechnung|Bewegungsbilanz|Statische Liquidität)/.exec(text)?.[1] ?? "BWA"; + const aus: BwaZeile[] = []; + let akt: BwaZeile | null = null; + for (const z of zeilen) { + const nr = /^\d{3,4}$/.test(z[0] ?? "") ? Number(z[0]) : null; + // Werte stehen in den letzten vier Spalten (Monat Konto/Zeile, kumuliert Konto/Zeile) + const w = z.slice(-4).map(betrag); + if (nr !== null && z.length >= 6) { + akt = { zeile: nr, bezeichnung: z[1] || z[4] || "", monat: w[1] ?? w[0] ?? 0, kumuliert: w[3] ?? w[2] ?? 0, konten: [], summe: false }; + aus.push(akt); + } else if (!akt || !z[2] || z.length < 6) continue; + const konto = z[2] ?? ""; + if (!/^\d{3,}$/.test(konto)) continue; + // vierstellig = Verweis auf eine andere Zeile, also eine Summenzeile + if (konto.length <= 4) { akt.summe = true; continue; } + akt.konten.push({ konto, name: z[4] ?? "", monat: w[0] ?? 0, kumuliert: w[2] ?? 0 }); + } + if (!aus.length) throw new BwaFehler("Keine BWA-Zeilen gefunden. Bitte die BWA als .xls aus DATEV (BWA-Wertenachweis) nehmen."); + // Summen wie „Vorläufiges Ergebnis“ ohne Konten, aber mit Gleichheitszeichen oder als Ergebniszeile + for (const z of aus) if (/^=|ergebnis|summe|liquiditätsbeitrag|über-\/-unterdeckung|betriebseinnahmen$|betriebsausgaben$|einnahmen-ausgaben-bwa/i.test(z.bezeichnung)) z.summe = true; + return { jahr, monat, art, zeilen: aus }; +} + +// Zuordnung für die Einnahmen-Ausgaben-BWA (Form 43, SKR04), wie in Hennings Muster von Herrn Seeler +const VORGABE: Record = { + 1040: "umsatz", 1050: "umsatz", + 1230: "material", 1240: "material", + 1250: "personal", + 1260: "laufend", 1270: "laufend", 1280: "laufend", 1300: "laufend", 1310: "laufend", 1330: "laufend", 1410: "laufend", + 1290: "werbung", + 1320: "afa", + 1460: "ignorieren", 1681: "ignorieren", + 1700: "tilgung", 1710: "investition", + 1800: "unternehmerlohn", + 1810: "steuer", +}; + +/** Vorschlag für eine BWA-Zeile: zuerst die bekannte Zeilennummer, sonst nach der Bezeichnung */ +export function zuordnungVorschlag(z: Pick): Planzeile { + if (z.summe) return "ignorieren"; + if (VORGABE[z.zeile]) return VORGABE[z.zeile]!; + const b = z.bezeichnung.toLowerCase(); + if (/umsatzsteuer|vorsteuer|anzahlung|forderung|verbindlichkeit|privateinlage|darlehen/.test(b)) return "ignorieren"; + if (/erlös|umsatz/.test(b)) return "umsatz"; + if (/material|waren|fremdleist/.test(b)) return "material"; + if (/personal|löhne|gehälter/.test(b)) return "personal"; + if (/werbe/.test(b)) return "werbung"; + if (/abschreib|afa/.test(b)) return "afa"; + if (/privatentnahm/.test(b)) return "unternehmerlohn"; + if (/tilgung/.test(b)) return "tilgung"; + if (/raum|fahrzeug|versicherung|beitr|kosten|instandhaltung|werkzeug|zins/.test(b)) return "laufend"; + return "ignorieren"; +} + +export interface PlanIstZeile { + id: string; + text: string; + plan: Cent; + ist: Cent | null; + abweichung: Cent | null; + /** in % vom Plan */ + prozent: number | null; + /** Abweichung ab 5 %: gelb, ab 15 % rot; gut = besser als geplant */ + stufe: "" | "gelb" | "rot" | "gut"; + /** Kosten: im Plan als negative Zahl gezeigt */ + kosten: boolean; + summe?: boolean; +} + +export interface Kennzahl { id: string; text: string; wert: number | null; plan: number; ziel?: number; einheit: "€" | "%"; gut: boolean | null; unter: string } + +/** Ist-Werte je Planzeile aus den BWA-Zeilen: Monat oder kumuliert (Jan bis Monat) */ +export function istWerte(zeilen: Pick[], zuordnung: Map, kumuliert: boolean): Record { + const ist: Record = Object.fromEntries(PLANZEILEN.map((p) => [p, 0])); + for (const z of zeilen) { + const p = zuordnung.get(z.zeile); + if (!p || p === "ignorieren") continue; + ist[p]! += kumuliert ? z.kumuliert : z.monat; + } + return ist; +} + +const ZEILEN: { id: (typeof PLANZEILEN)[number] | "rohertrag" | "ergebnis"; text: string; kosten: boolean; summe?: boolean }[] = [ + { id: "umsatz", text: "Umsatzerlöse", kosten: false }, + { id: "material", text: "Material und Subunternehmer", kosten: true }, + { id: "rohertrag", text: "Rohertrag", kosten: false, summe: true }, + { id: "personal", text: "Personalkosten", kosten: true }, + { id: "unternehmerlohn", text: "Unternehmerlohn (Privatentnahmen)", kosten: true }, + { id: "werbung", text: "Werbekosten", kosten: true }, + { id: "laufend", text: "Laufende Kosten (Raum, Fahrzeug, Versicherung, Büro)", kosten: true }, + { id: "afa", text: "Abschreibungen", kosten: true }, + { id: "ergebnis", text: "Betriebsergebnis", kosten: false, summe: true }, + { id: "tilgung", text: "Tilgung Kredite", kosten: true }, + { id: "investition", text: "Investitionen", kosten: true }, + { id: "steuer", text: "Steuer-Vorauszahlungen (privat)", kosten: true }, +]; + +const ergaenzt = (x: Record): Record & { rohertrag: Cent; ergebnis: Cent } => { + const rohertrag = x.umsatz! - x.material!; + return { ...x, rohertrag, ergebnis: rohertrag - x.personal! - x.unternehmerlohn! - x.werbung! - x.laufend! - x.afa! }; +}; + +export function planIst(r: Rechnung, ist: Record | null, monat: number, kumuliert: boolean): { zeilen: PlanIstZeile[]; kennzahlen: Kennzahl[] } { + const plan = ergaenzt(planWerte(r, monat, kumuliert)); + const i = ist ? ergaenzt(ist) : null; + const zeilen = ZEILEN.map((z): PlanIstZeile => { + const p = plan[z.id] ?? 0, w = i ? i[z.id] ?? 0 : null; + // Kosten: mehr als geplant ist schlecht; Erlöse und Ergebnis: weniger ist schlecht + const abweichung = w === null ? null : z.kosten ? p - w : w - p; + const prozent = w === null || !p ? null : Math.round((Math.abs(w - p) / Math.abs(p)) * 1000) / 10; + const stufe = abweichung === null || prozent === null || prozent < 5 ? "" : abweichung > 0 ? "gut" : prozent >= 15 ? "rot" : "gelb"; + return { id: z.id, text: z.text, plan: p, ist: w, abweichung, prozent, stufe, kosten: z.kosten, ...(z.summe ? { summe: true } : {}) }; + }); + // Kennzahlen (Roos): Rohertrag, Personal + Werbung vom Rohertrag, Gewinn vom Rohertrag (immer kumuliert) + const kum = ergaenzt(planWerte(r, monat, true)); + const q = (x: Cent, b: Cent) => (b > 0 ? Math.round((x / b) * 100) : null); + const pw = (x: Record) => x.personal! + x.unternehmerlohn! + x.werbung!; + const istKum = i && kumuliert ? i : null; + const kennzahlen: Kennzahl[] = [ + { id: "rohertrag", text: `Rohertrag ${kumuliert ? "bis" : ""}`, wert: i ? i.rohertrag : null, plan: plan.rohertrag, einheit: "€", + gut: i ? i.rohertrag >= plan.rohertrag : null, unter: "" }, + { id: "personal", text: "Personal + Werbung vom Rohertrag", wert: i ? q(pw(i), i.rohertrag) : null, plan: q(pw(plan), plan.rohertrag) ?? 0, ziel: ZIEL_PERSONAL, einheit: "%", + gut: i ? (q(pw(i), i.rohertrag) ?? 999) <= ZIEL_PERSONAL : null, unter: "" }, + { id: "gewinn", text: "Gewinn vom Rohertrag", wert: istKum ? q(istKum.ergebnis, istKum.rohertrag) : i ? q(i.ergebnis, i.rohertrag) : null, plan: q(kum.ergebnis, kum.rohertrag) ?? 0, ziel: ZIEL_GEWINN, einheit: "%", + gut: i ? (q(i.ergebnis, i.rohertrag) ?? -999) >= ZIEL_GEWINN : null, unter: "" }, + ]; + return { zeilen, kennzahlen }; +} diff --git a/src/domain/jahresplan.ts b/src/domain/jahresplan.ts new file mode 100644 index 0000000..32bcf94 --- /dev/null +++ b/src/domain/jahresplan.ts @@ -0,0 +1,422 @@ +// Jahresfinanzplanung (Stufe 5, Henning 21.10.2026, Entwurf finanzen/entwurf-jahresplan): ein Jahresplan wird aus +// Bausteinen gebaut (Mitarbeiter, Investitionen, Annahmen) und rechnet die „Treppe“ nach Roos: +// Stunden × Satz + Material/Sub mit Aufschlag = Umsatz → Rohertrag → Personal + Werbung (Ziel ≤ 55 % vom Rohertrag) +// → laufende Kosten → Abschreibungen → Gewinn (Ziel 20 % vom Rohertrag). Der Monatsplan verteilt den Umsatz nach +// der Saison und rechnet bis zum Kontostand am Monatsende. Alle Beträge netto in Cent. + +import type { Cent } from "./geld.js"; +import type { Posten } from "./liquiditaet.js"; + +export interface PlanMitarbeiter { + id: string; + name: string; + /** Inhaber: „brutto“ ist der Unternehmerlohn je Monat; angestellt: Bruttolohn je Monat */ + art: "inhaber" | "angestellt"; + /** verkaufbare Stunden bei einem vollen Jahr */ + stunden: number; + brutto: Cent; + /** Arbeitgeberanteile usw., Vorschlag 1,25 */ + faktor: number; + /** erster und letzter Monat im Planjahr (1–12) */ + eintritt: number; + austritt: number; + /** kommt neu dazu: steht noch nicht in den laufenden Kosten, zählt in der Liquidität als Plan mit */ + neu: boolean; +} + +export interface PlanInvestition { + id: string; + name: string; + betrag: Cent; + /** Monat der Anschaffung (1–12) */ + monat: number; + art: "kauf" | "kredit" | "leasing"; + /** Kredit: Eigenanteil; Leasing: Sonderzahlung */ + anzahlung: Cent; + /** Kredit- bzw. Leasinglaufzeit in Monaten */ + laufzeit: number; + /** Zins % im Jahr (Kredit) */ + zins: number; + /** Leasingrate je Monat */ + rate: Cent; + /** Nutzungsdauer für die Abschreibung in Jahren (Kauf und Kredit) */ + nutzungsdauer: number; +} + +export interface PlanAnnahmen { + stundensatz: Cent; + materialEinkauf: Cent; + materialAufschlag: number; + subEinkauf: Cent; + subAufschlag: number; + /** laufende Kosten je Monat ohne Personal (aus „Laufende Kosten“) */ + laufendMonat: Cent; + preissteigerung: number; + werbungMonat: Cent; + /** Abschreibungen auf das, was schon da ist, je Jahr */ + afaBisher: Cent; + /** Tilgung laufender Kredite je Monat */ + tilgungBisher: Cent; + /** Steuer-Vorauszahlungen je Quartal (März, Juni, September, Dezember) */ + steuerQuartal: Cent; + kontostandStart: Cent; + mindestgrenze: Cent; +} + +export interface PlanDaten { + mitarbeiter: PlanMitarbeiter[]; + investitionen: PlanInvestition[]; + annahmen: PlanAnnahmen; + /** Anteil am Jahresumsatz je Monat in % */ + saison: number[]; +} + +/** typisch für eine Zimmerei: ruhiger Winter, Saison Mai bis November (Entwurf) */ +export const SAISON_HANDWERK = [4, 4, 6, 8, 10, 10, 10, 10, 10, 10, 10, 8]; +export const SAISON_GLEICH = Array.from({ length: 12 }, () => 100 / 12); + +export const ZIEL_PERSONAL = 55; +export const ZIEL_GEWINN = 20; + +export function leererPlan(vorgaben: Partial = {}): PlanDaten { + return { + mitarbeiter: [], + investitionen: [], + annahmen: { + stundensatz: 6200, materialEinkauf: 0, materialAufschlag: 15, subEinkauf: 0, subAufschlag: 10, + laufendMonat: 0, preissteigerung: 3, werbungMonat: 0, afaBisher: 0, tilgungBisher: 0, steuerQuartal: 0, + kontostandStart: 0, mindestgrenze: 0, ...vorgaben, + }, + saison: [...SAISON_HANDWERK], + }; +} + +const MONATE = Array.from({ length: 12 }, (_, i) => i + 1); +const null12 = (): Cent[] => Array(12).fill(0); + +/** Betrag nach Gewichten auf 12 Monate, Summe bleibt genau (größter Rest) */ +export function verteile(betrag: Cent, gewichte: number[]): Cent[] { + const g = gewichte.map((x) => (Number.isFinite(x) && x > 0 ? x : 0)); + const s = g.reduce((a, b) => a + b, 0); + if (!s) return verteile(betrag, Array(12).fill(1)); + const roh = g.map((x) => (betrag * x) / s); + const teile = roh.map((x) => Math.floor(x)); + let rest = betrag - teile.reduce((a, b) => a + b, 0); + const reihenfolge = roh.map((x, i) => [x - Math.floor(x), i] as const).sort((a, b) => b[0] - a[0]); + for (let k = 0; rest > 0; k = (k + 1) % 12, rest--) teile[reihenfolge[k]![1]]! += 1; + return teile; +} + +export const aktiv = (m: PlanMitarbeiter, monat: number) => monat >= m.eintritt && monat <= m.austritt; +export const monateAktiv = (m: PlanMitarbeiter) => Math.max(0, Math.min(12, m.austritt) - Math.max(1, m.eintritt) + 1); +export const stundenImJahr = (m: PlanMitarbeiter) => Math.round((m.stunden * monateAktiv(m)) / 12); +export const personalMonat = (m: PlanMitarbeiter): Cent => (m.art === "inhaber" ? m.brutto : Math.round(m.brutto * m.faktor)); + +/** Annuität: gleiche Monatsrate aus Zins und Tilgung */ +export function annuitaet(betrag: Cent, zinsJahr: number, monate: number): Cent { + if (betrag <= 0 || monate <= 0) return 0; + const i = zinsJahr / 1200; + return Math.round(i ? (betrag * i) / (1 - (1 + i) ** -monate) : betrag / monate); +} + +export interface InvestitionImJahr { + /** was vom Konto geht: Kauf, Anzahlung, Kredit- oder Leasingrate */ + abfluss: Cent[]; + /** Kosten in der Treppe: Zinsen und Leasing */ + kosten: Cent[]; + afa: Cent[]; + /** Kreditrate bzw. Leasingrate je Monat (zur Anzeige) */ + rate: Cent; + afaJahr: Cent; +} + +export function investitionImJahr(v: PlanInvestition): InvestitionImJahr { + const abfluss = null12(), kosten = null12(), afa = null12(); + const m0 = Math.min(12, Math.max(1, v.monat)) - 1; + let rate = 0; + if (v.art === "kauf") abfluss[m0]! += v.betrag; + if (v.art === "kredit") { + abfluss[m0]! += v.anzahlung; + const kredit = Math.max(0, v.betrag - v.anzahlung); + rate = annuitaet(kredit, v.zins, v.laufzeit); + let rest = kredit; + for (let k = 1; k <= v.laufzeit && m0 + k < 12 && rest > 0; k++) { + const zins = Math.round((rest * v.zins) / 1200); + const zahlung = Math.min(rate, rest + zins); + abfluss[m0 + k]! += zahlung; + kosten[m0 + k]! += zins; + rest -= zahlung - zins; + } + } + if (v.art === "leasing") { + abfluss[m0]! += v.anzahlung; + rate = v.rate; + // Sonderzahlung verteilt über die Laufzeit als Kosten + const anteil = v.laufzeit > 0 ? Math.round(v.anzahlung / v.laufzeit) : v.anzahlung; + for (let k = 1; k <= v.laufzeit && m0 + k < 12; k++) { abfluss[m0 + k]! += v.rate; kosten[m0 + k]! += v.rate; } + for (let k = 0; k < v.laufzeit && m0 + k < 12; k++) kosten[m0 + k]! += anteil; + } + if (v.art !== "leasing" && v.nutzungsdauer > 0) { + const monatlich = v.betrag / (v.nutzungsdauer * 12); + // ab dem Monat der Anschaffung (monatsgenau wie im Steuerrecht), Summe kaufmännisch gerundet + const jahr = Math.round(monatlich * (12 - m0)); + verteile(jahr, MONATE.map((m) => (m - 1 >= m0 ? 1 : 0))).forEach((x, i) => (afa[i] = x)); + } + return { abfluss, kosten, afa, rate, afaJahr: afa.reduce((a, b) => a + b, 0) }; +} + +export type Ampel = "gruen" | "gelb" | "rot"; +export const ampelPersonal = (p: number): Ampel => (p <= ZIEL_PERSONAL ? "gruen" : p <= ZIEL_PERSONAL + 5 ? "gelb" : "rot"); +export const ampelGewinn = (p: number): Ampel => (p >= ZIEL_GEWINN ? "gruen" : p >= ZIEL_GEWINN - 5 ? "gelb" : "rot"); + +export interface Treppe { + stunden: number; + stundenUmsatz: Cent; + materialUmsatz: Cent; + subUmsatz: Cent; + umsatz: Cent; + wareneinsatz: Cent; + rohertrag: Cent; + personal: Cent; + unternehmerlohn: Cent; + werbung: Cent; + personalWerbung: Cent; + laufend: Cent; + afa: Cent; + gewinn: Cent; + /** in % vom Rohertrag */ + quotePersonal: number; + quoteLaufend: number; + quoteAfa: number; + quoteGewinn: number; + ampelPersonal: Ampel; + ampelGewinn: Ampel; + /** fehlender Gewinn bis 20 % vom Rohertrag (0 = Ziel erreicht) */ + luecke: Cent; +} + +/** Zeilen des Monatsplans, Ausgaben positiv */ +export interface Monate { + umsatz: Cent[]; + waren: Cent[]; + rohertrag: Cent[]; + personal: Cent[]; + unternehmerlohn: Cent[]; + werbung: Cent[]; + laufend: Cent[]; + investition: Cent[]; + steuer: Cent[]; + ueberschuss: Cent[]; + kontostand: Cent[]; + /** Kosten in der Treppe je Monat (laufend inkl. Zinsen und Leasing), für Plan/Ist */ + laufendKosten: Cent[]; + afa: Cent[]; + /** nur neue Mitarbeiter (Liquidität) */ + personalNeu: Cent[]; +} + +export interface Rechnung { + treppe: Treppe; + monate: Monate; + investitionen: (InvestitionImJahr & { id: string })[]; + /** knappster Monat (1–12) */ + tief: { monat: number; kontostand: Cent; abstand: Cent }; +} + +const quote = (x: Cent, basis: Cent) => (basis > 0 ? Math.round((x / basis) * 1000) / 10 : 0); + +export function rechne(d: PlanDaten): Rechnung { + const a = d.annahmen; + const stunden = d.mitarbeiter.reduce((s, m) => s + stundenImJahr(m), 0); + const stundenUmsatz = Math.round(stunden * a.stundensatz); + const materialUmsatz = Math.round(a.materialEinkauf * (1 + a.materialAufschlag / 100)); + const subUmsatz = Math.round(a.subEinkauf * (1 + a.subAufschlag / 100)); + const umsatz = stundenUmsatz + materialUmsatz + subUmsatz; + const wareneinsatz = a.materialEinkauf + a.subEinkauf; + + const personal = null12(), unternehmerlohn = null12(), personalNeu = null12(); + for (const m of d.mitarbeiter) { + for (const monat of MONATE) { + if (!aktiv(m, monat)) continue; + const k = personalMonat(m); + if (m.art === "inhaber") unternehmerlohn[monat - 1]! += k; + else personal[monat - 1]! += k; + if (m.neu) personalNeu[monat - 1]! += k; + } + } + const lfd = Math.round(a.laufendMonat * (1 + a.preissteigerung / 100)); + const investitionen = d.investitionen.map((v) => ({ id: v.id, ...investitionImJahr(v) })); + const afaBisher = verteile(a.afaBisher, Array(12).fill(1)); + const monate: Monate = { + umsatz: verteile(umsatz, d.saison), + waren: verteile(wareneinsatz, d.saison), + rohertrag: [], personal, unternehmerlohn, personalNeu, + werbung: Array(12).fill(a.werbungMonat), + laufend: Array(12).fill(lfd), + investition: MONATE.map((m) => a.tilgungBisher + investitionen.reduce((s, v) => s + v.abfluss[m - 1]!, 0)), + steuer: MONATE.map((m) => (m % 3 === 0 ? a.steuerQuartal : 0)), + laufendKosten: MONATE.map((m) => lfd + investitionen.reduce((s, v) => s + v.kosten[m - 1]!, 0)), + afa: MONATE.map((m) => afaBisher[m - 1]! + investitionen.reduce((s, v) => s + v.afa[m - 1]!, 0)), + ueberschuss: [], kontostand: [], + }; + let stand = a.kontostandStart; + for (let i = 0; i < 12; i++) { + monate.rohertrag[i] = monate.umsatz[i]! - monate.waren[i]!; + monate.ueberschuss[i] = monate.rohertrag[i]! - personal[i]! - unternehmerlohn[i]! - monate.werbung[i]! - monate.laufend[i]! - monate.investition[i]! - monate.steuer[i]!; + stand += monate.ueberschuss[i]!; + monate.kontostand[i] = stand; + } + const s = (x: Cent[]) => x.reduce((p, q) => p + q, 0); + const rohertrag = umsatz - wareneinsatz; + const personalSumme = s(personal) + s(unternehmerlohn); + const werbung = s(monate.werbung); + const laufend = s(monate.laufendKosten); + const afa = s(monate.afa); + const gewinn = rohertrag - personalSumme - werbung - laufend - afa; + const quotePersonal = quote(personalSumme + werbung, rohertrag); + const quoteGewinn = quote(gewinn, rohertrag); + let ti = 0; + monate.kontostand.forEach((k, i) => { if (k < monate.kontostand[ti]!) ti = i; }); + return { + treppe: { + stunden, stundenUmsatz, materialUmsatz, subUmsatz, umsatz, wareneinsatz, rohertrag, + personal: s(personal), unternehmerlohn: s(unternehmerlohn), werbung, personalWerbung: personalSumme + werbung, + laufend, afa, gewinn, quotePersonal, quoteLaufend: quote(laufend, rohertrag), quoteAfa: quote(afa, rohertrag), quoteGewinn, + ampelPersonal: ampelPersonal(quotePersonal), ampelGewinn: ampelGewinn(quoteGewinn), + luecke: Math.max(0, Math.ceil((rohertrag * ZIEL_GEWINN) / 100) - gewinn), + }, + monate, + investitionen, + tief: { monat: ti + 1, kontostand: monate.kontostand[ti]!, abstand: monate.kontostand[ti]! - a.mindestgrenze }, + }; +} + +export interface Vorschlag { + id: string; + text: string; + /** Gewinn danach minus Gewinn vorher */ + mehrGewinn: Cent; + name: string; + daten: PlanDaten; +} + +const kopie = (d: PlanDaten): PlanDaten => JSON.parse(JSON.stringify(d)); +const euroGanz = (c: Cent) => `${Math.round(c / 100).toLocaleString("de-DE")} €`; + +/** + * Was die Lücke zum Gewinnziel schließen würde, jeweils allein: Stundensatz, Material- oder Sub-Aufschlag. + * Mehr Umsatz hebt auch den Rohertrag und damit das Ziel, deshalb wird mit dem neuen Plan nachgerechnet. + */ +export function vorschlaege(d: PlanDaten): Vorschlag[] { + const r = rechne(d); + if (r.treppe.luecke <= 0) return []; + const a = d.annahmen; + const aus: Vorschlag[] = []; + const reicht = (x: PlanDaten) => rechne(x).treppe.luecke <= 0; + const suche = (start: number, schritt: number, setze: (x: PlanDaten, w: number) => void, max = 400): number | null => { + for (let w = start + schritt, i = 0; i < max; w += schritt, i++) { + const x = kopie(d); + setze(x, w); + if (reicht(x)) return w; + } + return null; + }; + if (r.treppe.stunden > 0) { + const satz = suche(Math.ceil(a.stundensatz / 100) * 100, 100, (x, w) => (x.annahmen.stundensatz = w)); + if (satz !== null) { + const x = kopie(d); + x.annahmen.stundensatz = satz; + aus.push({ id: "satz", text: `Stundensatz ${euroGanz(a.stundensatz)} → ${euroGanz(satz)}`, name: `Stundensatz ${euroGanz(satz)}`, mehrGewinn: rechne(x).treppe.gewinn - r.treppe.gewinn, daten: x }); + } + } + if (a.materialEinkauf > 0) { + const p = suche(Math.ceil(a.materialAufschlag), 1, (x, w) => (x.annahmen.materialAufschlag = w), 200); + if (p !== null) { + const x = kopie(d); + x.annahmen.materialAufschlag = p; + aus.push({ id: "material", text: `Material-Aufschlag ${a.materialAufschlag} → ${p} %`, name: `Material +${p} %`, mehrGewinn: rechne(x).treppe.gewinn - r.treppe.gewinn, daten: x }); + } + } + if (a.subEinkauf > 0) { + const p = suche(Math.ceil(a.subAufschlag), 1, (x, w) => (x.annahmen.subAufschlag = w), 200); + if (p !== null) { + const x = kopie(d); + x.annahmen.subAufschlag = p; + aus.push({ id: "sub", text: `Sub-Aufschlag ${a.subAufschlag} → ${p} %`, name: `Sub +${p} %`, mehrGewinn: rechne(x).treppe.gewinn - r.treppe.gewinn, daten: x }); + } + } + return aus; +} + +const MONAT_KURZ = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"]; + +/** Satz zum knappsten Monat und was ihn verursacht, wie in der Liquidität */ +export function knappText(d: PlanDaten, r: Rechnung): { satz: string; grund: string } { + const { monat, kontostand, abstand } = r.tief; + const name = MONAT_KURZ[monat - 1]!; + const satz = abstand >= 0 + ? `Am knappsten wird es Ende ${name} mit ${euroGanz(kontostand)}, ${euroGanz(abstand)} über deiner Mindestgrenze.` + : `Ende ${name} liegt der Kontostand bei ${euroGanz(kontostand)}, ${euroGanz(-abstand)} unter deiner Mindestgrenze.`; + const gruende: string[] = []; + const neue = d.mitarbeiter.filter((m) => m.art === "angestellt" && m.eintritt > 1 && m.eintritt <= monat); + if (neue.length) gruende.push(`${neue.map((m) => m.name).join(" und ")} ${neue.length > 1 ? "fangen" : "fängt"} an`); + const inv = d.investitionen.filter((v) => v.monat <= monat && v.monat >= monat - 2 && (v.art === "kauf" ? v.betrag : v.anzahlung) > 0); + if (inv.length) gruende.push(`${inv.map((v) => v.name).join(" und ")} ${v1(inv.length)} ${inv.some((v) => v.art === "kauf") ? "bezahlt" : "angezahlt"}`); + const saisonBis = d.saison.slice(0, monat); + const schnitt = d.saison.reduce((x, y) => x + y, 0) / 12; + if (saisonBis.at(-1)! < schnitt) gruende.push(`der Umsatz liegt bis dahin bei nur ${Math.round(Math.min(...saisonBis))}–${Math.round(Math.max(...saisonBis))} % je Monat`); + if (monat % 3 === 0 && d.annahmen.steuerQuartal > 0) gruende.push(`die Steuer-Vorauszahlung ist fällig`); + return { satz, grund: gruende.length ? `Grund: ${gruende.join(", ")}.` : "" }; +} +const v1 = (n: number) => (n > 1 ? "werden" : "wird"); + +/** Plan-Zeilen, denen die BWA-Zeilen zugeordnet werden */ +export const PLANZEILEN = ["umsatz", "material", "personal", "unternehmerlohn", "werbung", "laufend", "afa", "tilgung", "investition", "steuer"] as const; +export type Planzeile = (typeof PLANZEILEN)[number] | "ignorieren"; +export const PLANZEILE_TEXT: Record = { + umsatz: "Umsatz", material: "Material und Subunternehmer", personal: "Personal (Löhne)", unternehmerlohn: "Unternehmerlohn (Privatentnahmen)", + werbung: "Werbung", laufend: "Laufende Kosten", afa: "Abschreibungen", tilgung: "Tilgung", investition: "Investitionen", + steuer: "Steuer-Vorauszahlungen", ignorieren: "nicht im Plan (Steuer, Durchlauf, Summe)", +}; + +/** Planwerte eines Monats (oder kumuliert bis zum Monat) je Planzeile, Kosten positiv */ +export function planWerte(r: Rechnung, monat: number, kumuliert: boolean): Record<(typeof PLANZEILEN)[number], Cent> { + const von = kumuliert ? 0 : monat - 1; + const s = (x: Cent[]) => x.slice(von, monat).reduce((a, b) => a + b, 0); + const m = r.monate; + const investition = r.investitionen.reduce((t, v) => t + v.abfluss.slice(von, monat).reduce((a, b) => a + b, 0), 0); + return { + umsatz: s(m.umsatz), material: s(m.waren), personal: s(m.personal), unternehmerlohn: s(m.unternehmerlohn), werbung: s(m.werbung), + laufend: s(m.laufendKosten), afa: s(m.afa), tilgung: s(m.investition) - investition, investition, steuer: s(m.steuer), + }; +} + +/** + * Vorschau für die Liquidität (Henning, Entwurf „12 Monate“): ab dem nächsten Monat zählt der Plan, soweit echte + * Zahlungen fehlen. Einnahmen und Material/Sub nur der Rest über den echten Posten des Monats; dazu Löhne neuer + * Mitarbeiter, neue Investitionen und Steuer-Vorauszahlungen. Laufende Kosten stehen schon echt in der Liquidität. + * Plan-Werte sind netto; echte Posten werden dafür um die Umsatzsteuer bereinigt. + */ +export function planPosten(alle: Posten[], plaene: { jahr: number; daten: PlanDaten }[], heute: string, ustSatz: number): Posten[] { + const aus: Posten[] = []; + const ab = heute.slice(0, 7); + const netto = (b: number) => Math.round(b / (1 + ustSatz / 100)); + for (const p of plaene) { + const r = rechne(p.daten); + for (let i = 0; i < 12; i++) { + const monat = `${p.jahr}-${String(i + 1).padStart(2, "0")}`; + if (monat <= ab) continue; + const datum = `${monat}-15`, name = `${MONAT_KURZ[i]} ${p.jahr}`; + const imMonat = alle.filter((x) => x.datum.startsWith(monat)); + const ein = imMonat.filter((x) => x.gruppe === "Projekteinnahmen").reduce((s, x) => s + netto(x.betrag), 0); + const kosten = -imMonat.filter((x) => x.gruppe === "Projektkosten").reduce((s, x) => s + netto(x.betrag), 0); + const plus = (bezeichnung: string, betrag: number) => { if (betrag) aus.push({ datum, gruppe: "Jahresplan", bezeichnung, betrag }); }; + plus(`Plan: weitere Einnahmen ${name}`, Math.max(0, r.monate.umsatz[i]! - ein)); + plus(`Plan: Material und Sub ${name}`, -Math.max(0, r.monate.waren[i]! - kosten)); + plus(`Plan: Löhne neue Mitarbeiter ${name}`, -r.monate.personalNeu[i]!); + plus(`Plan: Investitionen ${name}`, -r.investitionen.reduce((s, v) => s + v.abfluss[i]!, 0)); + plus(`Plan: Steuer-Vorauszahlung ${name}`, -r.monate.steuer[i]!); + } + } + return aus; +} diff --git a/src/domain/liquiditaet.ts b/src/domain/liquiditaet.ts index 5e6bf93..37fb5fc 100644 --- a/src/domain/liquiditaet.ts +++ b/src/domain/liquiditaet.ts @@ -11,7 +11,7 @@ import { type Datum, plusTage, plusMonate, montagDerWoche, monatsErster } from " import { type Cent, ustAusNetto, summe, prozentVon } from "./geld.js"; import { type UstEinstellungen, STANDARD_UST, zeitraumVon, faelligkeit } from "./umsatzsteuer.js"; -export type Gruppe = "Projekteinnahmen" | "Projektkosten" | "Laufende Kosten" | "Umsatzsteuer"; +export type Gruppe = "Projekteinnahmen" | "Projektkosten" | "Laufende Kosten" | "Umsatzsteuer" | "Jahresplan"; export type Kostenart = "material" | "fremd" | "sonstiges"; export type Rhythmus = "einmalig" | "monatlich" | "vierteljaehrlich" | "jaehrlich"; @@ -72,6 +72,8 @@ export interface Vorschau { * ersten Zeitraum, kommen sie heute in die Rechnung (das Geld steht ja noch aus), höchstens ein Jahr zurück. */ offeneAb?: Datum; + /** weitere Posten aus allen Bewegungen, z. B. die Vorschau aus dem Jahresplan (Stufe 5) */ + ergaenzen?: (alle: Posten[]) => Posten[]; } export interface Posten { @@ -240,6 +242,7 @@ export function liquiditaet(d: Daten, v: Vorschau): Periode[] { if (p.datum < erster) p.datum = heute; } } + if (v.ergaenzen) alle.push(...v.ergaenzen(alle)); let kontostand = v.startsaldo; return grenzen.map(({ von, bis }) => { const posten = alle.filter((p) => p.datum >= von && p.datum <= bis).sort((a, b) => a.datum.localeCompare(b.datum)); diff --git a/src/server/anmeldung.ts b/src/server/anmeldung.ts index de05c75..77de075 100644 --- a/src/server/anmeldung.ts +++ b/src/server/anmeldung.ts @@ -39,7 +39,8 @@ function recht(methode: string, muster: string | undefined, url: string): Recht const k = `${methode} ${muster ?? ""}`; if (OFFEN.has(k)) return "offen"; if (muster?.startsWith("/api/ich/") || muster === "/api/ich" || ALLE.has(k)) return "alle"; - if (muster?.startsWith("/api/benutzer") || INHABER.has(k)) return "inhaber"; + // Jahresplan und BWA (Stufe 5) nur für den Inhaber + if (muster?.startsWith("/api/benutzer") || muster?.startsWith("/api/jahresplan") || muster?.startsWith("/api/bwa") || muster?.startsWith("/api/finanzmonat") || INHABER.has(k)) return "inhaber"; return muster ? "buero" : "inhaber"; } diff --git a/src/server/app.ts b/src/server/app.ts index 06abd30..023aa0d 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -28,6 +28,8 @@ import { registriereUrlaub, zeitraumText } from "./urlaub.js"; import { vorlageAnwenden } from "./vorlage.js"; import { AngebotFehler, pruefeBearbeitbar, registriereAngebote } from "./angebote.js"; import { registriereStammdaten } from "./stammdaten.js"; +import { finanzsitzungAnlegen, geltendePlaene, jahresplanStand, registriereJahresplan } from "./jahresplan.js"; +import { planPosten } from "../domain/jahresplan.js"; import { type BezugArt, bezugsTage } from "../domain/bezug.js"; import { formatDatum, plusTage } from "../domain/datum.js"; @@ -96,6 +98,7 @@ export async function baueApp(o: Optionen): Promise { registriereAngebote(app, pool, ladeEinstellungen, mitOrdner); registriereStammdaten(app, pool, ladeEinstellungen); + registriereJahresplan(app, pool, { einstellungen: ladeEinstellungen, liquiDaten: () => liquiDaten() }); app.post("/api/projekte/:id/ordner", async (req, reply) => { const { id } = IdParam.parse(req.params); @@ -310,7 +313,8 @@ export async function baueApp(o: Optionen): Promise { offene: z.enum(["0", "1"]).optional(), }); - async function berechneLiquiditaet(q: z.infer) { + /** Projekte, Zahlungen, Kosten und laufende Kosten für die Liquidität */ + async function liquiDaten() { const e = await ladeEinstellungen(); const [projekte, vorgaenge, zahlungen, kosten, laufend] = await Promise.all([ pool.query("select * from projekt"), @@ -319,7 +323,7 @@ export async function baueApp(o: Optionen): Promise { pool.query("select * from kosten"), pool.query("select * from laufende_kosten"), ]); - const daten = liquiditaetsDaten( + return liquiditaetsDaten( { projekte: projekte.rows, vorgaenge: vorgaenge.rows, @@ -331,9 +335,18 @@ export async function baueApp(o: Optionen): Promise { }, { tage: e.arbeitstage }, ); + } + + async function berechneLiquiditaet(q: z.infer) { + const e = await ladeEinstellungen(); + const daten = await liquiDaten(); const start = q.start ?? new Date().toISOString().slice(0, 10); + // Stufe 5: der geltende Jahresplan als Vorschau, wo echte Zahlungen fehlen + const jahr = Number(start.slice(0, 4)); + const plaene = e.jahresplanVorschau ? await geltendePlaene(pool, jahr, jahr + 3) : []; return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust, - offeneAb: q.offene === "1" ? start : undefined }); + offeneAb: q.offene === "1" ? start : undefined, + ergaenzen: plaene.length ? (alle) => planPosten(alle, plaene, new Date().toISOString().slice(0, 10), e.ust.satz) : undefined }); } app.get("/api/liquiditaet", async (req) => berechneLiquiditaet(LiquiAnfrage.parse(req.query))); @@ -349,7 +362,7 @@ export async function baueApp(o: Optionen): Promise { const mindestgrenze = e.mindestgrenzeArt === "fest" ? e.mindestreserve : laufendMonat; return { heute, wochen, kontostand: e.startsaldo, kontostandDatum: e.startsaldoDatum, - mindestgrenze, mindestgrenzeArt: e.mindestgrenzeArt, festerBetrag: e.mindestreserve, laufendMonat, + mindestgrenze, mindestgrenzeArt: e.mindestgrenzeArt, festerBetrag: e.mindestreserve, laufendMonat, jahresplanVorschau: e.jahresplanVorschau, lage: lage(wochen, e.startsaldo, mindestgrenze), }; } @@ -363,16 +376,19 @@ export async function baueApp(o: Optionen): Promise { const heute = z.object({ heute: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional() }).parse(req.query).heute ?? new Date().toISOString().slice(0, 10); const e = await ladeEinstellungen(); const woche = { tage: e.arbeitstage }; - const [tp, aufgaben, liqui] = await Promise.all([ + // Stufe 5: Finanzsitzung am ersten Freitag im Monat, sobald es einen Jahresplan gibt + if (e.finanzsitzung) await transaktion(pool, benutzer(req), (c) => finanzsitzungAnlegen(c, heute)); + const [tp, aufgaben, liqui, jahresplan] = await Promise.all([ terminplan(pool, woche, e.stundenProTag), pool.query(`select a.*, p.nummer as projekt_nummer, p.bezeichnung as projekt_name, k.name as kontakt_name, g.name as kategorie from aufgabe a left join projekt p on p.id = a.projekt_id left join kontakt k on k.id = a.kontakt_id left join aufgabe_kategorie g on g.id = a.kategorie_id where a.erledigt_am is null order by a.faellig_am nulls last, a.angelegt_am`), liquiLage(heute, 4), + req.wer?.rolle === "inhaber" ? jahresplanStand(pool, liquiDaten, heute) : null, ]); const u = { ...uebersicht({ heute, woche, tp, aufgaben: aufgaben.rows, liqui: liqui.wochen, mindestreserve: liqui.mindestgrenze, - kontostandErfasst: e.startsaldo !== 0 || e.startsaldoDatum !== null }), liquiLage: { ...liqui, wochen: undefined } }; + kontostandErfasst: e.startsaldo !== 0 || e.startsaldoDatum !== null }), liquiLage: { ...liqui, wochen: undefined }, jahresplan }; // M10: offene Urlaubsanträge oben in den Warnungen, damit kein Mitarbeiter auf Antwort wartet const antraege = await pool.query(`select a.von, a.bis, a.kontakt_id, k.name from abwesenheit a join kontakt k on k.id = a.kontakt_id where a.art = 'urlaub' and a.status = 'beantragt' order by a.von`); diff --git a/src/server/einstellungen.ts b/src/server/einstellungen.ts index 019bf5d..1fb7c93 100644 --- a/src/server/einstellungen.ts +++ b/src/server/einstellungen.ts @@ -47,6 +47,10 @@ export const EinstellungenSchema = z.object({ mindestreserve: z.number().int().default(0), // Mindestgrenze der Liquidität (Henning, 21.10.2026): automatisch ein Monat laufende Kosten oder fest der Betrag oben mindestgrenzeArt: z.enum(["auto", "fest"]).default("auto"), + // Stufe 5: der geltende Jahresplan zählt in der Liquidität als Vorschau, wo echte Zahlungen fehlen + jahresplanVorschau: z.boolean().default(true), + // Finanzsitzung am ersten Freitag im Monat als Aufgabe, sobald es einen Jahresplan gibt + finanzsitzung: z.boolean().default(true), // M3: immer voll abziehen (6:10 → 5:40, Henning 20.10.2026) oder knapp über einer Grenze nur bis zur Grenze (6:10 → 6:00) pausenabzug: z.enum(["bis_grenze", "voll"]).default("voll"), // geheimer Teil der Kalender-Links (T11); Outlook classic kann sich nicht anmelden diff --git a/src/server/jahresplan.ts b/src/server/jahresplan.ts new file mode 100644 index 0000000..47997bc --- /dev/null +++ b/src/server/jahresplan.ts @@ -0,0 +1,305 @@ +// Jahresfinanzplanung und BWA (Stufe 5, Henning 21.10.2026). Nur für den Inhaber (Rollen im Heft). +// Ein Jahr hat Versionen: die Basis bleibt, eine Version „gilt“ und speist Liquidität, Übersicht und Plan/Ist. +import type { FastifyInstance, FastifyRequest } from "fastify"; +import { z } from "zod"; +import { type Client, type Pool, transaktion } from "./db.js"; +import type { Einstellungen } from "./einstellungen.js"; +import { werName } from "./anmeldung.js"; +import { type PlanDaten, PLANZEILEN, type Planzeile, SAISON_HANDWERK, leererPlan, rechne, vorschlaege, knappText } from "../domain/jahresplan.js"; +import { BwaFehler, istWerte, liesBwa, planIst, zuordnungVorschlag } from "../domain/bwa.js"; +import type { Daten, LaufendeKosten } from "../domain/liquiditaet.js"; +import { laufendJeMonat } from "../domain/lage.js"; +import { type Datum, plusTage, wochentag } from "../domain/datum.js"; + +const cent = z.number().int().min(0).max(10_000_000_000); +const monat = z.number().int().min(1).max(12); +const PlanSchema = z.object({ + mitarbeiter: z.array(z.object({ + id: z.string().min(1).max(40), name: z.string().trim().min(1).max(100), art: z.enum(["inhaber", "angestellt"]), + stunden: z.number().min(0).max(4000), brutto: cent, faktor: z.number().min(1).max(3).default(1.25), + eintritt: monat.default(1), austritt: monat.default(12), neu: z.boolean().default(false), + })).max(50).default([]), + investitionen: z.array(z.object({ + id: z.string().min(1).max(40), name: z.string().trim().min(1).max(100), betrag: cent, monat: monat.default(1), + art: z.enum(["kauf", "kredit", "leasing"]).default("kauf"), anzahlung: cent.default(0), laufzeit: z.number().int().min(0).max(360).default(60), + zins: z.number().min(0).max(30).default(5), rate: cent.default(0), nutzungsdauer: z.number().min(0).max(50).default(6), + })).max(50).default([]), + annahmen: z.object({ + stundensatz: cent, materialEinkauf: cent, materialAufschlag: z.number().min(0).max(500), subEinkauf: cent, subAufschlag: z.number().min(0).max(500), + laufendMonat: cent, preissteigerung: z.number().min(-50).max(100), werbungMonat: cent, afaBisher: cent, tilgungBisher: cent, steuerQuartal: cent, + kontostandStart: z.number().int().min(-10_000_000_000).max(10_000_000_000), mindestgrenze: cent, + }), + saison: z.array(z.number().min(0).max(100)).length(12), +}); + +const Jahr = z.coerce.number().int().min(2000).max(2100); + +/** erster Freitag eines Monats */ +export function ersterFreitag(jahr: number, m: number): Datum { + const erster = `${jahr}-${String(m).padStart(2, "0")}-01`; + return plusTage(erster, (5 - wochentag(erster) + 7) % 7); +} + +const MONATSNAMEN = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"]; + +/** + * Finanzsitzung als wiederkehrende Aufgabe (Roos: monatlich, Henning: erster Freitag = Bürotag). Das Programm legt + * sie für den laufenden Monat an, sobald es einen Jahresplan gibt; erledigt oder gelöscht bleibt sie für diesen Monat weg. + */ +export async function finanzsitzungAnlegen(c: Client | Pool, heute: Datum): Promise { + if (!(await c.query("select 1 from jahresplan limit 1")).rowCount) return; + const jahr = Number(heute.slice(0, 4)), m = Number(heute.slice(5, 7)); + const serie = `finanzsitzung-${heute.slice(0, 7)}`; + const vor = m === 1 ? { m: 12, j: jahr - 1 } : { m: m - 1, j: jahr }; + // eine gelöschte Aufgabe nicht wieder anlegen: der Monat steht dann im Protokoll + if ((await c.query("select 1 from protokoll where tabelle = 'aufgabe' and aktion = 'loeschen' and vorher->>'serie' = $1 limit 1", [serie])).rowCount) return; + await c.query(`insert into aufgabe (text, faellig_am, serie) values ($1, $2, $3) on conflict (serie) do nothing`, + [`Finanzsitzung: BWA ${MONATSNAMEN[vor.m - 1]} ${vor.j} durchgehen (Jahresplanung → Plan / Ist)`, ersterFreitag(jahr, m), serie]); +} + +interface Hilfen { + einstellungen: () => Promise; + /** Projekte, Zahlungen und Kosten wie in der Liquidität */ + liquiDaten: () => Promise; +} + +export function registriereJahresplan(app: FastifyInstance, pool: Pool, h: Hilfen): void { + const wer = (req: FastifyRequest) => werName(req); + const heute = () => new Date().toISOString().slice(0, 10); + + async function laufend(): Promise { + return (await pool.query("select bezeichnung, kategorie, betrag, rhythmus, start, ende from laufende_kosten")).rows + .map((l) => ({ bezeichnung: l.bezeichnung, kategorie: l.kategorie ?? undefined, betrag: Number(l.betrag), rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined })); + } + + /** Was der Plan aus dem Programm übernehmen kann: laufende Kosten (Personal getrennt), Kontostand, Mindestgrenze, BWA des Vorjahres */ + async function vorlagen(jahr: number) { + const e = await h.einstellungen(); + const lk = await laufend(); + // im Planjahr laufende Posten, jeder Rhythmus auf den Monat umgerechnet (einmalige zählen nicht) + const imJahr = (k: LaufendeKosten) => k.rhythmus !== "einmalig" && k.start <= `${jahr}-12-31` && (!k.ende || k.ende >= `${jahr}-01-01`); + const jeMonat = (k: LaufendeKosten) => (imJahr(k) ? Math.round(k.betrag / ({ monatlich: 1, vierteljaehrlich: 3, jaehrlich: 12, einmalig: 1 } as const)[k.rhythmus]) : 0); + const istPersonal = (k: LaufendeKosten) => /personal|lohn|gehalt/i.test(`${k.kategorie ?? ""} ${k.bezeichnung}`); + const posten = lk.filter(imJahr).map((k) => ({ bezeichnung: k.bezeichnung, kategorie: k.kategorie ?? "", monat: jeMonat(k), personal: istPersonal(k) })); + const ohnePersonal = posten.filter((k) => !k.personal).reduce((x, k) => x + k.monat, 0); + const personal = posten.filter((k) => k.personal).reduce((x, k) => x + k.monat, 0); + const mindestgrenze = e.mindestgrenzeArt === "fest" ? e.mindestreserve : laufendJeMonat(lk, heute()); + // BWA des Vorjahres: jüngster Monat mit kumulierten Werten, aufs Jahr hochgerechnet + const zu = await zuordnung(); + const vj = (await pool.query("select monat, zeilen from finanz_monat where jahr = $1 and zeilen is not null order by monat desc limit 1", [jahr - 1])).rows[0]; + let vorjahr = null; + if (vj) { + const ist = istWerte(vj.zeilen, zu, true); + const f = 12 / vj.monat; + vorjahr = { monate: vj.monat, umsatz: Math.round(ist.umsatz! * f), material: Math.round(ist.material! * f), laufendMonat: Math.round((ist.laufend! / vj.monat)), + werbungMonat: Math.round(ist.werbung! / vj.monat), afa: Math.round(ist.afa! * f), tilgungMonat: Math.round(ist.tilgung! / vj.monat), + steuerQuartal: Math.round((ist.steuer! / vj.monat) * 3), unternehmerlohnMonat: Math.round(ist.unternehmerlohn! / vj.monat) }; + } + // Saison aus dem Vorjahr: Erlöse je Monat aus den eingelesenen BWA (Monatswerte) + const monate = (await pool.query("select monat, zeilen from finanz_monat where jahr = $1 and zeilen is not null order by monat", [jahr - 1])).rows; + const saisonVorjahr = monate.map((r) => ({ monat: r.monat as number, umsatz: istWerte(r.zeilen, zu, false).umsatz! })); + const personalListe = (await pool.query(`select k.name, m.angestellt, m.lohn_cent, m.eintritt, m.austritt from mitarbeiter m join kontakt k on k.id = m.kontakt_id + where m.austritt is null or m.austritt >= $1 order by m.angestellt, k.name`, [`${jahr}-01-01`])).rows; + return { laufend: { ohnePersonal, personal, posten }, kontostand: e.startsaldo, mindestgrenze, vorjahr, saisonVorjahr, personal: personalListe, + stundensatzEk: e.kalkulation.stundensaetze.geselle }; + } + + async function zuordnung(): Promise> { + return new Map((await pool.query("select zeile, planzeile from bwa_zuordnung")).rows.map((r) => [r.zeile as number, r.planzeile as Planzeile])); + } + + /** neuer Plan: Annahmen aus laufenden Kosten, Kontostand, Mindestgrenze und, wenn da, der BWA des Vorjahres */ + async function startPlan(jahr: number): Promise { + const v = await vorlagen(jahr); + const d = leererPlan({ + laufendMonat: v.laufend.ohnePersonal, kontostandStart: v.kontostand, mindestgrenze: v.mindestgrenze, + ...(v.vorjahr ? { materialEinkauf: v.vorjahr.material, werbungMonat: v.vorjahr.werbungMonat, afaBisher: v.vorjahr.afa, + tilgungBisher: v.vorjahr.tilgungMonat, steuerQuartal: v.vorjahr.steuerQuartal } : {}), + }); + d.mitarbeiter.push({ id: "inhaber", name: "Inhaber", art: "inhaber", stunden: 900, brutto: v.laufend.personal || v.vorjahr?.unternehmerlohnMonat || 0, faktor: 1, eintritt: 1, austritt: 12, neu: false }); + v.personal.filter((p) => p.angestellt).forEach((p, i) => { + const ein = p.eintritt && p.eintritt.slice(0, 4) === String(jahr) ? Number(p.eintritt.slice(5, 7)) : 1; + const aus = p.austritt && p.austritt.slice(0, 4) === String(jahr) ? Number(p.austritt.slice(5, 7)) : 12; + // Stundenlohn aus Personal × 173 Stunden im Monat + d.mitarbeiter.push({ id: `m${i + 1}`, name: p.name, art: "angestellt", stunden: 1400, brutto: Math.round(Number(p.lohn_cent ?? 0) * 173), faktor: 1.25, eintritt: ein, austritt: aus, neu: false }); + }); + if (v.saisonVorjahr.length === 12) d.saison = saisonAus(v.saisonVorjahr.map((x) => x.umsatz)); + return d; + } + + const zeile = (r: Record) => ({ id: r.id, jahr: r.jahr, name: r.name, basis: r.basis, gilt: r.gilt, daten: r.daten as PlanDaten, geaendert_am: r.geaendert_am }); + + const beauftragt = async (jahr: number) => beauftragtJeMonat(await h.liquiDaten(), jahr); + + app.get("/api/jahresplan", async (req) => { + const q = z.object({ jahr: Jahr.optional() }).parse(req.query); + const jahre = (await pool.query("select distinct jahr from jahresplan order by jahr")).rows.map((r) => r.jahr as number); + const jetzt = Number(heute().slice(0, 4)); + // ohne Angabe: das nächste Jahr ab Oktober, sonst das laufende + const jahr = q.jahr ?? (jahre.includes(jetzt) && heute().slice(5, 7) < "10" ? jetzt : jahre.find((j) => j > jetzt) ?? (heute().slice(5, 7) >= "10" ? jetzt + 1 : jetzt)); + await finanzsitzungAnlegen(pool, heute()); + const versionen = (await pool.query("select * from jahresplan where jahr = $1 order by basis desc, angelegt_am", [jahr])).rows.map(zeile); + return { jahr, jahre, versionen, vorlagen: await vorlagen(jahr), beauftragt: await beauftragt(jahr) }; + }); + + app.post("/api/jahresplan", async (req, reply) => { + const q = z.object({ jahr: Jahr, name: z.string().trim().min(1).max(80).optional(), von: z.uuid().optional(), daten: PlanSchema.optional() }).parse(req.body); + const daten = q.daten ?? (q.von ? (await pool.query("select daten from jahresplan where id = $1", [q.von])).rows[0]?.daten : await startPlan(q.jahr)); + if (!daten) return reply.status(404).send({ fehler: "Version nicht gefunden" }); + const neu = await transaktion(pool, wer(req), async (c) => { + const erste = !(await c.query("select 1 from jahresplan where jahr = $1", [q.jahr])).rowCount; + const r = (await c.query("insert into jahresplan (jahr, name, basis, gilt, daten) values ($1, $2, $3, $3, $4) returning *", + [q.jahr, q.name ?? (erste ? "Basis" : "Neue Version"), erste, PlanSchema.parse(daten)])).rows[0]; + await finanzsitzungAnlegen(c, heute()); + return r; + }); + return reply.status(201).send(zeile(neu)); + }); + + app.patch("/api/jahresplan/:id", async (req, reply) => { + const { id } = z.object({ id: z.uuid() }).parse(req.params); + const q = z.object({ name: z.string().trim().min(1).max(80).optional(), daten: PlanSchema.optional(), gilt: z.literal(true).optional() }).parse(req.body); + const r = await transaktion(pool, wer(req), async (c) => { + const alt = (await c.query("select * from jahresplan where id = $1", [id])).rows[0]; + if (!alt) return null; + if (q.gilt) await c.query("update jahresplan set gilt = false where jahr = $1 and gilt and id <> $2", [alt.jahr, id]); + return (await c.query("update jahresplan set name = coalesce($2, name), daten = coalesce($3, daten), gilt = gilt or coalesce($4, false) where id = $1 returning *", + [id, q.name ?? null, q.daten ?? null, q.gilt ?? null])).rows[0]; + }); + return r ? zeile(r) : reply.status(404).send({ fehler: "Nicht gefunden" }); + }); + + app.delete("/api/jahresplan/:id", async (req, reply) => { + const { id } = z.object({ id: z.uuid() }).parse(req.params); + const r = await transaktion(pool, wer(req), async (c) => { + const alt = (await c.query("select * from jahresplan where id = $1", [id])).rows[0]; + if (!alt) return 404; + if (alt.basis) return 409; + await c.query("delete from jahresplan where id = $1", [id]); + if (alt.gilt) await c.query("update jahresplan set gilt = true where jahr = $1 and basis", [alt.jahr]); + return 204; + }); + if (r === 409) return reply.status(409).send({ fehler: "Die Basis bleibt immer erhalten." }); + return r === 204 ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" }); + }); + + /** Vorschläge, um die Lücke zum Gewinnziel zu schließen; ein Klick legt die Version an */ + app.get("/api/jahresplan/:id/vorschlaege", async (req, reply) => { + const { id } = z.object({ id: z.uuid() }).parse(req.params); + const p = (await pool.query("select daten from jahresplan where id = $1", [id])).rows[0]; + if (!p) return reply.status(404).send({ fehler: "Nicht gefunden" }); + return vorschlaege(PlanSchema.parse(p.daten)).map(({ daten: _, ...v }) => v); + }); + + // ---------- BWA und Plan/Ist ---------- + + app.post("/api/bwa", async (req, reply) => { + const q = z.object({ dateiname: z.string().max(200).default(""), inhalt: z.string().min(1).max(20_000_000) }).parse(req.body); + let b; + try { b = liesBwa(q.inhalt); } catch (err) { + if (err instanceof BwaFehler) return reply.status(400).send({ fehler: err.message }); + throw err; + } + const neu = await transaktion(pool, wer(req), async (c) => { + await c.query(`insert into finanz_monat (jahr, monat, dateiname, bwa_art, eingelesen_am, zeilen) values ($1, $2, $3, $4, now(), $5) + on conflict (jahr, monat) do update set dateiname = $3, bwa_art = $4, eingelesen_am = now(), zeilen = $5`, + [b.jahr, b.monat, q.dateiname, b.art, JSON.stringify(b.zeilen)]); + const da = new Set((await c.query("select zeile from bwa_zuordnung")).rows.map((r) => r.zeile as number)); + const neue = []; + for (const z of b.zeilen) { + if (da.has(z.zeile)) continue; + const p = zuordnungVorschlag(z); + await c.query("insert into bwa_zuordnung (zeile, bezeichnung, planzeile) values ($1, $2, $3)", [z.zeile, z.bezeichnung, p]); + if (!z.summe && (z.monat || z.kumuliert)) neue.push({ zeile: z.zeile, bezeichnung: z.bezeichnung, planzeile: p }); + } + return neue; + }); + return reply.status(201).send({ jahr: b.jahr, monat: b.monat, art: b.art, zeilen: b.zeilen.length, neu: neu }); + }); + + app.delete("/api/bwa/:jahr/:monat", async (req) => { + const p = z.object({ jahr: Jahr, monat: z.coerce.number().int().min(1).max(12) }).parse(req.params); + await transaktion(pool, wer(req), (c) => c.query("update finanz_monat set zeilen = null, dateiname = null, bwa_art = null, eingelesen_am = null where jahr = $1 and monat = $2", [p.jahr, p.monat])); + return { ok: true }; + }); + + app.put("/api/bwa/zuordnung/:zeile", async (req) => { + const { zeile: nr } = z.object({ zeile: z.coerce.number().int().min(0).max(99999) }).parse(req.params); + const { planzeile } = z.object({ planzeile: z.enum([...PLANZEILEN, "ignorieren"]) }).parse(req.body); + await transaktion(pool, wer(req), (c) => c.query(`insert into bwa_zuordnung (zeile, planzeile) values ($1, $2) + on conflict (zeile) do update set planzeile = $2`, [nr, planzeile])); + return { zeile: nr, planzeile }; + }); + + app.put("/api/finanzmonat/:jahr/:monat", async (req) => { + const p = z.object({ jahr: Jahr, monat: z.coerce.number().int().min(1).max(12) }).parse(req.params); + const q = z.object({ notizen: z.record(z.string(), z.string().max(500)).optional(), erledigt: z.array(z.string().max(40)).max(30).optional() }).parse(req.body); + const r = await transaktion(pool, wer(req), async (c) => (await c.query(`insert into finanz_monat (jahr, monat, notizen, erledigt) values ($1, $2, coalesce($3, '{}'::jsonb), coalesce($4, '[]'::jsonb)) + on conflict (jahr, monat) do update set notizen = coalesce($3, finanz_monat.notizen), erledigt = coalesce($4, finanz_monat.erledigt) returning notizen, erledigt`, + [p.jahr, p.monat, q.notizen ? JSON.stringify(q.notizen) : null, q.erledigt ? JSON.stringify(q.erledigt) : null])).rows[0]); + return r; + }); + + app.get("/api/jahresplan/planist", async (req) => { + const q = z.object({ jahr: Jahr, monat: z.coerce.number().int().min(1).max(12).optional(), kumuliert: z.enum(["0", "1"]).default("0") }).parse(req.query); + // ohne Plan für das Jahr zeigt die Seite nur die Ist-Werte (z. B. die BWA des laufenden Jahres) + const plan = (await pool.query("select * from jahresplan where jahr = $1 and gilt", [q.jahr])).rows[0]; + const monate = (await pool.query("select monat, dateiname, bwa_art, eingelesen_am, zeilen is not null as bwa, notizen, erledigt from finanz_monat where jahr = $1 order by monat", [q.jahr])).rows; + const mitBwa = monate.filter((m) => m.bwa); + const m = q.monat ?? mitBwa.at(-1)?.monat ?? Math.max(1, Number(heute().slice(5, 7)) - 1); + const fm = (await pool.query("select * from finanz_monat where jahr = $1 and monat = $2", [q.jahr, m])).rows[0]; + const zu = await zuordnung(); + const kumuliert = q.kumuliert === "1"; + const r = rechne(plan ? PlanSchema.parse(plan.daten) : leererPlan()); + const ergebnis = planIst(r, fm?.zeilen ? istWerte(fm.zeilen, zu, kumuliert) : null, m, kumuliert); + const alleZeilen = (await pool.query("select zeile, bezeichnung, planzeile from bwa_zuordnung order by zeile")).rows; + const werte = new Map((fm?.zeilen ?? []).map((z: any) => [z.zeile, z])); + return { + jahr: q.jahr, monat: m, kumuliert, plan: plan ? { id: plan.id, name: plan.name } : null, + monate: monate.map(({ notizen: _n, erledigt: _e, ...x }) => x), + bwa: fm?.zeilen ? { dateiname: fm.dateiname, art: fm.bwa_art, eingelesen_am: fm.eingelesen_am } : null, + notizen: fm?.notizen ?? {}, erledigt: fm?.erledigt ?? [], + ...ergebnis, + zuordnung: alleZeilen.filter((z) => !werte.get(z.zeile)?.summe).map((z) => ({ ...z, bezeichnung: werte.get(z.zeile)?.bezeichnung ?? z.bezeichnung, + monatswert: werte.get(z.zeile)?.monat ?? null, kumuliert: werte.get(z.zeile)?.kumuliert ?? null })), + sitzung: ersterFreitag(m === 12 ? q.jahr + 1 : q.jahr, m === 12 ? 1 : m + 1), + }; + }); + + app.get("/api/jahresplan/stand", async () => jahresplanStand(pool, h.liquiDaten, heute())); +} + +/** beauftragter Umsatz je Monat (netto, nach Rechnungstermin) aus Projekten ab „beauftragt“ */ +function beauftragtJeMonat(d: Daten, jahr: number): number[] { + const m = Array(12).fill(0); + for (const e of d.einnahmen) if (e.termin.startsWith(`${jahr}-`)) m[Number(e.termin.slice(5, 7)) - 1] += e.netto; + return m; +} + +/** Übersicht: wie viel Umsatz im Planjahr noch verkauft werden muss (Stufe-5-Abnahme) */ +export async function jahresplanStand(pool: Pool, liquiDaten: () => Promise, heute: Datum) { + const p = (await pool.query("select jahr, name, daten from jahresplan where gilt and jahr >= $1 order by jahr limit 1", [Number(heute.slice(0, 4))])).rows[0]; + if (!p) return null; + const daten = PlanSchema.parse(p.daten); + const r = rechne(daten); + const b = beauftragtJeMonat(await liquiDaten(), p.jahr).reduce((x, y) => x + y, 0); + return { jahr: p.jahr as number, name: p.name as string, umsatz: r.treppe.umsatz, beauftragt: b, offen: Math.max(0, r.treppe.umsatz - b), + knapp: knappText(daten, r).satz, gewinnQuote: r.treppe.quoteGewinn }; +} + +/** gilt-Versionen der Jahre, die die Liquidität als Vorschau braucht */ +export async function geltendePlaene(pool: Pool, vonJahr: number, bisJahr: number): Promise<{ jahr: number; daten: PlanDaten }[]> { + return (await pool.query("select jahr, daten from jahresplan where gilt and jahr between $1 and $2", [vonJahr, bisJahr])).rows + .map((r) => ({ jahr: r.jahr as number, daten: PlanSchema.parse(r.daten) })); +} + +/** Saison in % aus Umsätzen je Monat, auf ganze Prozent, Summe 100 */ +export function saisonAus(umsaetze: number[]): number[] { + const s = umsaetze.reduce((a, b) => a + Math.max(0, b), 0); + if (!s) return [...SAISON_HANDWERK]; + const roh = umsaetze.map((u) => (Math.max(0, u) / s) * 100); + const ganz = roh.map(Math.floor); + let rest = 100 - ganz.reduce((a, b) => a + b, 0); + roh.map((x, i) => [x - Math.floor(x), i] as const).sort((a, b) => b[0] - a[0]).forEach(([, i]) => { if (rest-- > 0) ganz[i]! += 1; }); + return ganz; +} diff --git a/src/server/migrations/019_jahresplan.sql b/src/server/migrations/019_jahresplan.sql new file mode 100644 index 0000000..440fc8a --- /dev/null +++ b/src/server/migrations/019_jahresplan.sql @@ -0,0 +1,56 @@ +-- Jahresfinanzplanung und BWA (Stufe 5, Henning 21.10.2026): Versionen eines Jahresplans (Bausteine als JSON, +-- die Basis bleibt, eine Version „gilt“ für Liquidität und Übersicht), je Monat die eingelesene BWA mit Notizen und +-- der Checkliste der Finanzsitzung, und die einmalige Zuordnung der BWA-Zeilen zu den Planzeilen. + +create table jahresplan ( + id uuid primary key default gen_random_uuid(), + jahr integer not null check (jahr between 2000 and 2100), + name text not null check (trim(name) <> ''), + basis boolean not null default false, + gilt boolean not null default false, + daten jsonb not null default '{}', + angelegt_am timestamptz not null default now(), + geaendert_am timestamptz not null default now(), + geaendert_von text not null default 'system' +); +create unique index jahresplan_basis on jahresplan (jahr) where basis; +create unique index jahresplan_gilt on jahresplan (jahr) where gilt; +create trigger jahresplan_protokoll before insert or update or delete on jahresplan + for each row execute function stempel_und_protokoll(); + +create table finanz_monat ( + id uuid primary key default gen_random_uuid(), + jahr integer not null check (jahr between 2000 and 2100), + monat integer not null check (monat between 1 and 12), + -- eingelesene BWA: Zeilen mit Monats- und kumulierten Werten (Cent) und ihren Konten + dateiname text, + bwa_art text, + eingelesen_am timestamptz, + zeilen jsonb, + -- Notiz je Planzeile zur Abweichung, z. B. „Holz teurer“ + notizen jsonb not null default '{}', + -- abgehakte Punkte der Finanzsitzung + erledigt jsonb not null default '[]', + angelegt_am timestamptz not null default now(), + geaendert_am timestamptz not null default now(), + geaendert_von text not null default 'system', + unique (jahr, monat) +); +create trigger finanz_monat_protokoll before insert or update or delete on finanz_monat + for each row execute function nur_stempel(); + +create table bwa_zuordnung ( + id uuid primary key default gen_random_uuid(), + zeile integer not null unique, + bezeichnung text not null default '', + planzeile text not null check (planzeile in ('umsatz', 'material', 'personal', 'unternehmerlohn', 'werbung', 'laufend', 'afa', + 'tilgung', 'investition', 'steuer', 'ignorieren')), + angelegt_am timestamptz not null default now(), + geaendert_am timestamptz not null default now(), + geaendert_von text not null default 'system' +); +create trigger bwa_zuordnung_protokoll before insert or update or delete on bwa_zuordnung + for each row execute function stempel_und_protokoll(); + +-- wiederkehrende Aufgaben, die das Programm selbst anlegt (Finanzsitzung am ersten Freitag im Monat) +alter table aufgabe add column serie text unique; diff --git a/src/server/tabellen.ts b/src/server/tabellen.ts index cfe0b14..2e985ab 100644 --- a/src/server/tabellen.ts +++ b/src/server/tabellen.ts @@ -473,4 +473,8 @@ export const NUR_SICHERUNG: { name: string; pfad: string; sortierung: string }[] { name: "zeiteintrag", pfad: "zeiteintraege", sortierung: "datum, kontakt_id" }, { name: "zeitanteil", pfad: "zeitanteile", sortierung: "zeiteintrag_id, reihenfolge" }, { name: "projekt_vorlage", pfad: "projekt_vorlagen", sortierung: "projekt_id, vorlage" }, + // Stufe 5: Jahresplan-Versionen, BWA je Monat und die Zuordnung der BWA-Zeilen + { name: "jahresplan", pfad: "jahresplaene", sortierung: "jahr, basis desc, angelegt_am" }, + { name: "finanz_monat", pfad: "finanz_monate", sortierung: "jahr, monat" }, + { name: "bwa_zuordnung", pfad: "bwa_zuordnungen", sortierung: "zeile" }, ]; diff --git a/src/web/app.ts b/src/web/app.ts index 4114188..875ed50 100644 --- a/src/web/app.ts +++ b/src/web/app.ts @@ -16,6 +16,7 @@ import { angebotSeite, angeboteHtml, angeboteSeite, mengenblattSeite, neuesAngeb import { vorlageSeite } from "./mengenblatt.js"; import { leistungSeite, stammdatenSeite } from "./stammdaten.js"; import { lageKopfHtml, liquiditaetSeite } from "./liquiditaet.js"; +import { jahresplanSeite } from "./jahresplan.js"; // ---------- Reiter ---------- @@ -710,7 +711,8 @@ async function uebersicht(): Promise {

Wer macht was

Terminplan
${einsatzHtml(u.einsatz)}

Liquidität 4 Wochen

Details
${u.liquiLage ? lageKopfHtml(u.liquiLage, "4 Wochen") : ""} -
${u.liquiditaet.map((p: Zeile) => `
ab ${dat(p.von).slice(0, 6)}${euro(p.kontostand)}Saldo ${euro(p.saldo)}
`).join("")}
`; +
${u.liquiditaet.map((p: Zeile) => `
ab ${dat(p.von).slice(0, 6)}${euro(p.kontostand)}Saldo ${euro(p.saldo)}
`).join("")}
+ ${u.jahresplan ? jahresplanZeile(u.jahresplan) : ""}`; inhalt.appendChild(raster); raster.addEventListener("change", async (ev) => { @@ -724,6 +726,15 @@ async function uebersicht(): Promise { }; } +/** Stufe 5: wie viel Umsatz im Planjahr noch verkauft werden muss */ +function jahresplanZeile(j: Zeile): string { + const ganz = (c: number) => euro(Math.round(c / 100) * 100).replace(",00 €", " €"); + const anteil = j.umsatz ? Math.min(100, Math.round((j.beauftragt / j.umsatz) * 100)) : 0; + return `
Jahresplan ${j.jahr}: noch ${ganz(j.offen)} Umsatz zu verkaufen + Ziel ${ganz(j.umsatz)}, beauftragt ${ganz(j.beauftragt)} (${anteil} %) +
`; +} + function einsatzHtml(e: Zeile): string { if (!e.zeilen.length && e.ohne.tage.every((t: Zeile[]) => !t.length)) return '

In den nächsten zwei Wochen ist nichts eingeplant.

'; const zeilen = [...e.zeilen, ...(e.ohne.tage.some((t: Zeile[]) => t.length) ? [e.ohne] : [])]; @@ -965,7 +976,8 @@ function reiterFuer(s: Sitzung): Reiter[] { ["terminplan", "Terminplan", terminplan], ["personal", "Personal", () => personalSeite()], ["stunden", "Stunden", stundenSeite], ["kontakte", "Kontakte", kontakte], ["stammdaten", "Stammdaten", () => stammdatenSeite()], ["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten], ]; - if (rolle === "inhaber") alle.push(["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]); + // Jahresplan und BWA (Stufe 5) nur für den Inhaber + if (rolle === "inhaber") alle.push(["jahresplanung", "Jahresplanung", () => jahresplanSeite()], ["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]); return alle; } @@ -979,6 +991,7 @@ const SYMBOLE: Record = { stammdaten: '', liquiditaet: '', "laufende-kosten": '', + jahresplanung: '', benutzer: '', stunden: '', urlaub: '', diff --git a/src/web/jahresplan.ts b/src/web/jahresplan.ts new file mode 100644 index 0000000..491110f --- /dev/null +++ b/src/web/jahresplan.ts @@ -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) => ``; + +let d: Zeile; +let versionen: Version[] = []; +let plan: Version | null = null; +let speichernNach: ReturnType | undefined; + +const aktivSchluessel = () => `jp-version-${jahr}`; + +export async function jahresplanSeite(): Promise { + d = await api(`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", ``); + kopf.querySelectorAll("[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() : 'Noch kein Plan für dieses Jahr'} +
${([["aufbauen", "Plan aufbauen"], ["monate", "12 Monate"], ["planist", "Plan / Ist"]] as [Reiter, string][]).map(([r, t]) => + ``).join("")}
+ `; + 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 ``; +} + +async function leisteKlick(ev: Event, leiste: HTMLElement): Promise { + const b = (ev.target as HTMLElement).closest("[data-version], [data-reiter], [data-a]"); + if (!b) return; + if (b.dataset.version) { merke(aktivSchluessel(), b.dataset.version); offen = null; return jahresplanSeite(); } + if (b.dataset.reiter) { reiter = b.dataset.reiter as Reiter; merke("jp-reiter", reiter); return jahresplanSeite(); } + const w = leiste.querySelector(".jp-werkzeug")!; + if (b.dataset.a === "neue-version" && plan) return neueVersion(plan.daten, `Version ${versionen.length + 1}`); + if (b.dataset.a === "werkzeug" && plan) { + w.hidden = !w.hidden; + w.innerHTML = ` + ${plan.gilt ? 'Diese Version gilt für Liquidität, Übersicht und Plan / Ist.' : ''} + ${plan.basis ? 'Die Basis bleibt immer erhalten.' : ''}`; + w.querySelector("form")!.onsubmit = async (e) => { + e.preventDefault(); + const name = (w.querySelector("[name=name]") as HTMLInputElement).value.trim(); + if (name) { await api(`jahresplan/${plan!.id}`, "PATCH", { name }); void jahresplanSeite(); } + }; + return; + } + if (b.dataset.a === "gilt" && plan) { await api(`jahresplan/${plan.id}`, "PATCH", { gilt: true }); return jahresplanSeite(); } + if (b.dataset.a === "loeschen" && plan && (await bestaetigen(`Version „${plan.name}“ löschen?`))) { + await api(`jahresplan/${plan.id}`, "DELETE"); + merke(aktivSchluessel(), null); + return jahresplanSeite(); + } +} + +async function neueVersion(daten: PlanDaten, name: string): Promise { + await speichernJetzt(); + const v = await api("jahresplan", "POST", { jahr, name, daten }); + merke(aktivSchluessel(), v.id); + offen = null; + void jahresplanSeite(); +} + +function leerZeigen(): void { + const v = d.vorlagen as Zeile; + const karte = document.createElement("section"); + karte.className = "karte jp-leer"; + karte.innerHTML = `

Für ${jahr} gibt es noch keinen Plan

+

Das Programm füllt den ersten Plan, die Basis, mit dem, was es schon weiß. Danach passt du Leute, Stundensatz und Kosten an.

+ + `; + karte.querySelector("[data-a=anlegen]")!.onclick = async () => { + const neu = await api("jahresplan", "POST", { jahr }); + merke(aktivSchluessel(), neu.id); + void jahresplanSeite(); + }; + inhalt.append(karte); +} + +// ---------- speichern ---------- + +function speichernSpaeter(): void { + clearTimeout(speichernNach); + speichernNach = setTimeout(() => void speichernJetzt(), 700); +} +async function speichernJetzt(): Promise { + if (!speichernNach || !plan) return; + clearTimeout(speichernNach); + speichernNach = undefined; + const p = plan; + try { + await api(`jahresplan/${p.id}`, "PATCH", { daten: p.daten }); + document.querySelector(".jp-gespeichert")?.replaceChildren("Gespeichert"); + } catch (e) { + document.querySelector(".jp-gespeichert")?.replaceChildren(`Nicht gespeichert: ${(e as Error).message}`); + } +} +window.addEventListener("hashchange", () => void speichernJetzt()); + +/** Wert aus einem Eingabefeld in den Plan schreiben; data-f = "a.stundensatz", "m..brutto", "i..betrag", "s." */ +function setze(feld: string, typ: string, roh: string | boolean): void { + const p = plan!.daten; + const teile = feld.split("."); + const wert = typ === "bool" ? roh : typ === "euro" ? (String(roh).trim() ? parseEuro(String(roh)) : 0) : typ === "text" || typ === "art" ? String(roh) : leseZahl(String(roh)); + if (teile[0] === "a") (p.annahmen as unknown as Record)[teile[1]!] = wert; + if (teile[0] === "m") { const m = p.mitarbeiter.find((x) => x.id === teile[1]); if (m) (m as unknown as Record)[teile[2]!] = wert; } + if (teile[0] === "i") { const v = p.investitionen.find((x) => x.id === teile[1]); if (v) (v as unknown as Record)[teile[2]!] = wert; } + if (teile[0] === "s") p.saison[Number(teile[1])] = Math.max(0, Math.min(100, wert as number)); + // Austritt nicht vor dem Eintritt + for (const m of p.mitarbeiter) if (m.austritt < m.eintritt) m.austritt = m.eintritt; +} + +function eingabenVerbinden(wurzel: HTMLElement, neuZeichnen: () => void, teilweise: () => void): void { + wurzel.addEventListener("input", (ev) => { + const el = ev.target as HTMLInputElement; + if (!el.dataset.f) return; + try { + setze(el.dataset.f, el.dataset.t ?? "zahl", el.type === "checkbox" ? el.checked : el.value); + el.classList.remove("ungueltig"); + el.removeAttribute("aria-invalid"); + } catch { el.classList.add("ungueltig"); el.setAttribute("aria-invalid", "true"); return; } + speichernSpaeter(); + document.querySelector(".jp-gespeichert")?.replaceChildren("Speichert …"); + teilweise(); + }); + wurzel.addEventListener("change", (ev) => { + const el = ev.target as HTMLInputElement; + if (!el.dataset.f || el.classList.contains("ungueltig")) return; + if (el.tagName === "SELECT" || el.type === "checkbox") neuZeichnen(); + }); +} + +// ---------- Plan aufbauen ---------- + +const SCHRITTE = ["Leute und Stunden", "Stundensatz, Material, Sub", "Kosten und Investitionen", "Auf 12 Monate verteilen"]; + +function aufbauenZeigen(): void { + const raster = document.createElement("div"); + raster.className = "jp-raster"; + raster.innerHTML = ``; + inhalt.append(raster); + const links = raster.querySelector(".jp-links")!, rechts = raster.querySelector(".jp-rechts")!; + const zeichneRechts = () => { rechts.innerHTML = treppeHtml(plan!.daten) + vergleichHtml(); }; + const zeichneLinks = () => { links.innerHTML = bausteineHtml(plan!.daten); }; + const alles = () => { zeichneLinks(); zeichneRechts(); }; + alles(); + eingabenVerbinden(links, alles, () => { + zeichneRechts(); + // Zeile über dem offenen Baustein mitziehen + const p = plan!.daten; + links.querySelectorAll("[data-zus]").forEach((el) => { + const [art, id] = el.dataset.zus!.split(":"); + const m = art === "m" ? p.mitarbeiter.find((x) => x.id === id) : undefined, v = art === "i" ? p.investitionen.find((x) => x.id === id) : undefined; + if (m) el.innerHTML = mitarbeiterZeile(m); + if (v) el.innerHTML = investitionZeile(v); + }); + }); + raster.addEventListener("click", async (ev) => { + const t = ev.target as HTMLElement; + const b = t.closest("[data-a], [data-offen], [data-schritt]"); + if (!b) return; + const p = plan!.daten; + if (b.dataset.schritt) { + const s = Number(b.dataset.schritt); + if (s === 4) { reiter = "monate"; merke("jp-reiter", reiter); return void jahresplanSeite(); } + return links.querySelector(`#jp-schritt-${s}`)?.scrollIntoView({ behavior: "smooth", block: "start" }); + } + if (b.dataset.offen !== undefined) { offen = offen === b.dataset.offen ? null : b.dataset.offen; zeichneLinks(); links.querySelector(`[data-zus="${offen?.replace("-", ":")}"] ~ .jp-editor input`)?.focus(); return; } + const a = b.dataset.a; + if (a === "plus-m") { + const id = `m${Date.now().toString(36)}`; + p.mitarbeiter.push({ id, name: `Geselle ${p.mitarbeiter.filter((m) => m.art === "angestellt").length + 1}`, art: "angestellt", stunden: 1400, brutto: 340_000, faktor: 1.25, eintritt: 1, austritt: 12, neu: true }); + offen = `m-${id}`; + } + if (a === "plus-i") { + const id = `i${Date.now().toString(36)}`; + p.investitionen.push({ id, name: "Fahrzeug", betrag: 4_500_000, monat: 3, art: "kredit", anzahlung: 900_000, laufzeit: 60, zins: 5, rate: 0, nutzungsdauer: 6 }); + offen = `i-${id}`; + } + if (a === "weg-m") { p.mitarbeiter = p.mitarbeiter.filter((m) => `m-${m.id}` !== offen); offen = null; } + if (a === "weg-i") { p.investitionen = p.investitionen.filter((v) => `i-${v.id}` !== offen); offen = null; } + if (a === "fertig") offen = null; + if (a === "lk-uebernehmen") p.annahmen.laufendMonat = d.vorlagen.laufend.ohnePersonal; + if (a === "vj-material") p.annahmen.materialEinkauf = d.vorlagen.vorjahr.material; + if (a === "vorschlag") { + const v = vorschlaege(p).find((x) => x.id === b.dataset.id); + if (v) return neueVersion(v.daten, v.name); + } + if (a && ["plus-m", "plus-i", "weg-m", "weg-i", "fertig", "lk-uebernehmen", "vj-material"].includes(a)) { + if (a !== "fertig") speichernSpaeter(); + alles(); + links.querySelector(".jp-editor input")?.focus(); + } + }); +} + +function mitarbeiterZeile(m: PlanMitarbeiter): string { + const std = stundenImJahr(m), mon = monateAktiv(m); + const zeit = m.eintritt > 1 || m.austritt < 12 ? `${m.eintritt > 1 ? `ab 01.${String(m.eintritt).padStart(2, "0")}.` : ""}${m.austritt < 12 ? ` bis ${MONATSNAMEN[m.austritt - 1]}` : ""} · ` : ""; + const unter = m.art === "inhaber" + ? `${zeit}${zahl(std * 100)} verkaufbare Std · Unternehmerlohn ${eur(m.brutto)}/Mon` + : `${zeit}${zahl(std * 100)} Std · ${eur(m.brutto)} brutto × ${zahlWert(m.faktor)}${m.neu ? " · neu" : ""}`; + return ``; +} + +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 ``; +} + +const f = (label: string, feld: string, typ: string, wert: string, zusatz = "", hilfe = "") => + ``; + +function mitarbeiterEditor(m: PlanMitarbeiter): string { + const p = `m.${m.id}`; + return ``; +} + +function investitionEditor(v: PlanInvestition): string { + const p = `i.${v.id}`; + return ``; +} + +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 ``; + }; + const schritt = (n: number, inhaltHtml: string) => ``; + return ` + ${schritt(1, ` + `)} + ${schritt(2, ``)} + ${schritt(3, ` + + `)} + ${schritt(4, `

Den Umsatz nach Saison auf die Monate verteilen und sehen, wann es knapp wird.

`)} + `; +} + +function treppeHtml(p: PlanDaten): string { + const r = rechne(p), t = r.treppe, a = p.annahmen; + const ampel = (x: string, text: string) => `${text}`; + 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 = "") => + `${zeichen}${text}${unter ? `${unter}` : ""}${mitte}${eur(betrag)}${rechts}`; + const vs = t.luecke > 0 ? vorschlaege(p) : []; + return ``; +} + +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) => `${titel}${rs.map(({ v, r }) => `${wert(r)}`).join("")}`; + return ``; +} + +// ---------- 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 = ` +

Umsatz übers Jahr verteilen · Säule ziehen oder Wert eintippen

+
+ + ${Math.abs(sum - 100) > 0.05 ? `` : ""}
+

Monatsplan · jede Zeile filter- und sortierbar wie überall · Werte in €

+

${d.vorlagen && plan!.gilt ? `Die Liquidität übernimmt diese Version ab ${MONATSNAMEN[0]} ${jahr} als Vorschau für alle Monate, in denen noch keine echten Zahlungen stehen: weitere Einnahmen und Material/Sub nur, soweit Zahlungspläne und Eingangsrechnungen sie nicht schon abdecken; dazu Löhne neuer Mitarbeiter, Investitionen und Steuer-Vorauszahlungen. Echte Zahlungen ersetzen den Plan Monat für Monat.` : `Diese Version gilt nicht; die Liquidität rechnet mit „${esc(versionen.find((v) => v.gilt)?.name ?? "")}“.`}

+
`; + wurzel.querySelector(".jp-tabelle")!.append(monatsTabelle(p, r)); + }; + zeichne(); + eingabenVerbinden(wurzel, zeichne, () => { + // Säulen und Tabelle nachziehen, das Eingabefeld behält den Fokus + const aktiv = document.activeElement as HTMLInputElement | null; + const feld = aktiv?.dataset.f; + const pos = aktiv?.selectionStart ?? null; + zeichne(); + if (feld) { const neu = wurzel.querySelector(`[data-f="${feld}"]`); neu?.focus(); if (pos !== null) neu?.setSelectionRange(pos, pos); } + }); + // Säule ziehen: 100 % Höhe = 15 % Anteil + wurzel.addEventListener("pointerdown", (ev) => { + const s = (ev.target as HTMLElement).closest(".jp-saeule-feld"); + const saeule = s?.querySelector(".jp-saeule"); + if (!s || !saeule) return; + ev.preventDefault(); + const i = Number(saeule.dataset.s); + const feld = s.getBoundingClientRect(); + const setzeAus = (y: number) => { + const anteil = Math.max(0, Math.min(15, ((feld.bottom - y) / feld.height) * 15)); + plan!.daten.saison[i] = Math.round(anteil * 2) / 2; + speichernSpaeter(); + zeichne(); + }; + setzeAus(ev.clientY); + const weiter = (e: PointerEvent) => setzeAus(e.clientY); + const ende = () => { window.removeEventListener("pointermove", weiter); window.removeEventListener("pointerup", ende); }; + window.addEventListener("pointermove", weiter); + window.addEventListener("pointerup", ende); + }); + wurzel.addEventListener("keydown", (ev) => { + const s = (ev.target as HTMLElement).closest(".jp-saeule"); + if (!s || !["ArrowUp", "ArrowDown"].includes(ev.key)) return; + ev.preventDefault(); + const i = Number(s.dataset.s); + plan!.daten.saison[i] = Math.max(0, plan!.daten.saison[i]! + (ev.key === "ArrowUp" ? 0.5 : -0.5)); + speichernSpaeter(); + zeichne(); + wurzel.querySelector(`.jp-saeule[data-s="${i}"]`)?.focus(); + }); + wurzel.addEventListener("click", async (ev) => { + const b = (ev.target as HTMLElement).closest("[data-a]"); + if (!b) return; + const p = plan!.daten; + const a = b.dataset.a; + if (a === "saison-handwerk") p.saison = [...SAISON_HANDWERK]; + if (a === "saison-gleich") p.saison = SAISON_GLEICH.map((x) => Math.round(x * 10) / 10); + if (a === "saison-vj") { + const u = (d.vorlagen.saisonVorjahr as Zeile[]).map((x) => Math.max(0, x.umsatz as number)); + const s = u.reduce((x, y) => x + y, 0); + if (s) p.saison = u.map((x) => Math.round((x / s) * 1000) / 10); + } + if (a === "saison-100") { + const s = p.saison.reduce((x, y) => x + y, 0); + if (s) p.saison = p.saison.map((x) => Math.round((x / s) * 1000) / 10); + } + if (a?.startsWith("saison")) { speichernSpaeter(); return zeichne(); } + if (a === "kontokorrent") { + await api("aufgaben", "POST", { text: `Kontokorrent ${eur(Number(b.dataset.betrag))} bei der Bank vorsorglich anfragen (Jahresplan ${jahr})`, faellig_am: new Date().toISOString().slice(0, 10) }); + b.outerHTML = 'Als Aufgabe angelegt'; + } + if (a === "verschieben") { + const x: PlanDaten = JSON.parse(JSON.stringify(p)); + const v = x.investitionen.find((i) => i.id === b.dataset.id)!; + v.monat = Math.min(12, v.monat + 3); + return neueVersion(x, `${v.name} im ${MONATSNAMEN[v.monat - 1]}`); + } + }); +} + +function monatsTabelle(p: PlanDaten, r: Rechnung): HTMLElement { + const m = r.monate; + const beauftragt = d.beauftragt as number[]; + const negativ = (x: number[]) => x.map((v) => -v); + const zeilen: Zeile[] = [ + { id: "umsatz", text: "Umsatz", werte: m.umsatz }, + { id: "beauftragt", text: "davon schon beauftragt", werte: beauftragt, klein: true }, + { id: "offen", text: "noch zu verkaufen", werte: m.umsatz.map((u, i) => Math.max(0, u - beauftragt[i]!)), klein: true }, + { id: "waren", text: "− Material + Sub", werte: negativ(m.waren) }, + { id: "rohertrag", text: "= Rohertrag", werte: m.rohertrag, summe: true }, + { id: "personal", text: "− Personal + Werbung", werte: m.personal.map((x, i) => -(x + m.unternehmerlohn[i]! + m.werbung[i]!)) }, + { id: "laufend", text: "− Laufende Kosten", werte: negativ(m.laufend) }, + { id: "investition", text: "− Investition + Tilgung", werte: negativ(m.investition) }, + { id: "steuer", text: "− Steuer-Vorauszahlung", werte: negativ(m.steuer) }, + { id: "ueberschuss", text: "= Überschuss", werte: m.ueberschuss, summe: true }, + { id: "kontostand", text: "Kontostand Monatsende", werte: m.kontostand, summe: true, stand: true }, + { id: "grenze", text: "Mindestgrenze", werte: Array(12).fill(p.annahmen.mindestgrenze), klein: true, stand: true }, + ]; + const zelle = (z: Zeile, v: number, i: number) => + ` 0 ? " ein" : ""}${z.id === "kontostand" && i === r.tief.monat - 1 ? " jp-tief" : ""}${z.id === "kontostand" && v < p.annahmen.mindestgrenze ? " fehler" : ""}">${v ? zahl(v) : "–"}`; + const el = liste({ + schluessel: "jahresplan-monate", klein: true, klasse: "jp-monatsplan", + zeilenKlasse: (z) => `${z.summe ? "jp-summe-zeile" : ""}${z.klein ? " jp-klein" : ""}`, + spalten: [ + { id: "zeile", titel: "", wert: (z) => esc(z.text), text: (z) => z.text, klasse: "jp-erste" }, + ...KURZ.map((titel, i) => ({ id: `m${i + 1}`, titel, art: "zahl" as const, klasse: "zahl", wert: (z: Zeile) => zelle(z, z.werte[i], i), sortWert: (z: Zeile) => z.werte[i] as number })), + { id: "jahr", titel: "Jahr", art: "zahl", klasse: "zahl", wert: (z) => (z.stand ? "" : `${zahl((z.werte as number[]).reduce((x, y) => x + y, 0))}`), sortWert: (z) => (z.stand ? null : (z.werte as number[]).reduce((x, y) => x + y, 0)) }, + ], + zeilen, + }); + return el; +} + +// ---------- Plan / Ist ---------- + +const PUNKTE: { id: string; text: string; auto?: boolean; spaeter?: boolean }[] = [ + { id: "vollstaendig", text: "Monat vollständig? Alle Eingangsrechnungen und Löhne bei Herrn Seeler" }, + { id: "bwa", text: "BWA eingelesen", auto: true }, + { id: "kennzahlen", text: "Kennzahlen angesehen" }, + { id: "abweichung", text: "Abweichungen ab 5 % geklärt (Notiz in der Zeile)" }, + { id: "liquiditaet", text: 'Liquidität der nächsten 6 Wochen ansehen · öffnen' }, + { id: "toepfe", text: "Umbuchen in die Töpfe", spaeter: true }, + { id: "plan", text: "Plan anpassen? Bei großen Abweichungen eine neue Version für den Rest des Jahres" }, +]; + +async function planIstZeigen(): Promise { + const q = new URLSearchParams({ jahr: String(jahr), kumuliert: piKum ? "1" : "0", ...(piMonat ? { monat: String(piMonat) } : {}) }); + const x = await api(`jahresplan/planist?${q}`); + piMonat = x.monat; + const mitBwa = new Set((x.monate as Zeile[]).filter((m) => m.bwa).map((m) => m.monat as number)); + const wurzel = document.createElement("div"); + wurzel.className = "jp-planist"; + inhalt.append(wurzel); + const ohnePlan = !x.plan; + const monatName = MONATSNAMEN[x.monat - 1]; + const bwa = x.bwa as Zeile | null; + const kopf = ` + `; + 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 ``; + }).join(""); + const notizen = x.notizen as Record; + wurzel.innerHTML = `${kopf}${ohnePlan ? `

Für ${jahr} gibt es keinen Jahresplan; die Tabelle zeigt nur die Ist-Werte. Die BWA dient dem Plan ${jahr! + 1} als Vorjahr.

` : ""} + +

${bwa ? `BWA ${monatName} · eingelesen ${dat(String(bwa.eingelesen_am).slice(0, 10))} · ${esc(bwa.art ?? "")}` : `Noch keine BWA für ${monatName} ${jahr}`}

+ ${bwa ? `` : ""}
+

Die BWA-Zeilen sind einmal den Planzeilen zugeordnet, danach liest das Programm jede neue BWA-Datei selbst ein. Gelb ab 5 %, rot ab 15 % schlechter als geplant; grün = besser. ${x.plan ? `Plan: Version „${esc(x.plan.name)}“.` : ""}

+ + ${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 ? ` (${z.prozent.toLocaleString("de-DE")} %)` : ""}`), sortWert: (z: Zeile) => z.abweichung }]), + { id: "notiz", titel: "Notiz", fest: true, wert: (z) => (z.summe ? "" : ``) }, + ], + 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("[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 { + const datei = input.files?.[0]; + if (!datei) return; + const fehler = document.getElementById("jp-bwa-fehler")!; + fehler.textContent = ""; + try { + const r = await api("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 ``; +} + +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 ``; +} diff --git a/src/web/liquiditaet.ts b/src/web/liquiditaet.ts index f7ef8af..056a773 100644 --- a/src/web/liquiditaet.ts +++ b/src/web/liquiditaet.ts @@ -163,6 +163,7 @@ async function lageZeigen(): Promise {
${kurveSvg(d, bereich.clientWidth - 34, v?.wochen)}
KontostandEinnahmen je WocheAusgaben je WocheMindestgrenze${v ? 'Was wäre, wenn' : ""}

Woche anklicken: Zahlungen dieser Woche. Mindestgrenze: ${d.mindestgrenzeArt === "fest" ? `fester Betrag ${glatt(d.mindestgrenze)}` : `1 Monat laufende Kosten (${glatt(d.laufendMonat)})`}.

+ ${planHinweis(d)} ${wocheHtml(wochen.find((w) => w.von === gewaehlt), namen)}
Modus: @@ -177,6 +178,11 @@ async function lageZeigen(): Promise { if (w) { gewaehlt = gewaehlt === w.dataset.woche ? null : w.dataset.woche!; return zeichne(); } const m = t.closest("[data-mehr]"); if (m) { const k = m.dataset.mehr as "ein" | "aus"; mehr[k] = !mehr[k]; return zeichne(); } + const pv = t.closest("[data-plan-vorschau]"); + if (pv) { + void (async () => { const e = await api("einstellungen"); await api("einstellungen", "PUT", { ...e, jahresplanVorschau: pv.dataset.planVorschau === "an" }); void liquiditaetSeite(); })(); + return; + } const knopf = t.closest("[data-modus], [data-ausblenden], [data-zeige-aus], [data-alle-ein], [data-a=probe-weg], [data-verschieben]"); if (knopf?.dataset.modus) { modus = knopf.dataset.modus as "aus" | "was"; return zeichne(); } if (knopf?.dataset.ausblenden) { @@ -344,6 +350,15 @@ function listeHtml(art: "ein" | "aus", alle: ListenZeile[], namen: Map${art === "ein" ? "Im Zeitraum kommt nichts rein." : "Im Zeitraum geht nichts raus."}

`}`; } +/** Stufe 5: Posten aus dem Jahresplan zählen als Vorschau; hier ein- und ausschalten */ +function planHinweis(d: Zeile): string { + const plan = (d.wochen as Zeile[]).flatMap((w) => w.posten as Zeile[]).filter((p) => p.gruppe === "Jahresplan"); + if (d.jahresplanVorschau && !plan.length) return ""; + return `

${d.jahresplanVorschau + ? `Ab ${MONATSNAMEN[Number(plan[0]!.datum.slice(5, 7)) - 1]} ${plan[0]!.datum.slice(0, 4)} rechnet die Liquidität mit dem Jahresplan, soweit echte Zahlungen fehlen (Posten „Plan: …“). ` + : `Die Vorschau aus dem Jahresplan ist ausgeschaltet. `}

`; +} + /** Zahnrad: Mindestgrenze automatisch (1 Monat laufende Kosten) oder fester Betrag */ function grenzeBearbeiten(ziel: HTMLElement, d: Zeile): void { if (!ziel.hidden) { ziel.hidden = true; return; } diff --git a/src/web/styles.css b/src/web/styles.css index 570f248..3f403bc 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -1335,3 +1335,153 @@ dl.am-kennzahlen dd { margin: 0; text-align: right; font-variant-numeric: tabula .tag-probe { display: inline-block; font-size: 11px; font-weight: 600; padding: 1px 5px; border-radius: 4px; background: var(--probe-bg); border: 1px solid var(--probe-linie); color: var(--probe-text); } input.liqui-datum { width: 100%; font: inherit; font-size: 13px; padding: 2px 4px; border: 1px solid var(--akzent); border-radius: 6px; background: var(--fl); color: var(--text); } .probe-summe { font-weight: 400; color: var(--probe-text); } + +/* Jahresplanung (Stufe 5, Entwurf finanzen/entwurf-jahresplan) */ +.jp-jahre { display: flex; gap: 6px; } +.jp-leiste .hinweis { margin-left: 0; } +.jp-versionen { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; } +.jp-gilt { font-size: 11px; font-weight: 700; color: var(--gut-text); background: var(--gut-bg); border-radius: 99px; padding: 1px 6px; margin-left: 2px; } +.jp-werkzeug[hidden] { display: none; } +.jp-werkzeug { flex-basis: 100%; display: flex; gap: 10px; align-items: center; flex-wrap: wrap; background: var(--fl); border: 1px solid var(--linie); border-radius: 10px; padding: 10px 12px; } +.jp-umbenennen { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; } +.jp-umbenennen input { padding: 7px 10px; } +.jp-leer { max-width: 760px; } +.jp-leer h2 { margin-top: 0; } +.jp-liste { padding-left: 20px; line-height: 1.6; } +.jp-raster { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1.05fr); gap: 16px; align-items: start; } +.jp-links, .jp-rechts { display: flex; flex-direction: column; gap: 14px; min-width: 0; } +.jp-rechts { position: sticky; top: 12px; } +.jp-schritte { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 6px; } +.jp-schritte button { display: flex; gap: 8px; align-items: center; text-align: left; font-size: 13px; padding: 8px 10px; } +.jp-nr { flex: none; display: inline-grid; place-items: center; width: 22px; height: 22px; border-radius: 99px; background: var(--akzent-hell); color: var(--akzent); font-size: 12px; font-weight: 700; margin-right: 8px; } +.jp-schritte .jp-nr { margin-right: 0; } +.jp-schritt { scroll-margin-top: 12px; } +.jp-schritt h2 { display: flex; align-items: center; font-size: 17px; margin: 0 0 12px; } +.jp-unter { font-size: 14px; margin: 16px 0 8px; color: var(--leise); text-transform: uppercase; letter-spacing: .04em; } +.jp-bausteine { display: flex; flex-direction: column; gap: 8px; margin-bottom: 8px; } +.jp-baustein { border: 1px solid var(--linie); border-radius: 10px; background: var(--fl); } +.jp-baustein.auf { border-color: var(--akzent); box-shadow: 0 0 0 2px var(--akzent-hell); } +.jp-zeile { all: unset; box-sizing: border-box; display: flex; align-items: center; gap: 12px; width: 100%; padding: 10px 12px; cursor: pointer; border-radius: 10px; } +.jp-zeile:hover { background: var(--titel-bg); } +.jp-zeile:focus-visible { outline: 2px solid var(--akzent); } +.jp-sym { font-size: 20px; } +.jp-was { flex: 1; min-width: 0; display: flex; flex-direction: column; } +.jp-was small { color: var(--leise); font-size: 13px; } +.jp-betrag { font-weight: 600; white-space: nowrap; font-variant-numeric: tabular-nums; } +.jp-editor, .jp-felder { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 10px 14px; } +.jp-editor { padding: 4px 12px 12px; border-top: 1px solid var(--linie); padding-top: 12px; } +.jp-breit { grid-column: 1 / -1; } +.jp-editor .knoepfe { display: flex; justify-content: space-between; gap: 8px; } +.jp-f { display: flex; flex-direction: column; gap: 4px; font-size: 13px; color: var(--leise); min-width: 0; } +.jp-f > span:first-child { font-weight: 600; color: var(--text); } +.jp-ein { display: flex; align-items: center; border: 1px solid var(--eingabe-linie); background: var(--eingabe-bg); border-radius: 8px; overflow: hidden; } +.jp-ein input, .jp-ein select { flex: 1; min-width: 0; border: 0; background: transparent; color: var(--eingabe-text); font: inherit; font-size: 15px; padding: 8px 10px; text-align: right; font-variant-numeric: tabular-nums; } +.jp-ein select { text-align: left; color: var(--text); background: var(--fl); } +.jp-ein input[data-t="text"] { text-align: left; } +.jp-ein i { font-style: normal; padding: 0 10px; color: var(--leise); font-size: 13px; white-space: nowrap; } +.jp-ein:focus-within { outline: 2px solid var(--akzent); } +.jp-ein input.ungueltig { background: var(--warnung-bg); color: var(--warnung-text); } +.jp-f small.hinweis { font-size: 12px; } +.jp-treppe h2, .jp-vergleich h2 { margin: 0 0 10px; font-size: 17px; } +.jp-treppe table { width: 100%; border-collapse: collapse; font-variant-numeric: tabular-nums; } +.jp-treppe td { padding: 7px 6px; border-bottom: 1px solid var(--linie); vertical-align: top; } +.jp-treppe td small { display: block; color: var(--leise); font-size: 12px; } +.jp-z { width: 16px; color: var(--leise); font-weight: 700; } +.jp-mitte { color: var(--leise); font-size: 12.5px; } +.jp-q { font-size: 12px; color: var(--leise); text-align: right; width: 118px; } +.jp-treppe td.zahl { white-space: nowrap; text-align: right; } +.jp-q .ampel-chip { margin-left: 4px; } +.jp-treppe tr.summe td { font-weight: 600; border-top: 2px solid var(--linie); } +.jp-treppe tr.gewinn td { font-size: 16px; } +.jp-treppe tr.gewinn.rot td.zahl { color: var(--warn); } +.jp-treppe tr.gewinn.gruen td.zahl { color: var(--gut-text); } +.jp-luecke { margin-top: 12px; padding: 10px 12px; border-radius: 10px; background: var(--titel-bg); border: 1px dashed var(--linie); } +.jp-luecke p { margin: 0 0 8px; } +.jp-vorschlaege { display: flex; gap: 6px; flex-wrap: wrap; margin-bottom: 6px; } +.jp-vorschlaege .chip-knopf, .chip-knopf.gestrichelt { border-style: dashed; border-color: var(--akzent); color: var(--akzent); font-size: 13.5px; } +.jp-ok { color: var(--gut-text); font-weight: 600; } +.jp-scroll { overflow-x: auto; } +.jp-vergleich table { width: 100%; border-collapse: collapse; font-variant-numeric: tabular-nums; font-size: 14px; } +.jp-vergleich th, .jp-vergleich td { padding: 6px 8px; border-bottom: 1px solid var(--linie); text-align: right; white-space: nowrap; } +.jp-vergleich th[scope=row], .jp-vergleich thead th:first-child { text-align: left; font-weight: 500; color: var(--leise); } +.jp-vergleich .an { background: var(--akzent-hell); } +.jp-gespeichert { min-height: 1em; margin: 0; } +.jp-monate, .jp-planist { display: flex; flex-direction: column; gap: 14px; } +.jp-knapp { display: flex; gap: 14px; align-items: flex-start; border-left: 5px solid var(--gut-text); } +.jp-knapp.eng { border-left-color: var(--eingabe-linie); } +.jp-knapp p { margin: 0 0 8px; } +.jp-vorlagen { display: flex; gap: 6px; flex-wrap: wrap; } +.jp-saison { display: grid; grid-template-columns: repeat(12, minmax(0, 1fr)); gap: 8px; margin-top: 10px; } +.jp-monat { display: flex; flex-direction: column; align-items: stretch; gap: 4px; text-align: center; font-size: 12.5px; min-width: 0; } +.jp-monat b { font-size: 12px; font-variant-numeric: tabular-nums; } +.jp-saeule-feld { height: 120px; display: flex; align-items: flex-end; cursor: ns-resize; touch-action: none; border-bottom: 1px solid var(--linie); } +.jp-saeule { width: 100%; background: var(--g-vorgang-rand); border-radius: 5px 5px 0 0; } +.jp-monat.tief .jp-saeule { background: var(--akzent); } +.jp-saeule:focus-visible { outline: 2px solid var(--akzent); outline-offset: 2px; } +.jp-monat label { display: flex; flex-direction: column; gap: 2px; color: var(--leise); } +.jp-monat input { width: 100%; text-align: center; border: 1px solid var(--eingabe-linie); background: var(--eingabe-bg); color: var(--eingabe-text); border-radius: 6px; padding: 3px 2px; font: inherit; font-size: 12.5px; } +.jp-monat label i { display: none; } +.jp-summe { color: var(--warnung-text); margin: 10px 0 0; font-size: 14px; } +.jp-tabelle .liste { overflow-x: auto; } +.jp-monatsplan td, .jp-monatsplan th { white-space: nowrap; font-variant-numeric: tabular-nums; font-size: 13.5px; padding: 6px 7px; } +.jp-monatsplan tr.jp-summe-zeile td { font-weight: 600; border-top: 2px solid var(--linie); } +.jp-monatsplan tr.jp-klein td { color: var(--leise); font-size: 13px; } +.jp-monatsplan .aus { color: var(--warn); } +.jp-monatsplan .ein { color: var(--gut-text); } +.jp-monatsplan .jp-tief { background: var(--warnung-bg); color: var(--warnung-text); padding: 2px 4px; border-radius: 4px; } +.jp-pi-kopf { display: flex; gap: 12px; align-items: center; flex-wrap: wrap; } +.jp-monatswahl { display: flex; gap: 4px; flex-wrap: wrap; } +.jp-monatswahl .chip-knopf { font-size: 13px; padding: 4px 9px; color: var(--leise); } +.jp-monatswahl .chip-knopf.mit { color: var(--text); font-weight: 600; } +.jp-monatswahl .chip-knopf.an { color: var(--akzent); } +.knopf-datei { margin-left: auto; cursor: pointer; } +label.haupt { display: inline-block; background: var(--akzent); color: var(--akzent-text); border-radius: 8px; padding: 10px 18px; font-weight: 600; } +label.haupt:hover { background: var(--akzent-hover); } +label.haupt:focus-within { outline: 2px solid var(--akzent); outline-offset: 2px; } +#jp-bwa-fehler:empty { display: none; } +.jp-kennzahlen { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 12px; } +.jp-kz { display: flex; flex-direction: column; gap: 2px; border-top: 4px solid var(--linie); } +.jp-kz b { font-size: 26px; font-variant-numeric: tabular-nums; } +.jp-kz small { color: var(--leise); } +.jp-kz.gut { border-top-color: var(--gut-text); } +.jp-kz.schlecht { border-top-color: var(--warn); } +.jp-kz.schlecht b { color: var(--warn); } +.jp-pi td { font-variant-numeric: tabular-nums; } +.jp-pi tr.jp-summe-zeile td { font-weight: 600; border-top: 2px solid var(--linie); } +.jp-pi tr.jp-gelb td { background: var(--eingabe-bg); color: var(--eingabe-text); } +.jp-pi tr.jp-rot td { background: var(--warnung-bg); color: var(--warnung-text); } +.jp-pi tr.jp-gut td.zahl:nth-last-child(2) { color: var(--gut-text); } +input.jp-notiz { width: 100%; min-width: 140px; border: 1px solid var(--linie); border-radius: 6px; padding: 5px 8px; background: var(--fl); color: var(--text); font: inherit; font-size: 13.5px; } +.jp-zu { width: 100%; border-collapse: collapse; font-size: 14px; margin-top: 10px; } +.jp-zu th, .jp-zu td { padding: 5px 8px; border-bottom: 1px solid var(--linie); text-align: left; } +.jp-zu td.zahl, .jp-zu th.zahl { text-align: right; font-variant-numeric: tabular-nums; } +.jp-zu tr.leise td { color: var(--leise); } +.jp-zu select { padding: 5px 8px; border: 1px solid var(--linie); border-radius: 6px; background: var(--fl); color: var(--text); font: inherit; font-size: 13.5px; max-width: 100%; } +.jp-sitzung h2 { font-size: 17px; margin: 0 0 8px; } +.jp-sitzung ul { list-style: none; padding: 0; margin: 0 0 8px; display: flex; flex-direction: column; gap: 6px; } +.jp-sitzung li.spaeter { color: var(--leise); } +.jp-sitzung label { display: flex; gap: 8px; align-items: flex-start; } +.erfolg-text { color: var(--gut-text); font-weight: 600; font-size: 13.5px; } +.start-jahresplan { display: flex; flex-wrap: wrap; gap: 4px 12px; align-items: center; margin-top: 12px; padding-top: 10px; border-top: 1px solid var(--linie); } +.start-jahresplan a { color: var(--text); text-decoration: none; } +.start-jahresplan a:hover { color: var(--akzent); } +.jp-balken { flex-basis: 100%; height: 6px; border-radius: 99px; background: var(--linie); overflow: hidden; } +.jp-balken i { display: block; height: 100%; background: var(--gut-text); } +.liqui-plan-hinweis { margin-top: 4px; } +@media (max-width: 1100px) { + .jp-raster { grid-template-columns: minmax(0, 1fr); } + .jp-rechts { position: static; } +} +@media (max-width: 800px) { + .jp-schritte { grid-template-columns: repeat(2, minmax(0, 1fr)); } + .jp-editor, .jp-felder { grid-template-columns: minmax(0, 1fr); } + .jp-kennzahlen { grid-template-columns: minmax(0, 1fr); } + .jp-saison { grid-template-columns: repeat(6, minmax(0, 1fr)); } + .jp-saeule-feld { height: 80px; } + .jp-treppe td { padding: 6px 3px; } + .jp-mitte { display: none; } + .jp-q { white-space: normal; } + .jp-knapp { flex-direction: column; } + .knopf-datei { margin-left: 0; } +} +.jp-monate .karte-kopf { flex-wrap: wrap; gap: 8px; } diff --git a/test/daten/datev-bwa-muster.xls b/test/daten/datev-bwa-muster.xls new file mode 100644 index 0000000..81c72a4 --- /dev/null +++ b/test/daten/datev-bwa-muster.xls @@ -0,0 +1,4605 @@ + + + + + + + + + + + + + + + + + + + + + + + + + +
+ 1528239/21025 + + BWA-Wertenachweis zum 31.08.2026 + + Sendedatum: 12.10.2026 19:25:20 +   +
+ Schaarschmidt H + + Einnahmen-Ausgaben-BWA +   + + Währung EUR +
  +   +   +   +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Zeile
+
+
+ Bezeichnung
+
+
+ Konto
+
+
  + + Konten-/
+Zeilenbeschriftung
+
+ Fkt.-Schl.
+
+
+ Aug/2026
+Konten/Zeilen
+
+ BWA-Werte
+
+
+ Jan/2026 - Aug/2026
+Konten/Zeilen
+
+ BWA-Werte
+
+
+ 1040 + + betrieblicher Tätigkeit + + 433700 +   + + Erlöse aus Leistungen nach § 13b UStG +   + + 0,00 + + 59.653,91 + + 2.693,00 + + 115.348,80 +
  +   + + 440000 +   + + Erlöse 19% USt Holzbau +   + + 59.653,91 +   + + 112.655,81 +   +
  +   + + 473600 +   + + Gewährte Skonti 19 % USt +   + + 0,00 +   + + -0,01 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1050 + + Sonstige Erlöse + + 463900 +   + + Verwendung von Gegenst.(Fzg) ohne USt +   + + 76,40 + + 382,00 + + 611,20 + + 3.056,00 +
  +   + + 464500 +   + + Verwendung von Gegenst. (Fzg) 19% USt +   + + 305,60 +   + + 2.444,80 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1060 + + = Summe der Erlöse + + 1040 +   + + betrieblicher Tätigkeit +   + + 59.653,91 + + 60.035,91 + + 115.348,80 + + 118.404,80 +
  +   + + 1050 +   + + Sonstige Erlöse +   + + 382,00 +   + + 3.056,00 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1100 + + Umsatzsteuer + + 380600 +   + + Umsatzsteuer 19% +   + + 3.484,77 + + 3.484,77 + + 20.967,32 + + 20.967,32 +
  +   +   +   +   +   +   +   +   +   +
+ 1110 + + Umsatzsteuer-Erstattung +   +   +   +   + + 0,00 + + 0,00 + + 0,00 + + 0,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1140 + + Erhaltene Anzahlungen + + 327200 +   + + Erhaltene Anzahlungen 19% USt +   + + -41.618,54 + + -41.618,54 + + -4.745,97 + + -4.745,97 +
  +   +   +   +   +   +   +   +   +   +
+ 1160 + + - Zugang Forderungen + + 120000 +   + + Forderungen aus L+L +   + + -4.990,85 + + -4.990,85 + + 14.622,06 + + 14.622,06 +
  +   +   +   +   +   +   +   +   +   +
+ 1180 + + Betriebseinnahmen + + 1060 +   + + Summe der Erlöse +   + + 60.035,91 + + 26.892,99 + + 118.404,80 + + 120.004,09 +
  +   + + 1100 +   + + Umsatzsteuer +   + + 3.484,77 +   + + 20.967,32 +   +
  +   + + 1110 +   + + Umsatzsteuer-Erstattung +   + + 0,00 +   + + 0,00 +   +
  +   + + 1140 +   + + Erhaltene Anzahlungen +   + + -41.618,54 +   + + -4.745,97 +   +
  +   + + 1160 +   + + - Zugang Forderungen +   + + -4.990,85 +   + + 14.622,06 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1230 + + Material-/Wareneinkauf + + 540000 +   + + Wareneingang 19% Vorsteuer +   + + 10.198,38 + + 10.068,39 + + 41.555,89 + + 41.367,01 +
  +   + + 573600 +   + + Erhaltene Skonti 19% Vorsteuer +   + + -129,99 +   + + -328,39 +   +
  +   + + 580010 +   + + Frachten und andere Bezugskosten +   + + 0,00 +   + + 139,51 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1240 + + Fremdleistungen + + 590600 +   + + Fremdleistungen 19% Vorsteuer +   + + 670,00 + + 670,00 + + 806,95 + + 806,95 +
  +   +   +   +   +   +   +   +   +   +
+ 1250 + + Personalkosten + + 600000 +   + + Löhne und Gehälter +   + + 0,00 + + 0,00 + + 82,50 + + 5.544,07 +
  +   + + 601070 +   + + Löhne gewerblich +   + + 0,00 +   + + 3.357,75 +   +
  +   + + 603600 +   + + Pauschale Steuer für Minijobber +   + + 0,00 +   + + 68,76 +   +
  +   + + 611000 +   + + Gesetzliche Sozialaufwendungen +   + + 0,00 +   + + 968,45 +   +
  +   + + 611010 +   + + Umlage EFZ und MSG +   + + 0,00 +   + + 35,07 +   +
  +   + + 611073 +   + + Winterbeschäftigungs-Umlage gew. +   + + 0,00 +   + + 20,64 +   +
  +   + + 612000 +   + + Beiträge zur Berufsgenossenschaft +   + + 0,00 +   + + 315,97 +   +
  +   + + 615010 +   + + SOKA-Beiträge +   + + 0,00 +   + + 694,93 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1260 + + Raumkosten +   +   +   +   + + 0,00 + + 0,00 + + 0,00 + + 0,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1270 + + Steuern/Versicherungen/Beiträge + + 642000 +   + + Beiträge +   + + 0,00 + + 0,00 + + 1.530,00 + + 1.530,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1280 + + Fahrzeugkosten + + 652000 +   + + Fahrzeug-Versicherungen +   + + 0,00 + + 213,85 + + 192,04 + + 2.047,11 +
  +   + + 653000 +   + + Laufende Fahrzeug-Betriebskosten +   + + 0,00 +   + + 841,92 +   +
  +   + + 653070 +   + + Lfd. Fzg-Betriebskosten gewerblich +   + + 213,85 +   + + 213,85 +   +
  +   + + 654000 +   + + Fahrzeug-Reparaturen +   + + 0,00 +   + + 614,30 +   +
  +   + + 768500 +   + + Kfz-Steuern +   + + 0,00 +   + + 185,00 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1290 + + Werbe-/Reisekosten + + 668000 +   + + Reisekosten UN Übernacht./Nebenkost +   + + 0,00 + + 0,00 + + 12,61 + + 12,61 +
  +   +   +   +   +   +   +   +   +   +
+ 1300 + + Kosten Warenabgabe +   +   +   +   + + 0,00 + + 0,00 + + 0,00 + + 0,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1310 + + Instandhaltung/Werkzeuge + + 684500 +   + + Werkzeuge und Kleingeräte +   + + 0,00 + + 0,00 + + 124,88 + + 124,88 +
  +   +   +   +   +   +   +   +   +   +
+ 1320 + + Abschreibungen + + 622000 +   + + Abschreibungen auf Sachanlagen +   + + 57,25 + + 546,25 + + 457,99 + + 4.369,99 +
  +   + + 622200 +   + + Abschreibungen auf Fahrzeuge +   + + 489,00 +   + + 3.912,00 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1330 + + Verschiedene Kosten + + 681500 +   + + Bürobedarf +   + + 257,69 + + 630,11 + + 275,24 + + 6.733,23 +
  +   + + 682000 +   + + Zeitschrift./Bücher/dig.Medien(Fachlit.) +   + + 23,36 +   + + 147,04 +   +
  +   + + 682100 +   + + Fortbildungskosten +   + + 0,00 +   + + 1.460,00 +   +
  +   + + 682700 +   + + Abschluss- und Prüfungskosten +   + + 0,00 +   + + 907,40 +   +
  +   + + 683000 +   + + Buchführungskosten +   + + 126,50 +   + + 2.041,50 +   +
  +   + + 683500 +   + + Mieten für Einrichtungen bewegliche WG +   + + 0,00 +   + + 187,50 +   +
  +   + + 683700 +   + + Aufwendungen für Lizenzen, Konzessionen +   + + 139,90 +   + + 792,33 +   +
  +   + + 685000 +   + + Sonstiger Betriebsbedarf +   + + 0,00 +   + + 9,20 +   +
  +   + + 685010 +   + + Arbeitskleidung +   + + 0,00 +   + + 209,96 +   +
  +   + + 685011 +   + + Arbeitsschutzkleidung +   + + 0,00 +   + + 164,96 +   +
  +   + + 685500 +   + + Nebenkosten des Geldverkehrs +   + + 34,16 +   + + 146,98 +   +
  +   + + 685970 +   + + Baustellenentsorg./Toiletten gew. +   + + 48,50 +   + + 48,50 +   +
  +   + + 685971 +   + + Abraum-/Abfallbes.,Kipp-/Deponiegeb.gew +   + + 0,00 +   + + 342,62 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1340 + + = Summe der Kosten + + 1230 +   + + Mat.Stoffe u. Waren +   + + 10.068,39 + + 12.128,60 + + 41.367,01 + + 62.535,85 +
  +   + + 1240 +   + + Fremdleistungen +   + + 670,00 +   + + 806,95 +   +
  +   + + 1250 +   + + Personalkosten +   + + 0,00 +   + + 5.544,07 +   +
  +   + + 1260 +   + + Raumkosten +   + + 0,00 +   + + 0,00 +   +
  +   + + 1270 +   + + Steuern/Versicherungen/Beiträge +   + + 0,00 +   + + 1.530,00 +   +
  +   + + 1280 +   + + Fahrzeugkosten +   + + 213,85 +   + + 2.047,11 +   +
  +   + + 1290 +   + + Werbe-/Reisekosten +   + + 0,00 +   + + 12,61 +   +
  +   + + 1300 +   + + Kosten Warenabgabe +   + + 0,00 +   + + 0,00 +   +
  +   + + 1310 +   + + Instandhaltung/Werkzeuge +   + + 0,00 +   + + 124,88 +   +
  +   + + 1320 +   + + Abschreibungen +   + + 546,25 +   + + 4.369,99 +   +
  +   + + 1330 +   + + Verschiedene Kosten +   + + 630,11 +   + + 6.733,23 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1380 + + Geleistete Anzahlungen +   +   +   +   + + 0,00 + + 0,00 + + 0,00 + + 0,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1400 + + Buchwert Anlagenabgänge +   +   +   +   + + 0,00 + + 0,00 + + 0,00 + + 0,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1410 + + Sonstige Aufwendungen + + 730300 +   + + Abzugsfäh. and. Nebenleist. zu Steuern +   + + 0,00 + + 0,00 + + 29,00 + + 29,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1430 + + Vorsteuer + + 140000 +   + + Abziehbare Vorsteuer +   + + 6,49 + + 2.139,67 + + 486,03 + + 9.806,98 +
  +   + + 140100 +   + + Abziehbare Vorsteuer 7% +   + + 1,63 +   + + 10,29 +   +
  +   + + 140600 +   + + Abziehbare Vorsteuer 19% +   + + 2.131,55 +   + + 9.310,66 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1440 + + Umsatzsteuer-Zahlung + + 382000 +   + + Umsatzsteuer-Vorauszahlungen +   + + 1.634,43 + + 1.634,43 + + 7.046,29 + + 12.965,64 +
  +   + + 383000 +   + + Umsatzsteuer-Vorauszahlungen 1/11 +   + + 0,00 +   + + 849,00 +   +
  +   + + 384000 +   + + Umsatzsteuer laufendes Jahr +   + + 0,00 +   + + 947,79 +   +
  +   + + 384100 +   + + Umsatzsteuerverbindlichkeiten Vorjahr +   + + 0,00 +   + + 4.122,56 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1460 + + - Verrechnete kalkulatorische Kosten +   +   +   +   + + 0,00 + + 0,00 + + 0,00 + + 0,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1470 + + - Zugang Verbindlichkeiten + + 145700 +   + + Forderung gegenüber Bundesagentur +   + + 0,00 + + -1.584,80 + + -82,50 + + 10.305,68 +
  +   + + 330000 +   + + Verbindlichkeiten aus Lieferungen+Leist. +   + + -1.584,80 +   + + 11.087,05 +   +
  +   + + 372000 +   + + Verbindlichkeiten aus Lohn und Gehalt +   + + 0,00 +   + + -523,76 +   +
  +   + + 373000 +   + + Verbindlichk. Lohn- und Kirchensteuer +   + + 0,00 +   + + -86,96 +   +
  +   + + 374000 +   + + Verbindlichkeiten soziale Sicherheit +   + + 0,00 +   + + 82,70 +   +
  +   + + 374010 +   + + Verbindl. an Sozialkassen (SOKA) +   + + 0,00 +   + + -205,30 +   +
  +   + + 374011 +   + + Verbindl. Winterbeschäftigungs-Uml. +   + + 0,00 +   + + 34,41 +   +
  +   + + 375900 +   + + Voraus.Beitrag ggb. Sozialversich.träger +   + + 0,00 +   + + 0,04 +   +
  +   + + 379000 +   + + Lohn- und Gehaltsverrechnungen +   + + 0,00 +   + + 0,00 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1490 + + Betriebsausgaben + + 1340 +   + + Summe der Kosten +   + + 12.128,60 + + 17.487,50 + + 62.535,85 + + 75.031,79 +
  +   + + 1380 +   + + Geleistete Anzahlungen +   + + 0,00 +   + + 0,00 +   +
  +   + + 1400 +   + + Buchwert Anlagenabgänge +   + + 0,00 +   + + 0,00 +   +
  +   + + 1410 +   + + Sonstige Aufwendungen +   + + 0,00 +   + + 29,00 +   +
  +   + + 1430 +   + + Vorsteuer +   + + 2.139,67 +   + + 9.806,98 +   +
  +   + + 1440 +   + + Umsatzsteuer-Zahlung +   + + 1.634,43 +   + + 12.965,64 +   +
  +   + + 1460 +   + + - Verrechnete kalkulatorische Kosten +   + + 0,00 +   + + 0,00 +   +
  +   + + 1470 +   + + - Zugang Verbindlichkeiten +   + + -1.584,80 +   + + 10.305,68 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1520 + + Einnahmen-Ausgaben-BWA + + 1180 +   + + Betriebseinnahmen +   + + 26.892,99 + + 9.405,49 + + 120.004,09 + + 44.972,30 +
  +   + + 1490 +   + + Betriebsausgaben +   + + 17.487,50 +   + + 75.031,79 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1660 + + Vorläufiges Ergebnis +   +   + + Vorläufiges Ergebnis +   + + 9.405,49 + + 9.405,49 + + 44.972,30 + + 44.972,30 +
  +   +   +   +   +   +   +   +   +   +
+ 1681 + + (nicht kalkulatorisch) + + 622000 +   + + Abschreibungen auf Sachanlagen +   + + 57,25 + + 546,25 + + 457,99 + + 4.369,99 +
  +   + + 622200 +   + + Abschreibungen auf Fahrzeuge +   + + 489,00 +   + + 3.912,00 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1690 + + + Aufnahme Darlehen +   +   +   +   + + 0,00 + + 0,00 + + 0,00 + + 0,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1700 + + - Tilgung Darlehen + + 356000 +   + + Finanzierung VITO Mercedes Benz +   + + 300,43 + + 300,43 + + 2.403,44 + + 2.403,44 +
  +   +   +   +   +   +   +   +   +   +
+ 1710 + + - Anlagenzugänge +   +   +   +   + + 0,00 + + 0,00 + + 0,00 + + 0,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1712 + + + Anlagenabgänge +   +   +   +   + + 0,00 + + 0,00 + + 0,00 + + 0,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1720 + + +/- Sonstige Posten +   +   +   +   + + 0,00 + + 0,00 + + 0,00 + + 0,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1740 + + Liquiditätsbeitrag Betrieb + + 1660 +   + + Vorläufiges betriebswirtschaftliches Ergebnis Einnahmen-Ausgaben-BWA +   + + 9.405,49 + + 9.651,31 + + 44.972,30 + + 46.938,85 +
  +   + + 1681 +   + + + Abschreibungen (nicht kalkulatorisch) +   + + 546,25 +   + + 4.369,99 +   +
  +   + + 1690 +   + + + Aufnahme Darlehen +   + + 0,00 +   + + 0,00 +   +
  +   + + 1700 +   + + - Tilgung Darlehen +   + + 300,43 +   + + 2.403,44 +   +
  +   + + 1710 +   + + - Anlagenzugänge +   + + 0,00 +   + + 0,00 +   +
  +   + + 1712 +   + + + Anlagenabgänge +   + + 0,00 +   + + 0,00 +   +
  +   + + 1720 +   + + +/- Sonstige Posten +   + + 0,00 +   + + 0,00 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1770 + + Privateinlagen + + 218000 +   + + Privateinlagen (VH), EK +   + + 0,00 + + 0,00 + + 9.721,87 + + 9.721,87 +
  +   +   +   +   +   +   +   +   +   +
+ 1780 + + + Grundstücksertrag +   +   +   +   + + 0,00 + + 0,00 + + 0,00 + + 0,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1790 + + - Grundstücksaufwand +   +   +   +   + + 0,00 + + 0,00 + + 0,00 + + 0,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1800 + + - Privatentnahmen + + 210000 +   + + Privatentnahmen allgemein (VH), EK +   + + 6.900,00 + + 6.900,00 + + 43.484,66 + + 43.484,66 +
  +   +   +   +   +   +   +   +   +   +
+ 1805 + + - Unentgeltliche Wertabgaben + + 213000 +   + + Unentgeltliche Wertabgaben (VH), EK +   + + 440,06 + + 440,06 + + 3.520,48 + + 3.520,48 +
  +   +   +   +   +   +   +   +   +   +
+ 1810 + + - Privatsteuern + + 215000 +   + + Privatsteuern (VH), EK +   + + 0,00 + + 0,00 + + 3.375,00 + + 3.551,00 +
  +   + + 915900 +   + + Privatsteuern Kirchensteuer (VH) +   + + 0,00 +   + + 176,00 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1820 + + - Sonderausgaben/Spenden + + 220000 +   + + Krankenkasse +   + + 280,14 + + 280,14 + + 7.907,49 + + 7.907,49 +
  +   +   +   +   +   +   +   +   +   +
+ 1830 + + - Außergewöhnliche Belastungen +   +   +   +   + + 0,00 + + 0,00 + + 0,00 + + 0,00 +
  +   +   +   +   +   +   +   +   +   +
+ 1840 + + Liquiditätsbeitrag Privat + + 1770 +   + + Privateinlagen +   + + 0,00 + + -7.620,20 + + 9.721,87 + + -48.741,76 +
  +   + + 1780 +   + + + Grundstücksertrag +   + + 0,00 +   + + 0,00 +   +
  +   + + 1790 +   + + - Grundstücksaufwand +   + + 0,00 +   + + 0,00 +   +
  +   + + 1800 +   + + - Privatentnahmen +   + + 6.900,00 +   + + 43.484,66 +   +
  +   + + 1805 +   + + - Unentgeltliche Wertabgaben +   + + 440,06 +   + + 3.520,48 +   +
  +   + + 1810 +   + + - Privatsteuern +   + + 0,00 +   + + 3.551,00 +   +
  +   + + 1820 +   + + - Sonderausgaben/Spenden +   + + 280,14 +   + + 7.907,49 +   +
  +   + + 1830 +   + + - Außergewöhnliche Belastungen +   + + 0,00 +   + + 0,00 +   +
  +   +   +   +   +   +   +   +   +   +
+ 1870 + + über-/-unterdeckung + + 1740 +   + + Liquiditätsbeitrag Betrieb +   + + 9.651,31 + + 2.031,11 + + 46.938,85 + + -1.802,91 +
  +   + + 1840 +   + + Liquiditätsbeitrag Privat +   + + -7.620,20 +   + + -48.741,76 +   +
+ + + + + + + + + +
  + + SKR 04 BWA Nr. 01 BWA Form 43 Wareneinsatz K51 +
  + + Werte in EUR +
+ + \ No newline at end of file diff --git a/test/jahresplan.test.ts b/test/jahresplan.test.ts new file mode 100644 index 0000000..6174162 --- /dev/null +++ b/test/jahresplan.test.ts @@ -0,0 +1,193 @@ +// Jahresfinanzplanung (Stufe 5): Treppe, Monatsplan, Vorschläge, BWA einlesen, Plan/Ist und Liquiditäts-Vorschau +import { describe, it, expect, beforeAll, afterAll } from "vitest"; +import { readFileSync } from "node:fs"; +import type { FastifyInstance } from "fastify"; +import { type PlanDaten, leererPlan, rechne, vorschlaege, knappText, verteile, annuitaet, planPosten } from "../src/domain/jahresplan.js"; +import { liesBwa, istWerte, zuordnungVorschlag, planIst, betrag } from "../src/domain/bwa.js"; +import { erstellePool, type Pool } from "../src/server/db.js"; +import { migriere } from "../src/server/migrate.js"; +import { baueApp } from "../src/server/app.js"; +import { ersterFreitag, saisonAus } from "../src/server/jahresplan.js"; + +/** das Beispiel aus dem Entwurf (finanzen/entwurf-jahresplan) */ +function entwurf(): PlanDaten { + const d = leererPlan({ stundensatz: 6200, materialEinkauf: 12_000_000, subEinkauf: 6_000_000, laufendMonat: 320_000, preissteigerung: 0, + werbungMonat: 25_000, afaBisher: 50_000, kontostandStart: 1_308_000, mindestgrenze: 600_000, steuerQuartal: 200_000 }); + d.mitarbeiter = [ + { id: "h", name: "Henning", art: "inhaber", stunden: 900, brutto: 450_000, faktor: 1, eintritt: 1, austritt: 12, neu: false }, + { id: "g1", name: "Geselle 1", art: "angestellt", stunden: 1400, brutto: 340_000, faktor: 1.25, eintritt: 4, austritt: 12, neu: true }, + { id: "g2", name: "Geselle 2", art: "angestellt", stunden: 1400, brutto: 340_000, faktor: 1.25, eintritt: 4, austritt: 12, neu: true }, + ]; + d.investitionen = [{ id: "t", name: "Transporter", betrag: 4_500_000, monat: 3, art: "kredit", anzahlung: 900_000, laufzeit: 60, zins: 5, rate: 0, nutzungsdauer: 6 }]; + return d; +} + +const bwaText = () => new TextDecoder("windows-1252").decode(readFileSync(new URL("./daten/datev-bwa-muster.xls", import.meta.url))); + +describe("Jahresplan rechnen", () => { + it("Treppe wie im Entwurf: 3.000 Std × 62 € + Material/Sub = 390.000 € Umsatz, Rohertrag 210.000 €", () => { + const t = rechne(entwurf()).treppe; + expect(t.stunden).toBe(3000); + expect(t.umsatz).toBe(39_000_000); + expect(t.rohertrag).toBe(21_000_000); + expect(t.personalWerbung).toBe(13_350_000); + expect(t.quotePersonal).toBe(63.6); + expect(t.ampelPersonal).toBe("rot"); + // Gewinn = Rohertrag − Personal/Werbung − laufende Kosten (mit Zinsen) − AfA + expect(t.gewinn).toBe(t.rohertrag - t.personalWerbung - t.laufend - t.afa); + expect(t.quoteGewinn).toBeCloseTo(14.3, 1); + expect(t.luecke).toBe(Math.ceil(t.rohertrag * 0.2) - t.gewinn); + }); + + it("Monatsplan: Umsatz nach Saison, Summe genau, knappster Monat April", () => { + const r = rechne(entwurf()); + expect(r.monate.umsatz.reduce((a, b) => a + b, 0)).toBe(39_000_000); + expect(r.monate.umsatz[0]).toBe(1_560_000); + expect(r.monate.personal[2]).toBe(0); + expect(r.monate.personal[3]).toBe(850_000); + expect(r.tief.monat).toBe(4); + const k = knappText(entwurf(), r); + expect(k.satz).toMatch(/^Am knappsten wird es Ende April mit 7\.30\d €/); + expect(k.grund).toContain("Transporter wird angezahlt"); + }); + + it("Kredit: Anzahlung im Kaufmonat, danach Annuität; AfA ab dem Kaufmonat", () => { + const r = rechne(entwurf()); + const v = r.investitionen[0]!; + expect(v.rate).toBe(annuitaet(3_600_000, 5, 60)); + expect(v.abfluss[2]).toBe(900_000); + expect(v.abfluss[3]).toBe(v.rate); + expect(v.afaJahr).toBe(Math.round((4_500_000 / 72) * 10)); + }); + + it("verteile hält die Summe", () => { + expect(verteile(100, [1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0])).toEqual([34, 33, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0]); + }); + + it("Vorschläge schließen die Lücke jeder für sich", () => { + const v = vorschlaege(entwurf()); + expect(v.map((x) => x.id)).toEqual(["satz", "material", "sub"]); + for (const x of v) expect(rechne(x.daten).treppe.luecke).toBe(0); + expect(v[0]!.text).toBe("Stundensatz 62 € → 67 €"); + }); + + it("Vorschau für die Liquidität: nur der Rest über den echten Posten, ab dem nächsten Monat", () => { + const echte = [{ datum: "2027-05-20", gruppe: "Projekteinnahmen" as const, bezeichnung: "Abschlag", betrag: 2_380_000 }]; + const p = planPosten(echte, [{ jahr: 2027, daten: entwurf() }], "2027-04-10", 19); + expect(p.some((x) => x.datum.startsWith("2027-04"))).toBe(false); + const mai = p.find((x) => x.bezeichnung === "Plan: weitere Einnahmen Mai 2027")!; + expect(mai.betrag).toBe(3_900_000 - 2_000_000); + expect(p.find((x) => x.bezeichnung === "Plan: Löhne neue Mitarbeiter Mai 2027")!.betrag).toBe(-850_000); + }); +}); + +describe("BWA einlesen", () => { + it("liest das DATEV-Muster: August 2026, Zeilen mit Monats- und kumulierten Werten", () => { + const b = liesBwa(bwaText()); + expect(b).toMatchObject({ jahr: 2026, monat: 8, art: "Einnahmen-Ausgaben-BWA" }); + const z = (n: number) => b.zeilen.find((x) => x.zeile === n)!; + expect(z(1040)).toMatchObject({ monat: 5_965_391, kumuliert: 11_534_880, summe: false }); + expect(z(1040).konten[1]).toMatchObject({ konto: "440000", kumuliert: 11_265_581 }); + expect(z(1280)).toMatchObject({ monat: 21_385, kumuliert: 204_711 }); + expect(z(1060).summe).toBe(true); + expect(z(1660).summe).toBe(true); + }); + + it("ordnet die Zeilen vor und rechnet Ist-Werte", () => { + const b = liesBwa(bwaText()); + const zu = new Map(b.zeilen.map((z) => [z.zeile, zuordnungVorschlag(z)])); + expect(zu.get(1230)).toBe("material"); + expect(zu.get(1800)).toBe("unternehmerlohn"); + expect(zu.get(1100)).toBe("ignorieren"); + const ist = istWerte(b.zeilen, zu, true); + expect(ist.umsatz).toBe(11_840_480); + expect(ist.material).toBe(4_136_701 + 80_695); + }); + + it("Beträge mit Tausenderpunkt und Minus", () => { + expect(betrag("59.653,91")).toBe(5_965_391); + expect(betrag("-0,01")).toBe(-1); + expect(betrag("")).toBeNull(); + }); + + it("Plan/Ist färbt ab 5 % Abweichung", () => { + const r = rechne(entwurf()); + const { zeilen, kennzahlen } = planIst(r, { umsatz: 3_900_000, material: 2_135_000, personal: 850_000, unternehmerlohn: 450_000, werbung: 25_000, laufend: 330_000, afa: 0, tilgung: 0, investition: 0, steuer: 0 }, 5, false); + const m = zeilen.find((z) => z.id === "material")!; + expect(m.stufe).toBe("rot"); + expect(zeilen.find((z) => z.id === "umsatz")!.stufe).toBe(""); + expect(kennzahlen.map((k) => k.id)).toEqual(["rohertrag", "personal", "gewinn"]); + }); + + it("Saison aus Vorjahresumsätzen und erster Freitag", () => { + expect(saisonAus([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]).reduce((a, b) => a + b, 0)).toBe(100); + expect(ersterFreitag(2026, 11)).toBe("2026-11-06"); + expect(ersterFreitag(2027, 1)).toBe("2027-01-01"); + }); +}); + +const url = process.env.TEST_DATABASE_URL; + +describe.skipIf(!url)("Jahresplan über die API", () => { + let pool: Pool; + let app: FastifyInstance; + beforeAll(async () => { + pool = erstellePool(url!); + await pool.query("drop schema public cascade; create schema public;"); + await migriere(pool); + app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" }); + }); + afterAll(async () => { await app?.close(); await pool?.end(); }); + + it("erste Version ist Basis und gilt; weitere Versionen, Basis bleibt", async () => { + await app.inject({ method: "POST", url: "/api/laufende-kosten", payload: { bezeichnung: "Gehalt Eigner", kategorie: "Personalkosten Henning", betrag: 400_000, rhythmus: "monatlich", start: "2026-01-01" } }); + await app.inject({ method: "POST", url: "/api/laufende-kosten", payload: { bezeichnung: "Versicherung", kategorie: "Versicherung", betrag: 120_000, rhythmus: "jaehrlich", start: "2026-01-01" } }); + const b = await app.inject({ method: "POST", url: "/api/jahresplan", payload: { jahr: 2027 } }); + expect(b.statusCode, b.body).toBe(201); + expect(b.json()).toMatchObject({ basis: true, gilt: true, name: "Basis" }); + const d = b.json().daten as PlanDaten; + expect(d.annahmen.laufendMonat).toBe(10_000); + expect(d.mitarbeiter[0]).toMatchObject({ art: "inhaber", brutto: 400_000 }); + const v = await app.inject({ method: "POST", url: "/api/jahresplan", payload: { jahr: 2027, von: b.json().id, name: "Mit 3. Geselle" } }); + expect(v.json()).toMatchObject({ basis: false, gilt: false }); + const g = await app.inject({ method: "PATCH", url: `/api/jahresplan/${v.json().id}`, payload: { gilt: true } }); + expect(g.json().gilt).toBe(true); + expect((await app.inject({ method: "DELETE", url: `/api/jahresplan/${b.json().id}` })).statusCode).toBe(409); + expect((await app.inject({ method: "DELETE", url: `/api/jahresplan/${v.json().id}` })).statusCode).toBe(204); + const l = (await app.inject("/api/jahresplan?jahr=2027")).json(); + expect(l.versionen).toHaveLength(1); + expect(l.versionen[0].gilt).toBe(true); + }); + + it("Finanzsitzung als Aufgabe, nur einmal je Monat", async () => { + await app.inject("/api/jahresplan?jahr=2027"); + await app.inject("/api/jahresplan?jahr=2027"); + const a = (await app.inject("/api/aufgaben")).json().filter((x: { text: string }) => x.text.startsWith("Finanzsitzung")); + expect(a).toHaveLength(1); + expect(new Date(a[0].faellig_am).getUTCDay() === 5 || typeof a[0].faellig_am === "string").toBe(true); + }); + + it("BWA einlesen, Zuordnung ändern, Plan/Ist", async () => { + await app.inject({ method: "POST", url: "/api/jahresplan", payload: { jahr: 2026 } }); + const r = await app.inject({ method: "POST", url: "/api/bwa", payload: { dateiname: "bwa.xls", inhalt: bwaText() } }); + expect(r.statusCode, r.body).toBe(201); + expect(r.json()).toMatchObject({ jahr: 2026, monat: 8 }); + const pi = (await app.inject("/api/jahresplan/planist?jahr=2026&monat=8&kumuliert=1")).json(); + expect(pi.zeilen.find((z: { id: string }) => z.id === "umsatz").ist).toBe(11_840_480); + await app.inject({ method: "PUT", url: "/api/bwa/zuordnung/1050", payload: { planzeile: "ignorieren" } }); + const pi2 = (await app.inject("/api/jahresplan/planist?jahr=2026&monat=8&kumuliert=1")).json(); + expect(pi2.zeilen.find((z: { id: string }) => z.id === "umsatz").ist).toBe(11_534_880); + const n = await app.inject({ method: "PUT", url: "/api/finanzmonat/2026/8", payload: { notizen: { material: "Holz teurer" }, erledigt: ["bwa"] } }); + expect(n.json()).toMatchObject({ notizen: { material: "Holz teurer" }, erledigt: ["bwa"] }); + const kaputt = await app.inject({ method: "POST", url: "/api/bwa", payload: { inhalt: "kein HTML" } }); + expect(kaputt.statusCode).toBe(400); + }); + + it("Liquidität rechnet den geltenden Plan als Vorschau mit; Mitarbeiter dürfen nicht", async () => { + const r = (await app.inject("/api/liquiditaet?ansicht=monat&anzahl=24")).json(); + expect(r.flatMap((p: { posten: { gruppe: string }[] }) => p.posten).some((x: { gruppe: string }) => x.gruppe === "Jahresplan")).toBe(true); + const sicherung = (await app.inject("/api/export")).json(); + expect(sicherung.daten.jahresplaene.length).toBeGreaterThan(0); + expect(sicherung.daten.finanz_monate.length).toBeGreaterThan(0); + }); +});