Files
Betriebsf-hrungssoftware/src/server/app.ts
Claude c0dd91718e
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
Projektnummern: keine doppelten, Buchstabe A/P/G/I nach Status, Aufräumen (0.40.0)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-26 09:10:25 +00:00

601 lines
36 KiB
TypeScript

import Fastify, { type FastifyInstance, type FastifyRequest } from "fastify";
import fastifyStatic from "@fastify/static";
import { fileURLToPath } from "node:url";
import path from "node:path";
import { existsSync } from "node:fs";
import { randomBytes, timingSafeEqual } from "node:crypto";
import { z, ZodError } from "zod";
import { type Client, type Pool, transaktion } from "./db.js";
import { mitNeuplanung, pruefeVerknuepfung, terminplan } from "./terminplan.js";
import { legeZahlungsplanAn, restNachziehen, zahlungsplanFest, zahlungsplaeneAutomatisch } from "./zahlungsplan.js";
import { uebersicht } from "./uebersicht.js";
import { aufgabenKalender, baustellenKalender } from "./kalender.js";
import { nummernAufraeumen, projektNummerVorbereiten } from "./nummern.js";
import { Nextcloud, STATUSORDNER, ordnerAbgleichen, webdavBasis } from "./nextcloud.js";
import { NUR_SICHERUNG, TABELLEN } from "./tabellen.js";
import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js";
import { liquiditaet } from "../domain/liquiditaet.js";
import { laufendJeMonat, lage } from "../domain/lage.js";
import { liquiditaetsDaten } from "../domain/projektplan.js";
import { uebernimmV70 } from "../domain/v70.js";
import { speichereUebernahme } from "./v70import.js";
import { benutzerFuerSicherung, pruefeStand, speichereStand } from "./stand.js";
import { VERSION } from "./version.js";
import { type Anmeldeart, registriereAnmeldung, werName } from "./anmeldung.js";
import { istEingeteilt, registriereIch } from "./ich.js";
import { registrierePersonal } from "./personal.js";
import { registriereZeiten } from "./zeiten.js";
import { registriereUrlaub, zeitraumText } from "./urlaub.js";
import { vorlageAnwenden } from "./vorlage.js";
import { AngebotFehler, pruefeBearbeitbar, registriereAngebote } from "./angebote.js";
import { registriereStammdaten } from "./stammdaten.js";
import { registriereStundensaetze } from "./stundensaetze.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";
export interface Optionen {
pool: Pool;
/** P10: Projektordner in der Nextcloud; ohne Zugang wird nichts angelegt. Fest vorgegeben (.env, Tests) geht vor der Maske unter Daten */
nextcloud?: Nextcloud;
/** Zugang über die Maske unter Daten; in der Browser-Testversion aus, weil sie die Nextcloud nicht erreicht */
nextcloudEinrichtbar?: boolean;
/** nur für Tests: WebDAV-Anfragen abfangen */
nextcloudAbruf?: typeof fetch;
webOrdner?: string;
logger?: boolean;
/** passwort: Server; testversion: Browser-Testversion und Tests, ohne Passwörter */
anmeldung?: Anmeldeart;
/** Nur auf dem Server: Code, mit dem der erste Benutzer (Inhaber) angelegt wird */
einrichtungsCode?: string;
}
/** Wer angemeldet ist, steht im Änderungsprotokoll */
const benutzer = (req: FastifyRequest): string => werName(req);
const IdParam = z.object({ id: z.uuid() });
export async function baueApp(o: Optionen): Promise<FastifyInstance> {
const app = Fastify({ logger: o.logger ?? false, bodyLimit: 50 * 1024 * 1024 });
const { pool } = o;
app.setErrorHandler((err, _req, reply) => {
if (err instanceof ZodError) {
return reply.status(400).send({ fehler: "Eingabe ungültig", details: err.issues.map((i) => `${i.path.join(".")}: ${i.message}`) });
}
const pgCode = (err as { code?: string }).code;
if (pgCode === "23503") return reply.status(409).send({ fehler: "Verknüpfter Datensatz fehlt oder wird noch verwendet" });
if (pgCode === "23505") return reply.status(409).send({ fehler: "Eintrag gibt es schon" });
if (pgCode === "23514" || pgCode === "22P02" || pgCode === "22007" || pgCode === "22008") {
return reply.status(400).send({ fehler: "Eingabe ungültig" });
}
const status = (err as { statusCode?: number }).statusCode;
if (status && status < 500) return reply.status(status).send({ fehler: (err as Error).message });
app.log.error(err);
return reply.status(500).send({ fehler: "Interner Fehler" });
});
registriereAnmeldung(app, pool, o.anmeldung ?? "passwort", o.einrichtungsCode);
registriereIch(app, pool, ladeEinstellungen);
registrierePersonal(app, pool, ladeEinstellungen);
registriereZeiten(app, pool, ladeEinstellungen);
registriereUrlaub(app, pool, ladeEinstellungen);
app.get("/api/status", async () => {
await pool.query("select 1");
return { ok: true, version: VERSION };
});
// P10: Ordner nach dem Speichern abgleichen. Ein Fehler in der Nextcloud macht die Änderung nicht
// rückgängig; der Hinweis kommt mit zurück, und der Abgleich lässt sich wiederholen.
const einrichtbar = o.nextcloudEinrichtbar !== false;
/** Der Zugang gilt sofort nach dem Speichern unter Daten, ohne Neustart */
async function nextcloud(): Promise<Nextcloud | undefined> {
if (o.nextcloud) return o.nextcloud;
if (!einrichtbar) return undefined;
const z = (await ladeEinstellungen()).nextcloud;
if (!z.adresse || !z.benutzer) return undefined;
const passwort = (await pool.query<{ passwort: string }>("select passwort from nextcloud_zugang")).rows[0]?.passwort;
return passwort ? new Nextcloud({ url: webdavBasis(z), benutzer: z.benutzer, passwort }, o.nextcloudAbruf) : undefined;
}
async function mitOrdner(p: Record<string, any>, wer: string): Promise<Record<string, unknown>> {
const nc = await nextcloud();
if (!nc) return p;
try {
const pfad = await ordnerAbgleichen(nc, p as { nummer: string; bezeichnung: string; status: string }, p.nextcloud_link ?? null);
if (pfad === p.nextcloud_link) return p;
return await transaktion(pool, wer, async (c) => (await c.query("update projekt set nextcloud_link = $2 where id = $1 returning *", [p.id, pfad])).rows[0]);
} catch (err) {
app.log.warn(err);
return { ...p, ordner_fehler: `Projektordner in der Nextcloud: ${(err as Error).message}` };
}
}
registriereAngebote(app, pool, ladeEinstellungen, mitOrdner);
registriereStammdaten(app, pool, ladeEinstellungen);
registriereStundensaetze(app, pool);
registriereJahresplan(app, pool, { einstellungen: ladeEinstellungen, liquiDaten: () => liquiDaten() });
app.post("/api/projekte/:id/ordner", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const p = (await pool.query("select * from projekt where id = $1", [id])).rows[0];
if (!p) return reply.status(404).send({ fehler: "Nicht gefunden" });
if (!(await nextcloud())) return reply.status(409).send({ fehler: "Für die Projektordner ist kein Nextcloud-Zugang eingerichtet." });
return mitOrdner(p, benutzer(req));
});
// Maske unter Daten (Henning, 23.10.2026): Adresse, Benutzer, Ordner und App-Passwort eintragen und prüfen.
// Das Passwort geht nie zurück an die Oberfläche, nur ob eines gespeichert ist.
app.get("/api/nextcloud", async () => {
const z = (await ladeEinstellungen()).nextcloud;
const pw = (await pool.query("select geaendert_am from nextcloud_zugang")).rows[0];
return { ...z, passwortGesetzt: !!pw, passwortGeaendert: pw?.geaendert_am ?? null, fest: !!o.nextcloud, einrichtbar,
webdav: z.adresse && z.benutzer ? webdavBasis(z) : null };
});
const ZugangEingabe = z.object({
adresse: z.string().trim().max(300).refine((a) => !a || /^https:\/\/[^\s/]+/i.test(a), "Die Adresse muss mit https:// beginnen."),
benutzer: z.string().trim().max(100),
ordner: z.string().trim().max(300).refine((a) => !/^[a-z]:\\/i.test(a), "Bitte den Ordner in der Nextcloud angeben, nicht den Pfad auf dem PC (z. B. „01 Projekte“)."),
// leer = bisheriges Passwort behalten
passwort: z.string().max(200).optional(),
passwortLoeschen: z.boolean().optional(),
});
app.put("/api/nextcloud", async (req, reply) => {
const d = ZugangEingabe.parse(req.body);
if ((d.passwort || d.passwortLoeschen) && !einrichtbar) {
return reply.status(409).send({ fehler: "Das App-Passwort trägst du erst auf dem Server ein. Adresse, Benutzer und Ordner sind gespeichert und ziehen mit der Sicherung um." });
}
const e = await ladeEinstellungen();
const neu = EinstellungenSchema.parse({ ...e, nextcloud: { adresse: d.adresse.replace(/\/+$/, ""), benutzer: d.benutzer, ordner: d.ordner.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "") } });
await transaktion(pool, benutzer(req), async (c) => {
await c.query("update einstellungen set daten = $1", [neu]);
if (d.passwortLoeschen) await c.query("delete from nextcloud_zugang");
else if (d.passwort) {
await c.query(`insert into nextcloud_zugang (id, passwort, geaendert_von) values (true, $1, $2)
on conflict (id) do update set passwort = excluded.passwort, geaendert_am = now(), geaendert_von = excluded.geaendert_von`, [d.passwort, benutzer(req)]);
}
});
return reply.send({ ok: true });
});
// Verbindung prüfen: erreicht das Programm den Ordner, und welche Statusordner gibt es schon?
app.post("/api/nextcloud/pruefen", async (_req, reply) => {
const nc = await nextcloud();
if (!nc) return reply.status(409).send({ fehler: einrichtbar || o.nextcloud ? "Bitte Adresse, Benutzer und App-Passwort eintragen." : "Die Verbindung zur Nextcloud geht erst auf dem Server." });
try {
if (!(await nc.gibtEs(""))) return { ok: false, fehler: "Den Ordner gibt es unter dieser Adresse nicht. Bitte Adresse, Benutzer und Ordner prüfen." };
const da = await nc.liste("");
const statusordner = [...new Set(Object.values(STATUSORDNER))];
return { ok: true, vorhanden: statusordner.filter((s) => da.includes(s)), fehlen: statusordner.filter((s) => !da.includes(s)), anzahl: da.length };
} catch (err) {
const text = (err as Error).message;
if (/ 401 /.test(text)) return { ok: false, fehler: "Die Nextcloud lehnt die Anmeldung ab: Benutzer oder App-Passwort stimmt nicht." };
return { ok: false, fehler: `Keine Verbindung: ${text}` };
}
});
// Alle Projekte einmal abgleichen: vorhandene Ordner mit gleicher Nummer übernehmen, fehlende anlegen, falsche verschieben
app.post("/api/nextcloud/abgleichen", async (req, reply) => {
if (!(await nextcloud())) return reply.status(409).send({ fehler: "Für die Projektordner ist kein Nextcloud-Zugang eingerichtet." });
const projekte = (await pool.query("select * from projekt order by nummer")).rows;
let ok = 0;
const fehler: string[] = [];
for (const p of projekte) {
const r = await mitOrdner(p, benutzer(req));
if (r.ordner_fehler) fehler.push(`${p.nummer}: ${String(r.ordner_fehler).replace(/^Projektordner in der Nextcloud: /, "")}`);
else ok++;
}
return { ok, fehler };
});
// Ablage auf der Projektseite (Henning, 20.10.2026): Inhalt des Nextcloud-Projektordners anzeigen und Dateien öffnen
const AblageAnfrage = z.object({ pfad: z.string().max(500).default("") })
.refine((q) => !q.pfad.split("/").some((t) => t === ".." || t === "."), { message: "Pfad ungültig" });
async function ablagePfad(id: string, unter: string): Promise<string | null> {
const p = (await pool.query("select nextcloud_link from projekt where id = $1", [id])).rows[0];
if (!p) return null;
return [p.nextcloud_link, unter.replace(/^\/+|\/+$/g, "")].filter(Boolean).join("/");
}
// P13: Mitarbeiter sehen die Ablage der Projekte, auf denen sie eingeteilt sind
const ablageErlaubt = async (req: FastifyRequest, id: string) => req.wer?.rolle !== "mitarbeiter" || istEingeteilt(pool, req.wer.kontakt_id, id);
app.get("/api/projekte/:id/ablage", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const { pfad } = AblageAnfrage.parse(req.query);
if (!(await ablageErlaubt(req, id))) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." });
const nc = await nextcloud();
if (!nc) return reply.status(409).send({ fehler: einrichtbar ? "Die Ablage zeigt den Projektordner in der Nextcloud. Dafür unter Daten den Nextcloud-Zugang eintragen." : "Die Ablage zeigt den Projektordner in der Nextcloud. Das geht, sobald das Programm auf dem Server läuft." });
const p = (await pool.query("select nextcloud_link from projekt where id = $1", [id])).rows[0];
if (!p) return reply.status(404).send({ fehler: "Nicht gefunden" });
if (!p.nextcloud_link) return reply.status(409).send({ fehler: "Für dieses Projekt gibt es noch keinen Ordner in der Nextcloud." });
const eintraege = await nc.inhalt((await ablagePfad(id, pfad))!);
if (!eintraege) return reply.status(404).send({ fehler: "Ordner nicht gefunden" });
return { ordner: p.nextcloud_link, pfad, eintraege };
});
app.get("/api/projekte/:id/ablage/datei", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const { pfad } = AblageAnfrage.parse(req.query);
if (!(await ablageErlaubt(req, id))) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." });
const nc = await nextcloud();
if (!nc || !pfad) return reply.status(404).send({ fehler: "Nicht gefunden" });
const voll = await ablagePfad(id, pfad);
if (!voll) return reply.status(404).send({ fehler: "Nicht gefunden" });
const r = await nc.datei(voll);
const name = pfad.split("/").at(-1)!;
reply.header("content-type", r.headers.get("content-type") ?? "application/octet-stream");
reply.header("content-disposition", `inline; filename*=UTF-8''${encodeURIComponent(name)}`);
return reply.send(Buffer.from(await r.arrayBuffer()));
});
// Standard-Zahlungsplan von Hand anlegen (P9), z. B. für schon laufende Projekte; nur solange das Projekt keine Raten hat
app.post("/api/projekte/:id/zahlungsplan", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const p = (await pool.query("select id, umsatz_netto from projekt where id = $1", [id])).rows[0];
if (!p) return reply.status(404).send({ fehler: "Nicht gefunden" });
if (!(Number(p.umsatz_netto) > 0)) return reply.status(400).send({ fehler: "Bitte zuerst beim Projekt den Auftragswert (Umsatz netto) eintragen." });
const e = await ladeEinstellungen();
const raten = await transaktion(pool, benutzer(req), async (c) => {
if ((await c.query("select 1 from zahlung where projekt_id = $1 limit 1", [id])).rowCount) return null;
return legeZahlungsplanAn(c, id, Number(p.umsatz_netto), { tage: e.arbeitstage });
});
if (!raten) return reply.status(409).send({ fehler: "Das Projekt hat schon einen Zahlungsplan." });
return reply.status(201).send(raten);
});
// Änderungen an Vorgängen und Verknüpfungen planen die Nachfolger in derselben Transaktion neu
// T15: auch Besetzung, Abwesenheiten und Arbeitszeitmodelle ändern die Dauer berechneter Vorgänge
// Zahlungen, Kosten und Aufgaben können an Vorgängen hängen und wandern dann mit
// 0.15: Kolonnen und Subunternehmer ändern Besetzung, Dauer und die Kosten eingeplanter Subunternehmer
const PLAN = new Set(["vorgang", "vorgang_vorgaenger", "zahlung", "kosten", "aufgabe", "besetzung", "abwesenheit", "arbeitszeitmodell",
"kolonne", "kolonne_mitglied", "subunternehmer"]);
// P12: Projektänderungen legen den Zahlungsplan an oder führen ihn nach; eine Rate von Hand ändern stellt ihn fest
async function geplant<T>(c: Client, tabelle: string, fn: () => Promise<T>, bewegt: string[] = [], zahlungVon?: string): Promise<T> {
const e = await ladeEinstellungen();
if (tabelle === "projekt") {
const ergebnis = await fn();
await zahlungsplaeneAutomatisch(c, { tage: e.arbeitstage });
await restNachziehen(c);
await vorlageAnwenden(c, e.aufgabenVorlage, { tage: e.arbeitstage });
return ergebnis;
}
if (!PLAN.has(tabelle)) return fn();
const aenderung = zahlungVon ? async () => { const r = await fn(); await zahlungsplanFest(c, zahlungVon); return r; } : fn;
return (await mitNeuplanung(c, { tage: e.arbeitstage }, aenderung, bewegt, e.stundenProTag, e.aufgabenVorlage)).ergebnis;
}
// Wer das Datum einer verknüpften Zahlung, Kosten oder Aufgabe ändert (z. B. die Raute im Terminplan zieht),
// ändert den Versatz zum Vorgang: sie bleibt verknüpft und wandert weiter mit
const DATUM_FELD: Record<string, string> = { zahlung: "termin", kosten: "termin", aufgabe: "faellig_am" };
async function versatzAusDatum(c: Client, tabelle: string, daten: Record<string, unknown>, id?: string): Promise<void> {
const feld = DATUM_FELD[tabelle];
if (!feld || typeof daten[feld] !== "string" || daten.bezug_tage !== undefined) return;
const alt = id ? (await c.query(`select vorgang_id, bezug_art, freitag from ${tabelle} where id = $1`, [id])).rows[0] : undefined;
const vid = (daten.vorgang_id !== undefined ? daten.vorgang_id : alt?.vorgang_id) as string | null | undefined;
if (!vid) return;
const v = (await c.query("select id, start, start_teil, dauer, freitage from vorgang where id = $1", [vid])).rows[0];
if (!v) return;
const e = await ladeEinstellungen();
const art = (daten.bezug_art ?? alt?.bezug_art ?? "EE") as BezugArt;
daten.bezug_tage = bezugsTage({ ...v, dauer: Number(v.dauer) }, art, daten[feld] as string, { tage: e.arbeitstage }, (daten.freitag ?? alt?.freitag) as boolean | undefined);
}
const projektDerZahlung = async (c: Client, tabelle: string, id: string) =>
tabelle === "zahlung" ? (await c.query("select projekt_id from zahlung where id = $1", [id])).rows[0]?.projekt_id as string | undefined : undefined;
// U2: Felder wie der Stundenlohn gehen nur an den Inhaber; Zahlen-Arrays (Arbeitszeitmodell) als Zahlen
const fuer = (req: FastifyRequest, t: (typeof TABELLEN)[number]) => (z: Record<string, unknown> | undefined) => {
if (!z) return z;
const aus: Record<string, unknown> = { ...z };
if (req.wer?.rolle !== "inhaber") for (const f of t.nurInhaber ?? []) delete aus[f];
for (const [k, v] of Object.entries(aus)) if (Array.isArray(v)) aus[k] = v.map((x) => (typeof x === "string" && /^-?\d+(\.\d+)?$/.test(x) ? Number(x) : x));
return aus;
};
const verboten = (req: FastifyRequest, t: (typeof TABELLEN)[number], daten: Record<string, unknown>) =>
req.wer?.rolle !== "inhaber" && (t.nurInhaber ?? []).some((f) => daten[f] !== undefined);
for (const t of TABELLEN) {
const felder = Object.keys(t.schema.shape);
const teil = t.schema.partial();
app.get(`/api/${t.pfad}`, async (req) => (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows.map(fuer(req, t)));
app.get(`/api/${t.pfad}/:id`, async (req, reply) => {
const { id } = IdParam.parse(req.params);
const r = await pool.query(`select * from ${t.name} where id = $1`, [id]);
return fuer(req, t)(r.rows[0]) ?? reply.status(404).send({ fehler: "Nicht gefunden" });
});
app.post(`/api/${t.pfad}`, async (req, reply) => {
const daten = t.schema.parse(req.body) as Record<string, unknown>;
if (verboten(req, t, daten)) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." });
const row = await transaktion(pool, benutzer(req), async (c) => {
if (t.name === "vorgang_vorgaenger") await pruefeVerknuepfung(c, daten as { vorgang_id: string; vorgaenger_id: string });
await pruefeBearbeitbar(c, t.name, undefined, daten);
if (t.name === "projekt") await projektNummerVorbereiten(c, daten);
await versatzAusDatum(c, t.name, daten);
const spalten = felder.filter((f) => daten[f] !== undefined);
return geplant(c, t.name, async () =>
(await c.query(
spalten.length
? `insert into ${t.name} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *`
: `insert into ${t.name} default values returning *`,
spalten.map((s) => daten[s]),
)).rows[0], [], t.name === "zahlung" ? daten.projekt_id as string : undefined);
});
if (t.name === "projekt") return reply.status(201).send(await mitOrdner(row, benutzer(req)));
return reply.status(201).send(fuer(req, t)(row));
});
app.patch(`/api/${t.pfad}/:id`, async (req, reply) => {
const { id } = IdParam.parse(req.params);
const daten = teil.parse(req.body) as Record<string, unknown>;
if (verboten(req, t, daten)) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." });
// T15: wer die Dauer von Hand ändert, legt sie fest (wie beim Zahlungsplan)
if (t.name === "vorgang" && daten.dauer !== undefined && daten.dauer_fest === undefined) daten.dauer_fest = true;
// Kosten eines Subunternehmer-Einsatzes: wer den Betrag ändert, hält ihn fest
if (t.name === "kosten" && daten.netto !== undefined && daten.automatisch === undefined) daten.automatisch = false;
if (felder.every((f) => daten[f] === undefined)) return reply.status(400).send({ fehler: "Keine Änderung angegeben" });
const row = await transaktion(pool, benutzer(req), async (c) => {
await pruefeBearbeitbar(c, t.name, id, daten);
if (t.name === "projekt") await projektNummerVorbereiten(c, daten, id);
await versatzAusDatum(c, t.name, daten, id);
const spalten = felder.filter((f) => daten[f] !== undefined);
if (t.name === "vorgang_vorgaenger" && (daten.vorgang_id || daten.vorgaenger_id)) {
const alt = (await c.query("select vorgang_id, vorgaenger_id from vorgang_vorgaenger where id = $1", [id])).rows[0];
if (alt) await pruefeVerknuepfung(c, { ...alt, ...daten } as { vorgang_id: string; vorgaenger_id: string }, id);
}
const zahlungVon = await projektDerZahlung(c, t.name, id);
return geplant(c, t.name, async () =>
(await c.query(
`update ${t.name} set ${spalten.map((s, i) => `${s} = $${i + 2}`).join(", ")} where id = $1 returning *`,
[id, ...spalten.map((s) => daten[s])],
)).rows[0], t.name === "vorgang" && daten.start !== undefined ? [id] : [], zahlungVon);
});
if (row && t.name === "projekt" && (daten.nummer || daten.bezeichnung || daten.status)) return mitOrdner(row, benutzer(req));
return fuer(req, t)(row) ?? reply.status(404).send({ fehler: "Nicht gefunden" });
});
app.delete(`/api/${t.pfad}/:id`, async (req, reply) => {
const { id } = IdParam.parse(req.params);
const n = await transaktion(pool, benutzer(req), async (c) => {
// ein angenommenes Angebot ist das Soll der Nachkalkulation (A19) und bleibt
if (t.name === "angebot" && (await c.query("select 1 from angebot where id = $1 and status = 'angenommen'", [id])).rowCount) {
throw new AngebotFehler("Ein angenommenes Angebot lässt sich nicht löschen.");
}
// Mitarbeiter scheiden aus und bleiben für Stunden, Einsätze und Lohnauswertungen erhalten (Henning 22.10.2026)
if (t.name === "mitarbeiter" || (t.name === "kontakt" && (await c.query("select 1 from mitarbeiter where kontakt_id = $1", [id])).rowCount)) {
throw new AngebotFehler("Mitarbeiter werden nicht gelöscht. Bitte unter Personal beim Mitarbeiter ein Austrittsdatum eintragen.");
}
await pruefeBearbeitbar(c, t.name === "angebot" ? "" : t.name, id, {});
return geplant(c, t.name, async () => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount, [], await projektDerZahlung(c, t.name, id));
});
return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
});
}
async function ladeEinstellungen(): Promise<Einstellungen> {
const r = await pool.query<{ daten: unknown }>("select daten from einstellungen limit 1");
return EinstellungenSchema.parse(r.rows[0]?.daten ?? {});
}
app.get("/api/einstellungen", ladeEinstellungen);
app.put("/api/einstellungen", async (req) => {
const neu = EinstellungenSchema.parse(req.body);
await transaktion(pool, benutzer(req), async (c) => {
await c.query("update einstellungen set daten = $1", [neu]);
await vorlageAnwenden(c, neu.aufgabenVorlage, { tage: neu.arbeitstage });
});
return neu;
});
// Aufgaben-Vorlage auf alle beauftragten Projekte anwenden (Testversion nach dem Laden, Server nach dem Update)
// Projektnummern aufräumen (Henning, 26.10.2026); die Testversion ruft das beim Start, der Server in index.ts
app.post("/api/projekte/nummern-aufraeumen", async (req) => {
const ids = await transaktion(pool, benutzer(req), nummernAufraeumen);
for (const id of ids) {
const p = (await pool.query("select * from projekt where id = $1", [id])).rows[0];
if (p) await mitOrdner(p, benutzer(req));
}
return { geaendert: ids.length };
});
app.post("/api/vorlage/anwenden", async (req) => {
const e = await ladeEinstellungen();
return { neu: await transaktion(pool, benutzer(req), (c) => vorlageAnwenden(c, e.aufgabenVorlage, { tage: e.arbeitstage })) };
});
const LiquiAnfrage = z.object({
ansicht: z.enum(["woche", "monat"]).default("woche"),
start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
anzahl: z.coerce.number().int().min(1).max(104).default(12),
// offene Einnahmen mit vergangenem Zahltag als überfällig markieren und heute einrechnen
offene: z.enum(["0", "1"]).optional(),
});
/** 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"),
pool.query("select v.id, a.projekt_id, v.start, v.start_teil, v.dauer, v.freitage 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"),
]);
return 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 },
);
}
async function berechneLiquiditaet(q: z.infer<typeof LiquiAnfrage>) {
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,
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)));
// Lage der Liquidität (Henning, 21.10.2026): je Woche ab heute, frei verfügbar, Tiefpunkt und Grund
async function liquiLage(heute: string, anzahl: number) {
const e = await ladeEinstellungen();
const [wochen, laufend] = await Promise.all([
berechneLiquiditaet({ ansicht: "woche", start: heute, anzahl, offene: "1" }),
pool.query("select betrag, rhythmus, start, ende from laufende_kosten"),
]);
const laufendMonat = laufendJeMonat(laufend.rows.map((l) => ({ bezeichnung: "", betrag: Number(l.betrag), rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined })), heute);
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, jahresplanVorschau: e.jahresplanVorschau,
mitKontostand: e.liquiditaetMitKontostand,
lage: lage(wochen, e.startsaldo, mindestgrenze),
};
}
app.get("/api/liquiditaet/lage", async (req) => {
const q = z.object({ heute: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(), wochen: z.coerce.number().int().min(1).max(26).default(13) }).parse(req.query);
return liquiLage(q.heute ?? new Date().toISOString().slice(0, 10), q.wochen);
});
// Startseite: Aufgaben, Warnungen, wer macht was in den nächsten zwei Wochen, Liquidität 4 Wochen
app.get("/api/uebersicht", async (req) => {
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 };
// 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, mitKontostand: e.liquiditaetMitKontostand }), 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`);
u.warnungen.unshift(...antraege.rows.map((a) => ({ art: "urlaub" as const, ziel: `mitarbeiter-${a.kontakt_id}`, text: `Urlaubsantrag von ${a.name}: ${zeitraumText(a.von, a.bis)}` })));
// § 48b EStG: ohne gültige Freistellungsbescheinigung müssen 15 % Bauabzugsteuer einbehalten werden
const eingeplant = new Set(tp.besetzungen.filter((b) => b.kontakt_id && (tp.vorgaenge.find((v) => v.id === b.vorgang_id)?.ende ?? "") >= heute).map((b) => b.kontakt_id as string));
const subs = await pool.query(`select k.id, coalesce(nullif(trim(k.firma), ''), k.name) as name, s.freistellung_bis from kontakt k
left join subunternehmer s on s.kontakt_id = k.id where k.rolle = 'subunternehmer' order by 2`);
for (const s of subs.rows) {
const bis = s.freistellung_bis as string | null;
const text = bis && bis < heute ? `Freistellungsbescheinigung von ${s.name} ist seit ${formatDatum(bis)} abgelaufen`
: bis && bis <= plusTage(heute, 30) ? `Freistellungsbescheinigung von ${s.name} läuft am ${formatDatum(bis)} ab`
: !bis && eingeplant.has(s.id) ? `${s.name} ist eingeplant, aber ohne Freistellungsbescheinigung (§ 48b)` : "";
if (text) u.warnungen.push({ art: "freistellung", ziel: `subunternehmer-${s.id}`, text });
}
// A35: Bindefrist eines versendeten Angebots läuft bald ab
const bis = plusTage(heute, e.kalkulation.erinnerungTage);
const angebote = await pool.query(`select a.id, a.nummer, a.bindefrist, p.bezeichnung from angebot a join projekt p on p.id = a.projekt_id
where a.status = 'versendet' and a.bindefrist is not null and a.bindefrist <= $1 order by a.bindefrist`, [bis]);
for (const a of angebote.rows) {
u.warnungen.push({ art: "angebot", ziel: `angebot-${a.id}`,
text: a.bindefrist < heute ? `Bindefrist von Angebot ${a.nummer} (${a.bezeichnung}) ist seit ${formatDatum(a.bindefrist)} abgelaufen`
: `Bindefrist von Angebot ${a.nummer} (${a.bezeichnung}) endet am ${formatDatum(a.bindefrist)}, nachfassen?` });
}
return u;
});
// T11: Kalender-Abos. Ohne Anmeldung erreichbar (Outlook classic kann das nicht), geschützt durch das Geheimnis im Link
const KalenderParam = z.object({ token: z.string().min(20).max(100), name: z.enum(["baustellen.ics", "aufgaben.ics"]) });
app.get("/kalender/:token/:name", async (req, reply) => {
const q = KalenderParam.safeParse(req.params);
const e = await ladeEinstellungen();
const soll = Buffer.from(e.kalenderToken ?? "");
const ist = Buffer.from(q.success ? q.data.token : "");
if (!q.success || !e.kalenderToken || soll.length !== ist.length || !timingSafeEqual(soll, ist)) {
return reply.status(404).send({ fehler: "Nicht gefunden" });
}
const ics = q.data.name === "baustellen.ics" ? await baustellenKalender(pool, { tage: e.arbeitstage }) : await aufgabenKalender(pool);
return reply.header("content-type", "text/calendar; charset=utf-8").header("cache-control", "no-store").send(ics);
});
// Neues Geheimnis für die Kalender-Links; alte Abos hören dann auf zu funktionieren
app.post("/api/kalender/neu", async (req) => {
const e = await ladeEinstellungen();
const neu = { ...e, kalenderToken: randomBytes(24).toString("base64url") };
await transaktion(pool, benutzer(req), (c) => c.query("update einstellungen set daten = $1", [neu]));
return { kalenderToken: neu.kalenderToken };
});
app.get("/api/terminplan", async () => {
const e = await ladeEinstellungen();
return terminplan(pool, { tage: e.arbeitstage }, e.stundenProTag);
});
// Ü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 e = await ladeEinstellungen();
// nach der Übernahme gelten die Verknüpfungen: Nachfolger rücken hinter ihre Vorgänger wie in V70
const anzahl = await transaktion(pool, benutzer(req), async (c) => (await mitNeuplanung(c, { tage: e.arbeitstage }, () => speichereUebernahme(c, u))).ergebnis);
return reply.status(201).send({ anzahl, hinweise: u.hinweise });
});
// D1: Sicherung aus GET /api/export in ein leeres Programm einspielen (Umzug aus der Testversion)
app.post("/api/import/stand", async (req, reply) => {
let s;
try {
s = pruefeStand(req.body);
} catch (err) {
return reply.status(400).send({ fehler: (err as Error).message });
}
const anzahl = await transaktion(pool, benutzer(req), (c) => speichereStand(c, s));
return reply.status(201).send({ anzahl });
});
// D1: kompletter Stand als JSON-Datei
app.get("/api/export", async (_req, reply) => {
const daten: Record<string, unknown[]> = {};
for (const t of [...TABELLEN, ...NUR_SICHERUNG]) daten[t.pfad] = (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows;
daten.benutzer = await benutzerFuerSicherung(pool);
daten.ansichten = (await pool.query("select id, anmeldename, tabelle, daten from ansicht order by anmeldename, tabelle")).rows;
const stand = new Date().toISOString();
reply.header("content-disposition", `attachment; filename="betrieb-${stand.slice(0, 10)}.json"`);
return { programm: "betrieb", version: VERSION, stand, einstellungen: await ladeEinstellungen(), daten };
});
app.get("/api/protokoll", async (req) => {
const q = z.object({ datensatz: z.uuid().optional(), limit: z.coerce.number().int().min(1).max(500).default(100) }).parse(req.query);
const r = q.datensatz
? await pool.query("select * from protokoll where datensatz = $1 order by id desc limit $2", [q.datensatz, q.limit])
: await pool.query("select * from protokoll order by id desc limit $1", [q.limit]);
return r.rows;
});
const web = o.webOrdner ?? path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "web");
if (existsSync(web)) {
await app.register(fastifyStatic, { root: web, prefix: "/" });
app.setNotFoundHandler((req, reply) =>
req.url.startsWith("/api/") ? reply.status(404).send({ fehler: "Nicht gefunden" }) : reply.sendFile("index.html"),
);
}
return app;
}