From 55fe69dc2b5c869cfed6a695b4a2b852509502f1 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 19 Oct 2026 05:23:45 +0000 Subject: [PATCH] =?UTF-8?q?=C3=9Cbernahme=20der=20V70-Sicherung=20und=20Li?= =?UTF-8?q?quidit=C3=A4t=20aus=20Projekten=20nach=20V70-Regeln?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Import der JSON-Sicherung in ein leeres Programm (eine Transaktion), mit Hinweisliste - Freitag als Arbeitstag erkannt, alle Termine bleiben gleich - Liquidität aus Projekten, Vorgängen, Abschlägen und Einzelkosten; Angebote zählen nicht (P5) - Vergleich gegen einen Nachbau der V70-Rechnung: je Woche und Monat centgenau gleich Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz --- src/domain/liquiditaet.ts | 6 +- src/domain/projektplan.ts | 109 ++++ src/domain/v70.ts | 363 ++++++++++++++ src/server/app.ts | 51 +- src/server/migrations/002_v70_uebernahme.sql | 14 + src/server/tabellen.ts | 7 + src/server/v70import.ts | 60 +++ src/web/app.ts | 20 +- test/api.test.ts | 53 ++ test/daten/v70-sicherung-2026-10-19.json | 496 +++++++++++++++++++ test/liquiditaet.test.ts | 10 +- test/v70-referenz.ts | 76 +++ test/v70.test.ts | 118 +++++ 13 files changed, 1357 insertions(+), 26 deletions(-) create mode 100644 src/domain/projektplan.ts create mode 100644 src/domain/v70.ts create mode 100644 src/server/migrations/002_v70_uebernahme.sql create mode 100644 src/server/v70import.ts create mode 100644 test/daten/v70-sicherung-2026-10-19.json create mode 100644 test/v70-referenz.ts create mode 100644 test/v70.test.ts diff --git a/src/domain/liquiditaet.ts b/src/domain/liquiditaet.ts index b4f996c..6a313c4 100644 --- a/src/domain/liquiditaet.ts +++ b/src/domain/liquiditaet.ts @@ -188,10 +188,10 @@ function anteilig(betrag: Cent, zaehler: Cent, nenner: Cent): Cent { /** * Einnahmen und Ausgaben eines Projekts nach den V70-Regeln (Pauschale minus Einzelposten). - * Liefert undefined, wenn das Projekt noch keine Termine hat. + * Ohne Termine zählen nur die einzeln erfassten Posten, wie in V70. */ -export function projektBewegungen(p: ProjektPlan): { einnahmen: Einnahme[]; ausgaben: Ausgabe[] } | undefined { - if (!p.zeitraum) return undefined; +export function projektBewegungen(p: ProjektPlan): { einnahmen: Einnahme[]; ausgaben: Ausgabe[] } { + if (!p.zeitraum) return { einnahmen: [...p.zahlungen], ausgaben: [...p.kosten] }; const einnahmen = [...p.zahlungen]; const rest = p.umsatz - summe(p.zahlungen.map((z) => z.netto)); if (rest > 0) einnahmen.push({ projekt: p.projekt, bezeichnung: "Schlussrechnung (Rest)", netto: rest, termin: p.zeitraum.ende }); diff --git a/src/domain/projektplan.ts b/src/domain/projektplan.ts new file mode 100644 index 0000000..5c6e047 --- /dev/null +++ b/src/domain/projektplan.ts @@ -0,0 +1,109 @@ +// Aus dem gespeicherten Bestand (Projekte, Vorgänge, Zahlungen, Kosten) die Daten der +// Liquiditätsvorschau bilden. Termine von Abschlägen folgen dem Ende ihres Vorgangs. + +import { type Datum } from "./datum.js"; +import { type Cent } from "./geld.js"; +import { type Arbeitswoche, endeNachDauer } from "./kalender.js"; +import { type Daten, type Einnahme, type Ausgabe, type Kostenart, type LaufendeKosten, projektBewegungen } from "./liquiditaet.js"; + +export interface BestandProjekt { + id: string; + nummer: string; + status: string; + umsatz_netto: Cent; + material_kosten: Cent; + fremd_kosten: Cent; + sonstige_kosten: Cent; +} + +export interface BestandVorgang { + id: string; + projekt_id: string; + start: Datum; + /** Arbeitstage, angefangene Tage zählen voll; 0 = Meilenstein */ + dauer: number; +} + +export interface BestandZahlung { + projekt_id: string; + vorgang_id?: string | null; + bezeichnung: string; + netto: Cent; + termin: Datum; + status?: string; + rechnungsdatum?: Datum | null; + bezahlt_am?: Datum | null; + zahlungsziel_tage?: number | null; +} + +export interface BestandKosten { + projekt_id: string; + art: Kostenart; + bezeichnung: string; + netto: Cent; + termin: Datum; + mit_vorsteuer: boolean; + zahlungsziel_tage?: number | null; +} + +export interface Bestand { + projekte: BestandProjekt[]; + vorgaenge: BestandVorgang[]; + zahlungen: BestandZahlung[]; + kosten: BestandKosten[]; + laufend: LaufendeKosten[]; +} + +/** P5: Anfragen und Angebote fließen nicht in die Liquidität (V70 hat sie mitgerechnet). */ +export const OHNE_LIQUIDITAET = new Set(["anfrage", "angebot"]); + +export function vorgangsEnde(v: Pick, woche: Arbeitswoche): Datum { + return endeNachDauer(v.start, Math.ceil(v.dauer), woche); +} + +/** Ein noch nicht gestellter Abschlag wandert mit dem Ende seines Vorgangs. */ +function folgtVorgang(z: BestandZahlung): boolean { + return !!z.vorgang_id && (z.status ?? "geplant") === "geplant"; +} + +export function liquiditaetsDaten(b: Bestand, woche: Arbeitswoche, mitAngeboten = false): Daten { + const ende = new Map(b.vorgaenge.map((v) => [v.id, vorgangsEnde(v, woche)])); + const einnahmen: Einnahme[] = []; + const ausgaben: Ausgabe[] = []; + + for (const p of b.projekte) { + if (!mitAngeboten && OHNE_LIQUIDITAET.has(p.status)) continue; + let start: Datum | undefined; + let schluss: Datum | undefined; + for (const v of b.vorgaenge) { + if (v.projekt_id !== p.id) continue; + const e = ende.get(v.id)!; + if (!start || v.start < start) start = v.start; + if (!schluss || e > schluss) schluss = e; + } + const zahlungen: Einnahme[] = b.zahlungen + .filter((z) => z.projekt_id === p.id) + .map((z) => ({ + projekt: p.nummer, + bezeichnung: z.bezeichnung, + netto: z.netto, + termin: z.rechnungsdatum ?? (folgtVorgang(z) ? ende.get(z.vorgang_id!) : undefined) ?? z.termin, + bezahltAm: z.bezahlt_am ?? undefined, + zahlungszielTage: z.zahlungsziel_tage ?? undefined, + })); + const kosten: Ausgabe[] = b.kosten + .filter((k) => k.projekt_id === p.id) + .map((k) => ({ + projekt: p.nummer, bezeichnung: k.bezeichnung, art: k.art, netto: k.netto, termin: k.termin, + mitVorsteuer: k.mit_vorsteuer, zahlungszielTage: k.zahlungsziel_tage ?? undefined, + })); + const r = projektBewegungen({ + projekt: p.nummer, umsatz: p.umsatz_netto, material: p.material_kosten, fremd: p.fremd_kosten, sonstiges: p.sonstige_kosten, + zeitraum: start && schluss ? { start, ende: schluss } : undefined, + zahlungen, kosten, + }); + einnahmen.push(...r.einnahmen); + ausgaben.push(...r.ausgaben); + } + return { einnahmen, ausgaben, laufend: b.laufend }; +} diff --git a/src/domain/v70.ts b/src/domain/v70.ts new file mode 100644 index 0000000..f4f37b9 --- /dev/null +++ b/src/domain/v70.ts @@ -0,0 +1,363 @@ +// Übernahme einer Sicherung aus dem Projektplaner V70 (Datei "projektplaner-sicherung-….json"). +// Reine Umrechnung ohne Datenbank: liefert die neuen Datensätze mit eigenen Schlüsseln +// für die Verknüpfungen und eine Liste von Hinweisen auf alles, was nicht 1:1 passt. + +import { type Datum, wochentag } from "./datum.js"; +import { type Cent } from "./geld.js"; +import { type Arbeitswoche, arbeitstageZwischen, endeNachDauer, feiertag } from "./kalender.js"; +import { type Rundung } from "./arbeitszeit.js"; +import { type Kostenart, type Rhythmus } from "./liquiditaet.js"; + +// --- Aufbau der V70-Sicherung (nur die Felder, die übernommen werden) --- + +export interface V70Task { + id: string; + t: "a" | "v"; + par?: string; + name: string; + start?: string; + end?: string; + ms?: boolean; + dep?: string | null; + typ?: string; + lag?: number; + abs?: number; + pers?: number; + std?: number; + no?: number; + kontakt?: unknown; +} + +export interface V70Projekt { + name: string; + nr?: string; + bauherr?: string; + umsatz?: number; + material?: number; + fremd?: number; + sonst?: number; + mann?: number; + tage?: number; + zb?: string; + std?: number; + status?: string; + farbe?: string; + arch?: boolean; + tasks?: V70Task[]; +} + +export interface V70Posten { + id?: string; + p: number | string; + t: string; + b: number; + d?: string; +} + +export interface V70Firmenkosten { + t: string; + g?: string; + c?: string; + b: number; + d?: string; + r?: number; +} + +export interface V70Sicherung { + format: "projektplaner"; + version?: number; + gesichert?: string; + projekte: V70Projekt[]; + kontakte: { name: string; tel?: string; mail?: string }[]; + kosten: V70Posten[]; + einnahmen?: V70Posten[]; + zahlungsziel?: number; + materialziel?: number; + firmenkosten_monatlich: V70Firmenkosten[]; + firmenkosten_einmalig: V70Firmenkosten[]; + arbeitszeit?: { h?: number; eff?: number; rund?: string }; + aufgaben?: unknown[]; +} + +// --- Ergebnis --- + +export type Projektstatus = "anfrage" | "angebot" | "auftrag" | "ausfuehrung" | "abgerechnet" | "gewaehrleistung" | "abgeschlossen"; + +export interface Uebernahme { + einstellungen: { + arbeitstage: number[]; + stundenProTag: number; + produktivitaet: number; + rundung: Rundung; + zahlungsziele: { kundenTage: number; materialTage: number; fremdTage: number; sonstigeTage: number }; + }; + kontakte: { schluessel: string; name: string; rolle: "bauherr" | "sonstige"; telefon?: string; email?: string }[]; + projekte: { + schluessel: string; nummer: string; bezeichnung: string; bauherr?: string; status: Projektstatus; + umsatz_netto: Cent; material_kosten: Cent; fremd_kosten: Cent; sonstige_kosten: Cent; + farbe?: string; reihenfolge: number; personen?: number; soll_stunden?: number; soll_tage?: number; + }[]; + abschnitte: { schluessel: string; projekt: string; name: string; ist_meilenstein: boolean; reihenfolge: number }[]; + vorgaenge: { + schluessel: string; abschnitt: string; name: string; start: Datum; dauer: number; + stunden?: number; personen?: number; reihenfolge: number; + }[]; + verknuepfungen: { vorgang: string; vorgaenger: string; art: "EA" | "AA" | "EE" | "AE"; verzoegerung: number }[]; + zahlungen: { + projekt: string; vorgang?: string; art: "abschlag"; bezeichnung: string; netto: Cent; termin: Datum; zahlungsziel_tage?: number; + }[]; + kosten: { projekt: string; art: Kostenart; bezeichnung: string; netto: Cent; termin: Datum; mit_vorsteuer: boolean; zahlungsziel_tage: number }[]; + laufend: { bezeichnung: string; gruppe?: string; kategorie: string; betrag: Cent; rhythmus: Rhythmus; start: Datum }[]; + hinweise: string[]; +} + +const DATUM = /^\d{4}-\d{2}-\d{2}$/; + +/** Euro-Betrag aus V70 (Gleitkommazahl) in Cent, kaufmännisch gerundet über die Dezimaldarstellung. */ +export function euroZuCent(euro: number | undefined): Cent { + if (euro === undefined || euro === null || !Number.isFinite(euro)) return 0; + const text = String(Math.abs(euro)); + let cent: number; + if (/e/i.test(text)) cent = Math.round(Math.abs(euro) * 100); + else { + const [ganz, nachkomma = ""] = text.split("."); + const z = (nachkomma + "000").slice(0, 3); + cent = Number(ganz) * 100 + Number(z.slice(0, 2)) + (Number(z[2]) >= 5 ? 1 : 0); + } + return euro < 0 ? -cent : cent; +} + +const STATUS: Record = { + Angebot: "angebot", + Auftrag: "auftrag", + Geplant: "auftrag", + "In Arbeit": "ausfuehrung", + Abgeschlossen: "abgeschlossen", +}; + +const RHYTHMUS: Record = { 1: "monatlich", 3: "vierteljaehrlich", 12: "jaehrlich" }; + +/** Prüft grob, ob die Datei eine V70-Sicherung ist; wirft sonst einen verständlichen Fehler. */ +export function pruefeSicherung(d: unknown): V70Sicherung { + const s = d as Partial | null; + if (!s || s.format !== "projektplaner" || !Array.isArray(s.projekte) || !Array.isArray(s.kosten) || !Array.isArray(s.firmenkosten_monatlich)) { + throw new Error("Diese Datei ist keine Sicherung des Projektplaners V70."); + } + return { kontakte: [], firmenkosten_einmalig: [], einnahmen: [], ...s } as V70Sicherung; +} + +function istBlatt(p: V70Projekt, t: V70Task): boolean { + return t.t === "v" || !(p.tasks ?? []).some((k) => k.t === "v" && k.par === t.id); +} + +function hatTermin(t: V70Task): t is V70Task & { start: string; end: string } { + return !!t.start && !!t.end && DATUM.test(t.start) && DATUM.test(t.end); +} + +/** + * V70 kennt einen Schalter "Freitag frei". Liegt ein Termin auf einem Freitag (ohne Feiertag), + * war der Schalter aus und es wurde Mo–Fr geplant; sonst Mo–Do. + */ +export function erkenneArbeitswoche(s: V70Sicherung): { woche: Arbeitswoche; freitage: Datum[] } { + const freitage = new Set(); + for (const p of s.projekte) { + for (const t of p.tasks ?? []) { + if (!hatTermin(t) || !istBlatt(p, t)) continue; + for (const d of [t.start, t.end]) if (wochentag(d) === 5 && !feiertag(d)) freitage.add(d); + } + } + return { woche: { tage: freitage.size ? [1, 2, 3, 4, 5] : [1, 2, 3, 4] }, freitage: [...freitage].sort() }; +} + +export function uebernimmV70(roh: unknown): Uebernahme { + const s = pruefeSicherung(roh); + const hinweise: string[] = []; + const { woche, freitage } = erkenneArbeitswoche(s); + if (freitage.length) { + hinweise.push(`In V70 war „Freitag frei“ aus: ${freitage.length} Termine liegen auf einem Freitag. Übernommen als Arbeitswoche Mo–Fr, damit alle Termine gleich bleiben.`); + } + + const az = s.arbeitszeit ?? {}; + const rundung: Rundung = az.rund === "ganz" || az.rund === "keine" ? az.rund : "halb"; + const zz = Math.max(0, Number(s.zahlungsziel ?? 14) || 0); + const mz = s.materialziel === undefined ? 7 : Math.max(0, Number(s.materialziel) || 0); + + const u: Uebernahme = { + einstellungen: { + arbeitstage: woche.tage, + stundenProTag: az.h && az.h > 0 ? az.h : 8, + produktivitaet: az.eff && az.eff > 0 ? Math.min(az.eff, 100) / 100 : 1, + rundung, + zahlungsziele: { kundenTage: zz, materialTage: mz, fremdTage: mz, sonstigeTage: mz }, + }, + kontakte: [], projekte: [], abschnitte: [], vorgaenge: [], verknuepfungen: [], zahlungen: [], kosten: [], laufend: [], + hinweise, + }; + + // Kontakte aus V70 und Bauherren (dort nur Text) als eigene Kontakte + const kontaktNachName = new Map(); + s.kontakte.forEach((k, i) => { + if (!k?.name?.trim()) return; + const schluessel = `k${i}`; + u.kontakte.push({ schluessel, name: k.name.trim(), rolle: "sonstige", telefon: k.tel || undefined, email: k.mail || undefined }); + kontaktNachName.set(k.name.trim(), schluessel); + }); + const bauherr = (name?: string): string | undefined => { + const n = name?.trim(); + if (!n) return undefined; + const vorhanden = kontaktNachName.get(n); + if (vorhanden) return vorhanden; + const schluessel = `b${kontaktNachName.size}`; + u.kontakte.push({ schluessel, name: n, rolle: "bauherr" }); + kontaktNachName.set(n, schluessel); + return schluessel; + }; + + // Projektnummern: "26-014" -> P-26-014 ab Auftrag, A-26-014 im Angebot; ohne Nummer Platzhalter + const vergeben = new Set(); + let ohneNummer = 0; + const nummer = (p: V70Projekt, status: Projektstatus): string => { + const prefix = status === "angebot" || status === "anfrage" ? "A" : "P"; + const nr = (p.nr ?? "").trim(); + let n: string; + if (!nr || nr === "0") { + n = `${prefix}-OHNE-${++ohneNummer}`; + hinweise.push(`„${p.name}“ hatte keine Projektnummer; vorläufig ${n}, bitte vergeben.`); + } else n = `${prefix}-${nr}`; + let eindeutig = n; + for (let i = 2; vergeben.has(eindeutig); i++) eindeutig = `${n}-${i}`; + if (eindeutig !== n) hinweise.push(`Nummer ${n} kam doppelt vor; „${p.name}“ heißt jetzt ${eindeutig}.`); + vergeben.add(eindeutig); + return eindeutig; + }; + + // V70-Task-Id -> Schlüssel des Vorgangs, der dafür im Terminplan steht + const vorgangZuTask = new Map(); + const offeneVerknuepfungen: { task: V70Task; projekt: V70Projekt }[] = []; + + s.projekte.forEach((p, pi) => { + const schluessel = `p${pi}`; + let status = STATUS[p.status ?? ""] ?? "auftrag"; + if (!STATUS[p.status ?? ""]) hinweise.push(`„${p.name}“: unbekannter Status „${p.status ?? ""}“, als Auftrag übernommen.`); + if (p.arch) status = "abgeschlossen"; + u.projekte.push({ + schluessel, + nummer: nummer(p, status), + bezeichnung: p.name?.trim() || `Projekt ${pi + 1}`, + bauherr: bauherr(p.bauherr), + status, + umsatz_netto: euroZuCent(p.umsatz), + material_kosten: euroZuCent(p.material), + fremd_kosten: euroZuCent(p.fremd), + sonstige_kosten: euroZuCent(p.sonst), + farbe: /^#[0-9a-f]{6}$/i.test(p.farbe ?? "") ? p.farbe : undefined, + reihenfolge: pi, + personen: p.mann && p.mann > 0 ? p.mann : undefined, + soll_stunden: p.zb === "std" && p.std !== undefined ? p.std : undefined, + soll_tage: p.tage !== undefined ? p.tage : undefined, + }); + + const tasks = [...(p.tasks ?? [])].sort((a, b) => (a.no ?? 0) - (b.no ?? 0)); + const abschnittZuTask = new Map(); + + const vorgang = (t: V70Task, abschnitt: string, meilenstein: boolean) => { + if (!hatTermin(t)) { + if (euroZuCent(t.abs) > 0) hinweise.push(`„${p.name}“ / „${t.name}“: Abschlag ohne Termin, nicht übernommen (fehlt in V70 auch in der Liquidität).`); + if (t.dep) hinweise.push(`„${p.name}“ / „${t.name}“: hat keinen Termin, die Verknüpfung zum Vorgänger entfällt.`); + return; + } + const vs = `v${u.vorgaenge.length}`; + const dauer = meilenstein ? 0 : arbeitstageZwischen(t.start, t.end, woche); + if (endeNachDauer(t.start, dauer, woche) !== t.end || (!meilenstein && dauer === 0)) { + hinweise.push(`„${p.name}“ / „${t.name}“: ${t.start} bis ${t.end} passt nicht auf die Arbeitstage, bitte prüfen.`); + } + u.vorgaenge.push({ + schluessel: vs, abschnitt, name: t.name?.trim() || "Vorgang", start: t.start, dauer: Math.max(dauer, meilenstein ? 0 : 1), + stunden: t.std !== undefined && t.std > 0 ? t.std : undefined, + personen: t.pers && t.pers > 0 ? t.pers : undefined, + reihenfolge: t.no ?? 0, + }); + vorgangZuTask.set(t.id, vs); + const abs = euroZuCent(t.abs); + if (abs > 0) u.zahlungen.push({ projekt: schluessel, vorgang: vs, art: "abschlag", bezeichnung: `Abschlag ${t.name}`.trim(), netto: abs, termin: t.end }); + if (t.dep) offeneVerknuepfungen.push({ task: t, projekt: p }); + if (t.kontakt !== undefined && t.kontakt !== null && t.kontakt !== "") { + hinweise.push(`„${p.name}“ / „${t.name}“: zugeordneter Kontakt bitte neu zuweisen.`); + } + }; + + // Abschnitte zuerst, dann Vorgänge in ihrer Reihenfolge + for (const t of tasks.filter((x) => x.t === "a")) { + const as = `a${u.abschnitte.length}`; + const meilenstein = !!t.ms; + u.abschnitte.push({ schluessel: as, projekt: schluessel, name: t.name?.trim() || "Abschnitt", ist_meilenstein: meilenstein, reihenfolge: t.no ?? 0 }); + abschnittZuTask.set(t.id, as); + // Abschnitt ohne Vorgänge mit eigenem Termin: in V70 ein Balken, hier ein gleichnamiger Vorgang + if (istBlatt(p, t)) vorgang(t, as, meilenstein); + } + for (const t of tasks.filter((x) => x.t === "v")) { + let as = t.par ? abschnittZuTask.get(t.par) : undefined; + if (!as) { + as = `a${u.abschnitte.length}`; + u.abschnitte.push({ schluessel: as, projekt: schluessel, name: "Ohne Abschnitt", ist_meilenstein: false, reihenfolge: t.no ?? 0 }); + if (t.par) abschnittZuTask.set(t.par, as); + hinweise.push(`„${p.name}“ / „${t.name}“: gehörte zu keinem Abschnitt, steht jetzt unter „Ohne Abschnitt“.`); + } + vorgang(t, as, !!t.ms); + } + }); + + for (const { task, projekt } of offeneVerknuepfungen) { + const vorgaenger = vorgangZuTask.get(task.dep!); + const art = (["EA", "AA", "EE", "AE"] as const).find((a) => a === (task.typ ?? "EA")); + if (!vorgaenger || !art) { + hinweise.push(`„${projekt.name}“ / „${task.name}“: Vorgänger nicht gefunden oder ohne Termin, Verknüpfung entfällt.`); + continue; + } + u.verknuepfungen.push({ vorgang: vorgangZuTask.get(task.id)!, vorgaenger, art, verzoegerung: Math.round(task.lag ?? 0) }); + } + + // Einzelkosten und -einnahmen hängen in V70 an der Listenposition des Projekts + const projektVon = (x: V70Posten, was: string): string | undefined => { + const i = Number(x.p); + if (!Number.isInteger(i) || !s.projekte[i]) { + hinweise.push(`${was} „${x.t}“ (${x.b} €) gehört zu keinem Projekt und wurde nicht übernommen.`); + return undefined; + } + if (!x.d || !DATUM.test(x.d)) { + hinweise.push(`${was} „${x.t}“ (${x.b} €) hat kein Datum; in V70 zählt sie nicht und wurde nicht übernommen.`); + return undefined; + } + return `p${i}`; + }; + for (const k of s.kosten) { + const projekt = projektVon(k, "Kosten"); + if (!projekt) continue; + // V70 bucht Einzelkosten am eingetragenen Tag und ohne Vorsteuer ("wie eingegeben") + u.kosten.push({ projekt, art: "material", bezeichnung: k.t?.trim() || "Kosten", netto: euroZuCent(k.b), termin: k.d!, mit_vorsteuer: false, zahlungsziel_tage: 0 }); + } + for (const e of s.einnahmen ?? []) { + const projekt = projektVon(e, "Einnahme"); + if (!projekt) continue; + u.zahlungen.push({ projekt, art: "abschlag", bezeichnung: e.t?.trim() || "Einnahme", netto: euroZuCent(e.b), termin: e.d!, zahlungsziel_tage: 0 }); + } + + for (const f of s.firmenkosten_monatlich) { + const rhythmus = RHYTHMUS[Number(f.r ?? 1)]; + if (!rhythmus || !f.d || !DATUM.test(f.d)) { + hinweise.push(`Laufende Kosten „${f.t}“: ${!rhythmus ? `Rhythmus alle ${f.r} Monate gibt es noch nicht` : "ohne erstes Fälligkeitsdatum"}, nicht übernommen.`); + continue; + } + u.laufend.push({ bezeichnung: f.t.trim(), gruppe: f.g?.trim() || undefined, kategorie: f.c?.trim() || "Sonstiges", betrag: euroZuCent(f.b), rhythmus, start: f.d }); + } + for (const f of s.firmenkosten_einmalig) { + if (!f.d || !DATUM.test(f.d)) { + hinweise.push(`Einmalige Kosten „${f.t}“ ohne Datum, nicht übernommen.`); + continue; + } + u.laufend.push({ bezeichnung: f.t.trim(), gruppe: f.g?.trim() || undefined, kategorie: f.c?.trim() || "Sonstiges", betrag: euroZuCent(f.b), rhythmus: "einmalig", start: f.d }); + } + if (s.aufgaben?.length) hinweise.push(`${s.aufgaben.length} Aufgaben aus V70 werden mit Stufe 1 übernommen.`); + + return u; +} diff --git a/src/server/app.ts b/src/server/app.ts index abf844f..1707564 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -7,7 +7,10 @@ import { z, ZodError } from "zod"; import { type Pool, transaktion } from "./db.js"; import { TABELLEN } from "./tabellen.js"; import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js"; -import { liquiditaet, type Daten } from "../domain/liquiditaet.js"; +import { liquiditaet } from "../domain/liquiditaet.js"; +import { liquiditaetsDaten } from "../domain/projektplan.js"; +import { uebernimmV70 } from "../domain/v70.js"; +import { speichereUebernahme } from "./v70import.js"; import { VERSION } from "./version.js"; export interface Optionen { @@ -118,27 +121,41 @@ export async function baueApp(o: Optionen): Promise { app.get("/api/liquiditaet", async (req) => { const q = LiquiAnfrage.parse(req.query); const e = await ladeEinstellungen(); - const [zahlungen, kosten, laufend] = await Promise.all([ - pool.query(`select z.*, p.nummer from zahlung z join projekt p on p.id = z.projekt_id`), - pool.query(`select k.*, p.nummer from kosten k join projekt p on p.id = k.projekt_id`), - pool.query(`select * from laufende_kosten`), + const [projekte, vorgaenge, zahlungen, kosten, laufend] = await Promise.all([ + pool.query("select * from projekt"), + pool.query("select v.id, a.projekt_id, v.start, v.dauer from vorgang v join abschnitt a on a.id = v.abschnitt_id"), + pool.query("select * from zahlung"), + pool.query("select * from kosten"), + pool.query("select * from laufende_kosten"), ]); - const daten: Daten = { - einnahmen: zahlungen.rows.map((z) => ({ - projekt: z.nummer, bezeichnung: z.bezeichnung, netto: z.netto, - termin: z.rechnungsdatum ?? z.termin, bezahltAm: z.bezahlt_am ?? undefined, - })), - ausgaben: kosten.rows.map((k) => ({ - projekt: k.nummer, bezeichnung: k.bezeichnung, art: k.art, netto: k.netto, termin: k.termin, mitVorsteuer: k.mit_vorsteuer, - })), - laufend: laufend.rows.map((l) => ({ - bezeichnung: l.bezeichnung, kategorie: l.kategorie, betrag: l.betrag, rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined, - })), - }; + const daten = liquiditaetsDaten( + { + projekte: projekte.rows, + vorgaenge: vorgaenge.rows, + zahlungen: zahlungen.rows, + kosten: kosten.rows, + laufend: laufend.rows.map((l) => ({ + bezeichnung: l.bezeichnung, kategorie: l.kategorie, betrag: l.betrag, rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined, + })), + }, + { tage: e.arbeitstage }, + ); const start = q.start ?? new Date().toISOString().slice(0, 10); return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust }); }); + // Übernahme aus dem Projektplaner V70 (JSON-Sicherung), nur in ein leeres Programm + app.post("/api/import/v70", async (req, reply) => { + let u; + try { + u = uebernimmV70(req.body); + } catch (err) { + return reply.status(400).send({ fehler: (err as Error).message }); + } + const anzahl = await transaktion(pool, benutzer(req), (c) => speichereUebernahme(c, u)); + return reply.status(201).send({ anzahl, hinweise: u.hinweise }); + }); + // D1: kompletter Stand als JSON-Datei app.get("/api/export", async (_req, reply) => { const daten: Record = {}; diff --git a/src/server/migrations/002_v70_uebernahme.sql b/src/server/migrations/002_v70_uebernahme.sql new file mode 100644 index 0000000..b500fc5 --- /dev/null +++ b/src/server/migrations/002_v70_uebernahme.sql @@ -0,0 +1,14 @@ +-- Felder für die Übernahme aus dem Projektplaner V70 + +-- Stundenplanung je Projekt und Vorgang (V70: mann, std, tage, pers) +alter table projekt add column personen numeric(4, 1); +alter table projekt add column soll_stunden numeric(8, 2); +alter table projekt add column soll_tage numeric(6, 1); +alter table vorgang add column personen numeric(4, 1); + +-- eigenes Zahlungsziel je Posten; leer = Vorgabe aus den Einstellungen +alter table zahlung add column zahlungsziel_tage integer check (zahlungsziel_tage >= 0); +alter table kosten add column zahlungsziel_tage integer check (zahlungsziel_tage >= 0); + +-- Gruppe der laufenden Kosten (V70: g), z. B. "Versicherungen/Beiträge" +alter table laufende_kosten add column gruppe text; diff --git a/src/server/tabellen.ts b/src/server/tabellen.ts index e93c185..5413020 100644 --- a/src/server/tabellen.ts +++ b/src/server/tabellen.ts @@ -47,6 +47,9 @@ export const TABELLEN: Tabelle[] = [ farbe: optText, nextcloud_link: optText, reihenfolge: z.number().int().optional(), + personen: z.number().positive().nullable().optional(), + soll_stunden: z.number().min(0).nullable().optional(), + soll_tage: z.number().min(0).nullable().optional(), }), }, { @@ -75,6 +78,7 @@ export const TABELLEN: Tabelle[] = [ kontakt_id: id.nullable().optional(), reihenfolge: z.number().int().optional(), fortschritt: z.number().int().min(0).max(100).optional(), + personen: z.number().positive().nullable().optional(), }), }, { @@ -103,6 +107,7 @@ export const TABELLEN: Tabelle[] = [ rechnungsdatum: datum.nullable().optional(), bezahlt_am: datum.nullable().optional(), reihenfolge: z.number().int().optional(), + zahlungsziel_tage: z.number().int().min(0).nullable().optional(), }), }, { @@ -118,6 +123,7 @@ export const TABELLEN: Tabelle[] = [ kontakt_id: id.nullable().optional(), mit_vorsteuer: z.boolean().optional(), status: z.enum(["geplant", "bestellt", "bezahlt"]).optional(), + zahlungsziel_tage: z.number().int().min(0).nullable().optional(), }), }, { @@ -127,6 +133,7 @@ export const TABELLEN: Tabelle[] = [ schema: z.object({ bezeichnung: text, kategorie: text.optional(), + gruppe: optText, betrag: cent, rhythmus: z.enum(["einmalig", "monatlich", "vierteljaehrlich", "jaehrlich"]).optional(), start: datum, diff --git a/src/server/v70import.ts b/src/server/v70import.ts new file mode 100644 index 0000000..519e397 --- /dev/null +++ b/src/server/v70import.ts @@ -0,0 +1,60 @@ +// Übernahme einer V70-Sicherung in eine leere Datenbank, alles in einer Transaktion. +import type { Client } from "./db.js"; +import { EinstellungenSchema } from "./einstellungen.js"; +import type { Uebernahme } from "../domain/v70.js"; + +export class NichtLeer extends Error { + statusCode = 409; +} + +async function einfuegen(c: Client, tabelle: string, werte: Record): Promise { + const spalten = Object.keys(werte).filter((k) => werte[k] !== undefined); + const r = await c.query<{ id: string }>( + `insert into ${tabelle} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning id`, + spalten.map((s) => werte[s]), + ); + return r.rows[0]!.id; +} + +export async function speichereUebernahme(c: Client, u: Uebernahme): Promise> { + const belegt = await c.query<{ n: number }>( + "select (select count(*) from projekt) + (select count(*) from kontakt) + (select count(*) from laufende_kosten) as n", + ); + if (Number(belegt.rows[0]!.n) > 0) { + throw new NichtLeer("Die Übernahme aus V70 geht nur in ein leeres Programm. Es sind schon Projekte, Kontakte oder laufende Kosten erfasst."); + } + + const id = new Map(); + const ref = (s: string | undefined) => (s === undefined ? undefined : id.get(s)!); + + for (const k of u.kontakte) { + id.set(k.schluessel, await einfuegen(c, "kontakt", { name: k.name, rolle: k.rolle, telefon: k.telefon, email: k.email })); + } + for (const { schluessel, bauherr, ...p } of u.projekte) { + id.set(schluessel, await einfuegen(c, "projekt", { ...p, bauherr_id: ref(bauherr) })); + } + for (const { schluessel, projekt, ...a } of u.abschnitte) { + id.set(schluessel, await einfuegen(c, "abschnitt", { ...a, projekt_id: ref(projekt) })); + } + for (const { schluessel, abschnitt, ...v } of u.vorgaenge) { + id.set(schluessel, await einfuegen(c, "vorgang", { ...v, abschnitt_id: ref(abschnitt) })); + } + for (const k of u.verknuepfungen) { + await einfuegen(c, "vorgang_vorgaenger", { vorgang_id: ref(k.vorgang), vorgaenger_id: ref(k.vorgaenger), art: k.art, verzoegerung: k.verzoegerung }); + } + for (const [i, { projekt, vorgang, ...z }] of u.zahlungen.entries()) { + await einfuegen(c, "zahlung", { ...z, projekt_id: ref(projekt), vorgang_id: ref(vorgang), reihenfolge: i }); + } + for (const { projekt, ...k } of u.kosten) await einfuegen(c, "kosten", { ...k, projekt_id: ref(projekt) }); + for (const l of u.laufend) await einfuegen(c, "laufende_kosten", l); + + const alt = await c.query<{ daten: unknown }>("select daten from einstellungen limit 1"); + const bisher = EinstellungenSchema.parse(alt.rows[0]?.daten ?? {}); + const neu = EinstellungenSchema.parse({ ...bisher, ...u.einstellungen, zahlungsziele: u.einstellungen.zahlungsziele }); + await c.query("update einstellungen set daten = $1", [neu]); + + return { + kontakte: u.kontakte.length, projekte: u.projekte.length, abschnitte: u.abschnitte.length, vorgaenge: u.vorgaenge.length, + verknuepfungen: u.verknuepfungen.length, zahlungen: u.zahlungen.length, kosten: u.kosten.length, laufendeKosten: u.laufend.length, + }; +} diff --git a/src/web/app.ts b/src/web/app.ts index 96417c0..7423bb6 100644 --- a/src/web/app.ts +++ b/src/web/app.ts @@ -298,8 +298,26 @@ async function daten(): Promise { const e = await api("einstellungen"); inhalt.insertAdjacentHTML("beforeend", `

Kompletten Stand als JSON sichern

-

Die Datenbank wird jede Nacht gesichert und in die Nextcloud kopiert. Der Import des V70-Stands folgt, sobald die V70-Datei vorliegt.

+

Die Datenbank wird jede Nacht gesichert und in die Nextcloud kopiert.

+

Übernahme aus dem Projektplaner V70

+

Sicherungsdatei aus V70 wählen (projektplaner-sicherung-….json). Geht nur, solange noch nichts erfasst ist.

+

+

Einstellungen

`); + const datei = document.getElementById("v70-datei") as HTMLInputElement; + datei.onchange = async () => { + const f = datei.files?.[0]; + const ziel = document.getElementById("v70-ergebnis")!; + if (!f) return; + try { + const r = await api<{ anzahl: Record; hinweise: string[] }>("import/v70", "POST", JSON.parse(await f.text())); + ziel.innerHTML = `

Übernommen: ${r.anzahl.projekte} Projekte, ${r.anzahl.vorgaenge} Vorgänge, ${r.anzahl.zahlungen} Abschläge, ${r.anzahl.kosten} Kosten, ${r.anzahl.laufendeKosten} laufende Kosten, ${r.anzahl.kontakte} Kontakte.

` + + (r.hinweise.length ? `

Bitte prüfen:

    ${r.hinweise.map((h) => `
  • ${esc(h)}
  • `).join("")}
` : ""); + } catch (e) { + ziel.innerHTML = `

${esc((e as Error).message)}

`; + } + datei.value = ""; + }; const felder: Feld[] = [ { name: "startsaldo", titel: "Kontostand (Startsaldo)", art: "euro" }, { name: "kundenTage", titel: "Zahlungsziel Kunden (Tage)", art: "zahl" }, diff --git a/test/api.test.ts b/test/api.test.ts index dd9c8ab..4ba24c2 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -4,6 +4,11 @@ import type { FastifyInstance } from "fastify"; import { erstellePool, type Pool } from "../src/server/db.js"; import { migriere } from "../src/server/migrate.js"; import { baueApp } from "../src/server/app.js"; +import { readFileSync } from "node:fs"; +import { uebernimmV70 } from "../src/domain/v70.js"; +import { liquiditaetsDaten } from "../src/domain/projektplan.js"; +import { liquiditaet } from "../src/domain/liquiditaet.js"; +import { bestandAus } from "./v70-referenz.js"; const url = process.env.TEST_DATABASE_URL; @@ -97,3 +102,51 @@ describe.skipIf(!url)("API mit Datenbank", () => { expect(j.daten.kontakte.length).toBeGreaterThan(0); }); }); + +describe.skipIf(!url)("Übernahme aus V70 über die API", () => { + let pool: Pool; + let app: FastifyInstance; + const sicherung = JSON.parse(readFileSync(new URL("./daten/v70-sicherung-2026-10-19.json", import.meta.url), "utf8")); + + 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" }); + }); + afterAll(async () => { + await app?.close(); + await pool?.end(); + }); + + const importiere = (payload: object) => app.inject({ method: "POST", url: "/api/import/v70", payload, headers: { "x-benutzer": "henning" } }); + + it("lehnt fremde Dateien ab", async () => { + const r = await importiere({ format: "etwas anderes" }); + expect(r.statusCode).toBe(400); + expect(r.json().fehler).toMatch(/keine Sicherung/); + }); + + it("übernimmt die Sicherung einmal, danach nicht mehr", async () => { + const r = await importiere(sicherung); + expect(r.statusCode, r.body).toBe(201); + expect(r.json().anzahl).toMatchObject({ projekte: 9, kontakte: 7, vorgaenge: 13, zahlungen: 5, kosten: 2, laufendeKosten: 10 }); + expect((await importiere(sicherung)).statusCode).toBe(409); + const e = (await app.inject("/api/einstellungen")).json(); + expect(e).toMatchObject({ arbeitstage: [1, 2, 3, 4, 5], rundung: "halb", zahlungsziele: { kundenTage: 14, materialTage: 7 } }); + const protokoll = (await app.inject("/api/protokoll?limit=1")).json(); + expect(protokoll[0].benutzer).toBe("henning"); + }); + + it("Liquidität aus der Datenbank wie aus der Sicherung gerechnet", async () => { + const u = uebernimmV70(sicherung); + const erwartet = liquiditaet(liquiditaetsDaten(bestandAus(u), { tage: u.einstellungen.arbeitstage }), { + ansicht: "monat", start: "2026-07-01", anzahl: 12, startsaldo: 0, ziele: u.einstellungen.zahlungsziele, + }); + const l = (await app.inject("/api/liquiditaet?ansicht=monat&start=2026-07-01&anzahl=12")).json(); + const kurz = (p: { von: string; einnahmen: number; ausgaben: number; kontostand: number }[]) => + p.map(({ von, einnahmen, ausgaben, kontostand }) => ({ von, einnahmen, ausgaben, kontostand })); + expect(kurz(l)).toEqual(kurz(erwartet)); + expect(erwartet.some((p) => p.einnahmen > 0)).toBe(true); + }); +}); diff --git a/test/daten/v70-sicherung-2026-10-19.json b/test/daten/v70-sicherung-2026-10-19.json new file mode 100644 index 0000000..bacf205 --- /dev/null +++ b/test/daten/v70-sicherung-2026-10-19.json @@ -0,0 +1,496 @@ +{ + "format": "projektplaner", + "version": 1, + "gesichert": "2026-10-19", + "gesichertAm": "2026-10-19T04:25:59.526Z", + "stand": 1792005531875, + "projekte": [ + { + "name": "Bohlentausch", + "nr": "26-014", + "bauherr": "Stadt Ratzeburg", + "umsatz": 3484, + "material": 1431, + "fremd": 0, + "sonst": 0, + "mann": 1, + "tage": 2, + "status": "Auftrag", + "tasks": [ + { + "id": "bhtm5z", + "t": "a", + "name": "Abbund", + "no": 1001, + "col": false + }, + { + "id": "aa8j9z", + "t": "a", + "name": "Materialbestellung", + "start": "2026-10-22", + "end": "2026-10-22", + "dep": null, + "abs": 0, + "no": 1002, + "col": false, + "ms": true + }, + { + "id": "nnap85", + "t": "v", + "no": 1003, + "par": "bhtm5z", + "name": "Abbund", + "start": "2026-10-23", + "end": "2026-10-23", + "dep": "aa8j9z", + "abs": 1000, + "dir": null, + "col": false, + "ms": false, + "typ": "EA", + "lag": 0 + }, + { + "id": "pmv4xw", + "t": "v", + "no": 1007, + "par": "bhtm5z", + "name": "Montage", + "start": "2026-10-26", + "end": "2026-10-26", + "dep": "nnap85", + "abs": 0, + "ms": false, + "col": false + } + ], + "col": false, + "farbe": "#2f6b5a" + }, + { + "name": "Anbau", + "nr": "26-015", + "bauherr": "Most", + "umsatz": 24445.01, + "material": 500, + "fremd": 11663.64, + "sonst": 4700, + "mann": 1, + "tage": 10, + "status": "Auftrag", + "tasks": [ + { + "id": "p9qiuh", + "t": "a", + "no": 1006, + "name": "Materialbestellung", + "col": false, + "dep": "yvnqja", + "typ": "AE", + "lag": -15 + }, + { + "id": "yvnqja", + "t": "a", + "no": 1013, + "name": "Montage", + "start": "2026-10-12", + "end": "2026-10-16", + "abs": 0, + "col": false + } + ], + "col": false, + "farbe": "#2b6cb0" + }, + { + "name": "Unterstellplatz Wohnmobil", + "nr": "27-001", + "bauherr": "Ehep. Schlünsen", + "umsatz": 15776, + "material": 5735, + "fremd": 0, + "sonst": 55, + "mann": 2, + "tage": 7, + "status": "Angebot", + "zb": "std", + "std": 110, + "tasks": [ + { + "id": "8i4g7v", + "t": "a", + "no": 1008, + "name": "Bauantrag", + "col": false + }, + { + "id": "5mfc6b", + "t": "v", + "no": 1009, + "par": "8i4g7v", + "name": "Entwurf", + "start": "2026-12-07", + "end": "2026-12-07", + "dep": null, + "abs": 0, + "ms": false, + "pers": 1, + "col": false + }, + { + "id": "o0y9pf", + "t": "v", + "no": 1010, + "par": "8i4g7v", + "name": "Bauantrag", + "start": "2026-12-22", + "end": "2026-12-22", + "dep": "5mfc6b", + "abs": 1000, + "ms": false, + "lag": 10, + "dir": null, + "pers": 1, + "col": false + }, + { + "id": "da7uyt", + "t": "a", + "no": 1012, + "name": "Baugenehmigung", + "start": "2027-02-02", + "end": "2027-02-02", + "dep": "o0y9pf", + "abs": 0, + "ms": true, + "lag": 28, + "col": false + }, + { + "id": "4btedb", + "t": "a", + "no": 1011, + "name": "Ausführung", + "start": "2027-02-03", + "end": "2027-02-09", + "abs": 14776, + "dep": "da7uyt", + "typ": "EA", + "lag": 0, + "dir": null, + "col": false + } + ], + "col": false, + "farbe": "#b7791f", + "kcol": false + }, + { + "name": "Fassadensanierung", + "nr": "0", + "bauherr": "Ehep. Kodal", + "umsatz": 55531, + "material": 22998, + "fremd": 0, + "sonst": 55, + "mann": 2, + "tage": 20, + "status": "Angebot", + "tasks": [ + { + "id": "kci1dc", + "t": "a", + "no": 1014, + "name": "Planung", + "col": false + }, + { + "id": "ixguxn", + "t": "v", + "no": 1015, + "par": "kci1dc", + "name": "Entwurfsplanung", + "start": "2026-11-23", + "end": "2026-11-23", + "dep": null, + "abs": 500, + "ms": false, + "pers": 1, + "std": 4, + "stdD": 1, + "stdP": 1, + "col": false + }, + { + "id": "6y8fbe", + "t": "a", + "no": 1017, + "name": "Materialbestellung", + "start": "2027-01-13", + "end": "2027-01-13", + "abs": 0, + "ms": false, + "pers": 1, + "std": 2, + "stdD": 1, + "stdP": 1, + "dep": "8uba50", + "typ": "AE", + "lag": -20, + "col": false + }, + { + "id": "8uba50", + "t": "a", + "no": 1018, + "name": "Ausführung", + "start": "2027-02-10", + "end": "2027-03-09", + "abs": 0, + "ms": false, + "dep": "4btedb", + "typ": "EA", + "lag": 0, + "col": false + } + ], + "col": false, + "farbe": "#c05621", + "kcol": false + }, + { + "name": "Sanierung Sitzstufenanlage", + "nr": "0", + "bauherr": "Stadt Ratzeburg", + "umsatz": 1333, + "material": 423, + "fremd": 0, + "sonst": 150, + "mann": 1, + "tage": 1, + "status": "Angebot", + "zb": "std", + "std": 8, + "tasks": [], + "farbe": "#805ad5", + "col": false + }, + { + "name": "Staubschutzmaßnahme", + "nr": "26-019", + "bauherr": "Kirche St. Lorenz", + "umsatz": 1890, + "material": 200, + "fremd": 0, + "sonst": 150, + "mann": 1, + "tage": 2.5, + "status": "Auftrag", + "zb": "std", + "std": 17, + "tasks": [], + "farbe": "#c53030", + "col": false + }, + { + "name": "Aufstockung", + "nr": "26-018", + "bauherr": "Fam. Kasza", + "umsatz": 5000, + "material": 0, + "fremd": 0, + "sonst": 0, + "mann": 1, + "tage": 7.5, + "status": "Auftrag", + "zb": "std", + "std": 60, + "tasks": [], + "farbe": "#2c7a7b", + "col": false + }, + { + "name": "Fassade EFH", + "nr": "26-007.2", + "bauherr": "Ehep. Braun/Müller", + "umsatz": 36867, + "material": 14051, + "fremd": 0, + "sonst": 1334, + "mann": 1, + "tage": 28.5, + "status": "Auftrag", + "zb": "std", + "std": 225, + "tasks": [], + "farbe": "#97266d", + "col": false + }, + { + "name": "Trockenbauarbeiten EFH", + "nr": "26-007.1", + "bauherr": "Ehep. Braun/Müller", + "umsatz": 19877, + "material": 5787, + "fremd": 0, + "sonst": 1336, + "mann": 2, + "tage": 9, + "status": "Auftrag", + "zb": "std", + "std": 144, + "tasks": [ + { + "id": "tg5ses", + "t": "a", + "no": 1019, + "name": "Wände einseitig stellen", + "start": "2026-07-27", + "end": "2026-08-06", + "abs": 7953.79, + "col": false + }, + { + "id": "x4qevp", + "t": "a", + "no": 1020, + "name": "Wände dämmen und schließen", + "col": false + }, + { + "id": "dfol9z", + "t": "v", + "no": 1021, + "par": "x4qevp", + "name": "Trockenbauwände ohne WC und Bäder", + "start": "2026-10-12", + "end": "2026-10-16", + "dep": null, + "abs": 0, + "col": false + } + ], + "farbe": "#4a5568", + "col": false + } + ], + "kontakte": [], + "kosten": [ + { + "id": "hbz2l9", + "p": 2, + "t": "Materialkosten", + "b": 5790, + "d": "2027-02-02" + }, + { + "id": "gnq4yw", + "p": 3, + "t": "Materialkosten", + "b": 23053, + "d": "2027-02-09" + } + ], + "einnahmen": [], + "zahlungsziel": 14, + "materialziel": 7, + "firmenkosten_monatlich": [ + { + "t": "Architektenkammer", + "g": "Versicherungen/Beiträge", + "c": "Verbände / Vereine", + "b": 220, + "d": "2027-01-02", + "r": 12 + }, + { + "t": "Handwerkskammer Lübeck", + "g": "Versicherungen/Beiträge", + "c": "Verbände / Vereine", + "b": 260, + "d": "2027-01-02", + "r": 12 + }, + { + "t": "Innung", + "g": "Versicherungen/Beiträge", + "c": "Verbände / Vereine", + "b": 700, + "d": "2027-03-01", + "r": 12 + }, + { + "t": "Steuerberatungskosten - Haselon", + "g": "Sonstige Kosten", + "c": "Beratung", + "b": 120, + "d": "2026-11-15", + "r": 1 + }, + { + "t": "Plancraft", + "g": "Sonstige Kosten", + "c": "Unternehmenssoftware", + "b": 131, + "d": "2026-11-01", + "r": 1 + }, + { + "t": "Gehalt Eigner", + "g": "Personalkosten", + "c": "Personalkosten Henning", + "b": 4000, + "d": "2026-11-01", + "r": 1 + }, + { + "t": "Krankenversicherungskosten", + "g": "Personalkosten", + "c": "Personalkosten Henning", + "b": 300, + "d": "2026-11-01", + "r": 1 + }, + { + "t": "Datev UnternehmenOnline", + "g": "Sonstige Kosten", + "c": "Unternehmenssoftware", + "b": 16.5, + "d": "2026-11-01", + "r": 1 + }, + { + "t": "Betriebshaftpflicht VHV", + "g": "Versicherungen/Beiträge", + "c": "Versicherung", + "b": 1000, + "d": "2027-01-02", + "r": 12 + }, + { + "t": "BG Bau", + "g": "Versicherungen/Beiträge", + "c": "Versicherung", + "b": 30, + "d": "2026-11-01", + "r": 1 + } + ], + "firmenkosten_einmalig": [], + "kategorien": [ + "Personalkosten Henning", + "Verbände / Vereine", + "Unternehmenssoftware", + "Beratung", + "Versicherung" + ], + "arbeitszeit": { + "h": 8, + "eff": 100, + "rund": "halb" + }, + "aufgaben": [] +} \ No newline at end of file diff --git a/test/liquiditaet.test.ts b/test/liquiditaet.test.ts index f0cba0b..1db40a9 100644 --- a/test/liquiditaet.test.ts +++ b/test/liquiditaet.test.ts @@ -110,7 +110,7 @@ describe("Projekt nach V70-Regeln", () => { }; it("Rest als Schlussrechnung am Projektende, Pauschale anteilig gemindert am Projektstart", () => { - const b = projektBewegungen(plan)!; + const b = projektBewegungen(plan); expect(b.einnahmen.map((e) => [e.bezeichnung, e.netto, e.termin])).toEqual([ ["Abschlag Abbund", 4_000_000, "2026-11-10"], ["Schlussrechnung (Rest)", 6_000_000, "2026-11-20"], @@ -124,17 +124,17 @@ describe("Projekt nach V70-Regeln", () => { }); it("Anteile kaufmännisch gerundet, Summe bleibt exakt", () => { - const b = projektBewegungen({ ...plan, material: 33_333, fremd: 66_667, kosten: [{ ...plan.kosten[0]!, netto: 100 }] })!; + const b = projektBewegungen({ ...plan, material: 33_333, fremd: 66_667, kosten: [{ ...plan.kosten[0]!, netto: 100 }] }); expect(b.ausgaben.slice(1).map((a) => a.netto)).toEqual([33_300, 66_600]); }); it("Einzelkosten über der Pauschale: keine Pauschale mehr; voll abgerechnet: kein Rest", () => { - const b = projektBewegungen({ ...plan, zahlungen: [{ ...plan.zahlungen[0]!, netto: 10_000_000 }], kosten: [{ ...plan.kosten[0]!, netto: 4_000_000 }] })!; + const b = projektBewegungen({ ...plan, zahlungen: [{ ...plan.zahlungen[0]!, netto: 10_000_000 }], kosten: [{ ...plan.kosten[0]!, netto: 4_000_000 }] }); expect(b.einnahmen).toHaveLength(1); expect(b.ausgaben).toHaveLength(1); }); - it("ohne Termine fließt das Projekt nicht ein", () => { - expect(projektBewegungen({ ...plan, zeitraum: undefined })).toBeUndefined(); + it("ohne Termine zählen nur die Einzelposten", () => { + expect(projektBewegungen({ ...plan, zeitraum: undefined })).toEqual({ einnahmen: plan.zahlungen, ausgaben: plan.kosten }); }); }); diff --git a/test/v70-referenz.ts b/test/v70-referenz.ts new file mode 100644 index 0000000..1914b94 --- /dev/null +++ b/test/v70-referenz.ts @@ -0,0 +1,76 @@ +// Nachbau der V70-Liquidität (lqEvents) mit Gleitkommazahlen wie im Original, +// nur für den Vergleich in den Tests. Brutto-Ansicht, Dauerfristverlängerung (uv = 2). +import type { V70Sicherung, V70Projekt, V70Task, Uebernahme } from "../src/domain/v70.js"; +import type { Bestand } from "../src/domain/projektplan.js"; + +const DAY = 864e5; +const S2D = (s: string) => Date.UTC(+s.slice(0, 4), +s.slice(5, 7) - 1, +s.slice(8, 10)); +const D2S = (t: number) => new Date(t).toISOString().slice(0, 10); +const addD = (s: string, n: number) => D2S(S2D(s) + n * DAY); +const dow = (s: string) => new Date(S2D(s)).getUTCDay(); +const pad2 = (n: number) => ("0" + n).slice(-2); +const HC: Record> = {}; +function hol(y: number) { + if (HC[y]) return HC[y]; + const a = y % 19, b = Math.floor(y / 100), c = y % 100, d = Math.floor(b / 4), e = b % 4, f = Math.floor((b + 8) / 25), + g = Math.floor((b - f + 1) / 3), h = (19 * a + b - d - g + 15) % 30, i = Math.floor(c / 4), k = c % 4, + l = (32 + 2 * e + 2 * i - h - k) % 7, m = Math.floor((a + 11 * h + 22 * l) / 451), + mo = Math.floor((h + l - 7 * m + 114) / 31), da = ((h + l - 7 * m + 114) % 31) + 1; + const es = y + "-" + pad2(mo) + "-" + pad2(da), o: Record = {}; + [y + "-01-01", y + "-05-01", y + "-10-03", y + "-10-31", y + "-12-25", y + "-12-26", addD(es, -2), addD(es, 1), addD(es, 39), addD(es, 50)].forEach((x) => (o[x] = 1)); + return (HC[y] = o); +} +const isHol = (s: string) => !!hol(+s.slice(0, 4))[s]; +const isBiz = (s: string) => { const w = dow(s); return w !== 0 && w !== 6 && !isHol(s); }; +const nextBiz = (s: string) => { while (!isBiz(s)) s = addD(s, 1); return s; }; + +export interface V70Ereignis { d: string; a: number; g: "e" | "k" | "u" } + +export function v70Ereignisse(s: V70Sicherung, uv = 2): V70Ereignis[] { + const TAX = 0.19, f = 1 + TAX, ZZ = s.zahlungsziel ?? 14, MZ = s.materialziel ?? 7; + const ev: V70Ereignis[] = [], vi: Record = {}, vm: Record = {}; + const costs = s.kosten, incomes = s.einnahmen ?? []; + const tk = (p: V70Projekt) => p.tasks ?? []; + const kids = (p: V70Projekt, a: V70Task) => tk(p).filter((t) => t.t === "v" && t.par === a.id); + const leaf = (p: V70Projekt, t: V70Task) => t.t === "v" || (t.t === "a" && !kids(p, t).length); + const span = (arr: V70Task[]) => { let a: string | null = null, b: string | null = null; arr.forEach((t) => { if (!t.start) return; if (!a || t.start < a) a = t.start; if (!b || t.end! > b) b = t.end!; }); return a ? [a, b!] : null; }; + const sumAbs = (p: V70Projekt) => { let x = 0; tk(p).forEach((t) => { if (leaf(p, t)) x += t.abs || 0; }); return x; }; + const sumInc = (pi: number) => { let x = 0; incomes.forEach((c) => { if (+c.p === pi && c.d) x += c.b; }); return x; }; + const inc = (d: string, net: number) => { ev.push({ d, a: net * f, g: "e" }); const mk = d.slice(0, 7); vi[mk] = (vi[mk] || 0) + net; }; + s.projekte.forEach((p, pi) => { + if (p.arch) return; + const lv = tk(p).filter((t) => leaf(p, t) && t.start && t.end), sp = span(lv); + if (!sp) return; + const mat0 = p.material || 0, tot0 = mat0 + (p.fremd || 0) + (p.sonst || 0); + let sc = 0; costs.forEach((c) => { if (+c.p === pi && c.d) sc += c.b; }); + const rf = tot0 > 0 ? Math.max(0, tot0 - sc) / tot0 : 0, mat = mat0 * rf, kost = (mat0 * f + (p.fremd || 0) + (p.sonst || 0)) * rf, dm = addD(sp[0]!, MZ); + if (kost > 0) ev.push({ d: dm, a: -kost, g: "k" }); + if (mat > 0) { const mk = dm.slice(0, 7); vm[mk] = (vm[mk] || 0) + mat; } + lv.forEach((t) => { if ((t.abs ?? 0) > 0) inc(addD(t.end!, ZZ), t.abs!); }); + const rest = (p.umsatz ?? 0) - sumAbs(p) - sumInc(pi); + if (rest > 0.005) inc(addD(sp[1]!, ZZ), rest); + }); + incomes.forEach((c) => { if (c.d && s.projekte[+c.p]) inc(c.d, c.b); }); + costs.forEach((c) => { if (c.d) ev.push({ d: c.d, a: -c.b, g: "k" }); }); + const ms: Record = {}; + Object.keys(vi).concat(Object.keys(vm)).forEach((k) => (ms[k] = 1)); + Object.keys(ms).forEach((mk) => { + const z = Math.round(TAX * ((vi[mk] || 0) - (vm[mk] || 0)) * 100) / 100; + const ab = +mk.slice(0, 4) * 12 + (+mk.slice(5, 7) - 1) + uv; + if (z) ev.push({ d: nextBiz(Math.floor(ab / 12) + "-" + pad2((ab % 12) + 1) + "-10"), a: -z, g: "u" }); + }); + return ev; +} + +/** Bestand so, wie er nach dem Import in der Datenbank steht. */ +export function bestandAus(x: Uebernahme): Bestand { + const projektVonAbschnitt = new Map(x.abschnitte.map((a) => [a.schluessel, a.projekt])); + return { + projekte: x.projekte.map((p) => ({ id: p.schluessel, ...p })), + vorgaenge: x.vorgaenge.map((v) => ({ id: v.schluessel, projekt_id: projektVonAbschnitt.get(v.abschnitt)!, start: v.start, dauer: v.dauer })), + zahlungen: x.zahlungen.map((z) => ({ ...z, projekt_id: z.projekt, vorgang_id: z.vorgang })), + kosten: x.kosten.map((k) => ({ ...k, projekt_id: k.projekt })), + laufend: x.laufend, + }; +} + diff --git a/test/v70.test.ts b/test/v70.test.ts new file mode 100644 index 0000000..6a7382d --- /dev/null +++ b/test/v70.test.ts @@ -0,0 +1,118 @@ +import { describe, it, expect } from "vitest"; +import { readFileSync } from "node:fs"; +import { uebernimmV70, euroZuCent, pruefeSicherung } from "../src/domain/v70.js"; +import { liquiditaetsDaten, vorgangsEnde } from "../src/domain/projektplan.js"; +import { liquiditaet, periodenGrenzen, type Gruppe } from "../src/domain/liquiditaet.js"; +import { v70Ereignisse, bestandAus } from "./v70-referenz.js"; + +const roh = JSON.parse(readFileSync(new URL("./daten/v70-sicherung-2026-10-19.json", import.meta.url), "utf8")); +const u = uebernimmV70(roh); +const woche = { tage: u.einstellungen.arbeitstage }; + +describe("Euro in Cent", () => { + it.each([[24445.01, 2444501], [11663.64, 1166364], [7953.79, 795379], [16.5, 1650], [1.005, 101], [-2.675, -268], [0, 0]])( + "%s €", (e, c) => expect(euroZuCent(e)).toBe(c)); +}); + +describe("Übernahme der V70-Sicherung vom 19.10.2026", () => { + it("lehnt fremde Dateien ab", () => { + expect(() => pruefeSicherung({ format: "anders" })).toThrow(/keine Sicherung/); + }); + + it("übernimmt alle Datensätze", () => { + expect(u.projekte).toHaveLength(9); + expect(u.laufend).toHaveLength(10); + expect(u.kosten).toHaveLength(2); + // 7 verschiedene Bauherren als Kontakte + expect(u.kontakte.map((k) => k.name)).toEqual([ + "Stadt Ratzeburg", "Most", "Ehep. Schlünsen", "Ehep. Kodal", "Kirche St. Lorenz", "Fam. Kasza", "Ehep. Braun/Müller", + ]); + expect(u.projekte.map((p) => [p.nummer, p.status])).toEqual([ + ["P-26-014", "auftrag"], ["P-26-015", "auftrag"], ["A-27-001", "angebot"], ["A-OHNE-1", "angebot"], ["A-OHNE-2", "angebot"], + ["P-26-019", "auftrag"], ["P-26-018", "auftrag"], ["P-26-007.2", "auftrag"], ["P-26-007.1", "auftrag"], + ]); + expect(u.projekte[1]).toMatchObject({ umsatz_netto: 2444501, fremd_kosten: 1166364, sonstige_kosten: 470000 }); + }); + + it("Freitage in V70 -> Arbeitswoche Mo–Fr, Einstellungen wie V70", () => { + expect(u.einstellungen).toEqual({ + arbeitstage: [1, 2, 3, 4, 5], stundenProTag: 8, produktivitaet: 1, rundung: "halb", + zahlungsziele: { kundenTage: 14, materialTage: 7, fremdTage: 7, sonstigeTage: 7 }, + }); + expect(u.hinweise[0]).toMatch(/Freitag frei/); + }); + + it("alle Termine bleiben gleich", () => { + const termine = u.vorgaenge.map((v) => [v.name, v.start, vorgangsEnde(v, woche)]); + const v70: [string, string, string][] = []; + for (const p of roh.projekte) for (const t of p.tasks ?? []) { + const blatt = t.t === "v" || !(p.tasks as { t: string; par?: string }[]).some((k) => k.t === "v" && k.par === t.id); + if (blatt && t.start) v70.push([t.name, t.start, t.end]); + } + expect(termine.sort()).toEqual(v70.sort()); + expect(u.hinweise.filter((h) => /passt nicht/.test(h))).toEqual([]); + }); + + it("Verknüpfungen mit Art und Verzögerung, auch projektübergreifend", () => { + const name = (s: string) => u.vorgaenge.find((v) => v.schluessel === s)!.name; + expect(u.verknuepfungen.map((k) => [name(k.vorgang), name(k.vorgaenger), k.art, k.verzoegerung])).toEqual( + expect.arrayContaining([ + ["Abbund", "Materialbestellung", "EA", 0], + ["Materialbestellung", "Ausführung", "AE", -20], + ["Ausführung", "Ausführung", "EA", 0], // Fassadensanierung nach Unterstellplatz + ["Bauantrag", "Entwurf", "EA", 10], + ]), + ); + expect(u.hinweise.some((h) => /Anbau.*Materialbestellung.*keinen Termin/.test(h))).toBe(true); + }); + + it("Abschläge hängen am Vorgang, Einzelkosten ohne Vorsteuer am eigenen Tag", () => { + expect(u.zahlungen.map((z) => [z.bezeichnung, z.netto, z.termin])).toEqual([ + ["Abschlag Abbund", 100000, "2026-10-23"], + ["Abschlag Ausführung", 1477600, "2027-02-09"], + ["Abschlag Bauantrag", 100000, "2026-12-22"], + ["Abschlag Entwurfsplanung", 50000, "2026-11-23"], + ["Abschlag Wände einseitig stellen", 795379, "2026-08-06"], + ]); + expect(u.kosten[0]).toMatchObject({ projekt: "p2", netto: 579000, termin: "2027-02-02", mit_vorsteuer: false, zahlungsziel_tage: 0 }); + }); + + it("laufende Kosten mit Rhythmus, Gruppe und Kategorie", () => { + expect(u.laufend.find((l) => l.bezeichnung === "Datev UnternehmenOnline")).toEqual({ + bezeichnung: "Datev UnternehmenOnline", gruppe: "Sonstige Kosten", kategorie: "Unternehmenssoftware", betrag: 1650, rhythmus: "monatlich", start: "2026-11-01", + }); + expect(u.laufend.filter((l) => l.rhythmus === "jaehrlich")).toHaveLength(4); + }); +}); + +describe("Liquidität centgenau wie V70", () => { + const GRUPPE: Record<"e" | "k" | "u", Gruppe> = { e: "Projekteinnahmen", k: "Projektkosten", u: "Umsatzsteuer" }; + + it.each([ + ["woche", "2026-07-01", 60], + ["monat", "2026-07-01", 12], + ] as const)("%s ab %s", (ansicht, start, anzahl) => { + const daten = liquiditaetsDaten({ ...bestandAus(u), laufend: [] }, woche, true); + const neu = liquiditaet(daten, { ansicht, start, anzahl, startsaldo: 0, ziele: u.einstellungen.zahlungsziele }); + const alt = v70Ereignisse(roh); + const grenzen = periodenGrenzen({ ansicht, start, anzahl }); + let ereignisse = 0; + grenzen.forEach((g, i) => { + for (const k of ["e", "k", "u"] as const) { + const imZeitraum = alt.filter((x) => x.g === k && x.d >= g.von && x.d <= g.bis); + ereignisse += imZeitraum.length; + const v70 = Math.round(imZeitraum.reduce((s, x) => s + x.a, 0) * 100); + const wir = neu[i]!.posten.filter((p) => p.gruppe === GRUPPE[k]).reduce((s, p) => s + p.betrag, 0); + expect(wir, `${g.von} ${GRUPPE[k]}`).toBe(v70); + } + }); + expect(ereignisse).toBe(alt.length); // nichts fällt aus dem Zeitraum + }); + + it("P5: Angebote fließen nicht ein (V70 hat sie mitgerechnet)", () => { + const mit = liquiditaetsDaten(bestandAus(u), woche, true); + const ohne = liquiditaetsDaten(bestandAus(u), woche); + const projekte = (d: typeof mit) => new Set([...d.einnahmen, ...d.ausgaben].map((x) => x.projekt)); + expect([...projekte(mit)].filter((p) => !projekte(ohne).has(p)).sort()).toEqual(["A-27-001", "A-OHNE-1"]); + }); +});