Übernahme der V70-Sicherung und Liquidität aus Projekten nach V70-Regeln
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

- 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) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
Claude
2026-10-19 05:23:45 +00:00
parent 639980a4d1
commit 55fe69dc2b
13 changed files with 1357 additions and 26 deletions

View File

@@ -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 });

109
src/domain/projektplan.ts Normal file
View File

@@ -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<BestandVorgang, "start" | "dauer">, 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 };
}

363
src/domain/v70.ts Normal file
View File

@@ -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<string, Projektstatus> = {
Angebot: "angebot",
Auftrag: "auftrag",
Geplant: "auftrag",
"In Arbeit": "ausfuehrung",
Abgeschlossen: "abgeschlossen",
};
const RHYTHMUS: Record<number, Rhythmus> = { 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<V70Sicherung> | 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<Datum>();
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<string, string>();
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<string>();
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<string, string>();
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<string, string>();
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;
}

View File

@@ -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<FastifyInstance> {
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<string, unknown[]> = {};

View File

@@ -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;

View File

@@ -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,

60
src/server/v70import.ts Normal file
View File

@@ -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<string, unknown>): Promise<string> {
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<Record<string, number>> {
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<string, string>();
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,
};
}

View File

@@ -298,8 +298,26 @@ async function daten(): Promise<void> {
const e = await api<Zeile>("einstellungen");
inhalt.insertAdjacentHTML("beforeend", `
<p><a class="neben" href="/api/export" download>Kompletten Stand als JSON sichern</a></p>
<p class="hinweis">Die Datenbank wird jede Nacht gesichert und in die Nextcloud kopiert. Der Import des V70-Stands folgt, sobald die V70-Datei vorliegt.</p>
<p class="hinweis">Die Datenbank wird jede Nacht gesichert und in die Nextcloud kopiert.</p>
<h2>Übernahme aus dem Projektplaner V70</h2>
<p class="hinweis">Sicherungsdatei aus V70 wählen (projektplaner-sicherung-….json). Geht nur, solange noch nichts erfasst ist.</p>
<p><input type="file" id="v70-datei" accept=".json,application/json"></p>
<div id="v70-ergebnis"></div>
<h2>Einstellungen</h2>`);
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<string, number>; hinweise: string[] }>("import/v70", "POST", JSON.parse(await f.text()));
ziel.innerHTML = `<p>Ü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.</p>`
+ (r.hinweise.length ? `<p>Bitte prüfen:</p><ul>${r.hinweise.map((h) => `<li>${esc(h)}</li>`).join("")}</ul>` : "");
} catch (e) {
ziel.innerHTML = `<p class="fehler">${esc((e as Error).message)}</p>`;
}
datei.value = "";
};
const felder: Feld[] = [
{ name: "startsaldo", titel: "Kontostand (Startsaldo)", art: "euro" },
{ name: "kundenTage", titel: "Zahlungsziel Kunden (Tage)", art: "zahl" },