Stufe 0: Grundgerüst mit Rechenkern, Datenbank, Oberfläche und Docker-Betrieb
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:
168
src/server/app.ts
Normal file
168
src/server/app.ts
Normal file
@@ -0,0 +1,168 @@
|
||||
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 { 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 { VERSION } from "./version.js";
|
||||
|
||||
export interface Optionen {
|
||||
pool: Pool;
|
||||
webOrdner?: string;
|
||||
logger?: boolean;
|
||||
}
|
||||
|
||||
/** Benutzer kommt vom Proxy (Anmeldung); ohne Proxy, z. B. lokal, gilt "lokal". */
|
||||
function benutzer(req: FastifyRequest): string {
|
||||
const h = req.headers["x-benutzer"];
|
||||
return (Array.isArray(h) ? h[0] : h)?.trim() || "lokal";
|
||||
}
|
||||
|
||||
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" });
|
||||
});
|
||||
|
||||
app.get("/api/status", async () => {
|
||||
await pool.query("select 1");
|
||||
return { ok: true, version: VERSION };
|
||||
});
|
||||
|
||||
for (const t of TABELLEN) {
|
||||
const felder = Object.keys(t.schema.shape);
|
||||
const teil = t.schema.partial();
|
||||
|
||||
app.get(`/api/${t.pfad}`, async () => (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows);
|
||||
|
||||
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 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>;
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
const row = await transaktion(pool, benutzer(req), async (c) =>
|
||||
(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],
|
||||
);
|
||||
return reply.status(201).send(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>;
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
if (spalten.length === 0) return reply.status(400).send({ fehler: "Keine Änderung angegeben" });
|
||||
const row = await transaktion(pool, benutzer(req), async (c) =>
|
||||
(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],
|
||||
);
|
||||
return 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) => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount);
|
||||
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), (c) => c.query("update einstellungen set daten = $1", [neu]));
|
||||
return neu;
|
||||
});
|
||||
|
||||
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),
|
||||
});
|
||||
|
||||
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 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 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 });
|
||||
});
|
||||
|
||||
// D1: kompletter Stand als JSON-Datei
|
||||
app.get("/api/export", async (_req, reply) => {
|
||||
const daten: Record<string, unknown[]> = {};
|
||||
for (const t of TABELLEN) daten[t.pfad] = (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).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;
|
||||
}
|
||||
34
src/server/db.ts
Normal file
34
src/server/db.ts
Normal file
@@ -0,0 +1,34 @@
|
||||
import pg from "pg";
|
||||
|
||||
// date als 'JJJJ-MM-TT' lassen, bigint (Cent) und numeric als Zahl liefern
|
||||
pg.types.setTypeParser(1082, (v) => v);
|
||||
pg.types.setTypeParser(20, (v) => {
|
||||
const n = Number(v);
|
||||
if (!Number.isSafeInteger(n)) throw new Error(`Betrag zu groß: ${v}`);
|
||||
return n;
|
||||
});
|
||||
pg.types.setTypeParser(1700, (v) => Number(v));
|
||||
|
||||
export type Pool = pg.Pool;
|
||||
export type Client = pg.PoolClient;
|
||||
|
||||
export function erstellePool(url: string): Pool {
|
||||
return new pg.Pool({ connectionString: url, max: 10 });
|
||||
}
|
||||
|
||||
/** Führt fn in einer Transaktion aus; der Benutzer landet im Änderungsprotokoll. */
|
||||
export async function transaktion<T>(pool: Pool, benutzer: string, fn: (c: Client) => Promise<T>): Promise<T> {
|
||||
const c = await pool.connect();
|
||||
try {
|
||||
await c.query("begin");
|
||||
await c.query("select set_config('betrieb.benutzer', $1, true)", [benutzer]);
|
||||
const ergebnis = await fn(c);
|
||||
await c.query("commit");
|
||||
return ergebnis;
|
||||
} catch (e) {
|
||||
await c.query("rollback");
|
||||
throw e;
|
||||
} finally {
|
||||
c.release();
|
||||
}
|
||||
}
|
||||
29
src/server/einstellungen.ts
Normal file
29
src/server/einstellungen.ts
Normal file
@@ -0,0 +1,29 @@
|
||||
import { z } from "zod";
|
||||
|
||||
export const EinstellungenSchema = z.object({
|
||||
arbeitstage: z.array(z.number().int().min(1).max(7)).default([1, 2, 3, 4]),
|
||||
stundenProTag: z.number().positive().default(8),
|
||||
produktivitaet: z.number().positive().max(1).default(1),
|
||||
rundung: z.enum(["auf", "kaufmaennisch", "halbe"]).default("auf"),
|
||||
zahlungsziele: z
|
||||
.object({
|
||||
kundenTage: z.number().int().min(0).default(14),
|
||||
materialTage: z.number().int().min(0).default(30),
|
||||
fremdTage: z.number().int().min(0).default(14),
|
||||
sonstigeTage: z.number().int().min(0).default(0),
|
||||
})
|
||||
.prefault({}),
|
||||
ust: z
|
||||
.object({
|
||||
satz: z.number().min(0).default(19),
|
||||
voranmeldung: z.enum(["monatlich", "vierteljaehrlich"]).default("monatlich"),
|
||||
dauerfristverlaengerung: z.boolean().default(false),
|
||||
versteuerung: z.enum(["soll", "ist"]).default("soll"),
|
||||
})
|
||||
.prefault({}),
|
||||
startsaldo: z.number().int().default(0),
|
||||
startsaldoDatum: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().default(null),
|
||||
mindestreserve: z.number().int().default(0),
|
||||
});
|
||||
|
||||
export type Einstellungen = z.infer<typeof EinstellungenSchema>;
|
||||
23
src/server/index.ts
Normal file
23
src/server/index.ts
Normal file
@@ -0,0 +1,23 @@
|
||||
import { erstellePool } from "./db.js";
|
||||
import { migriere } from "./migrate.js";
|
||||
import { baueApp } from "./app.js";
|
||||
|
||||
const url = process.env.DATABASE_URL;
|
||||
if (!url) {
|
||||
console.error("DATABASE_URL fehlt");
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
const pool = erstellePool(url);
|
||||
await migriere(pool, (t) => console.log(t));
|
||||
const app = await baueApp({ pool, logger: true });
|
||||
const port = Number(process.env.PORT ?? 3000);
|
||||
await app.listen({ host: "0.0.0.0", port });
|
||||
|
||||
for (const signal of ["SIGINT", "SIGTERM"] as const) {
|
||||
process.on(signal, async () => {
|
||||
await app.close();
|
||||
await pool.end();
|
||||
process.exit(0);
|
||||
});
|
||||
}
|
||||
40
src/server/migrate.ts
Normal file
40
src/server/migrate.ts
Normal file
@@ -0,0 +1,40 @@
|
||||
import { readdir, readFile } from "node:fs/promises";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import path from "node:path";
|
||||
import type { Pool } from "./db.js";
|
||||
|
||||
const ORDNER = path.join(path.dirname(fileURLToPath(import.meta.url)), "migrations");
|
||||
|
||||
/**
|
||||
* Spielt alle noch fehlenden Migrationen in Namensreihenfolge ein, jede in eigener Transaktion.
|
||||
* Eine Sperre verhindert, dass zwei Container gleichzeitig migrieren.
|
||||
*/
|
||||
export async function migriere(pool: Pool, log: (text: string) => void = () => {}): Promise<string[]> {
|
||||
const c = await pool.connect();
|
||||
const neu: string[] = [];
|
||||
try {
|
||||
await c.query("select pg_advisory_lock(4711)");
|
||||
await c.query("create table if not exists schema_version (name text primary key, eingespielt_am timestamptz not null default now())");
|
||||
const vorhanden = new Set((await c.query<{ name: string }>("select name from schema_version")).rows.map((r) => r.name));
|
||||
const dateien = (await readdir(ORDNER)).filter((d) => d.endsWith(".sql")).sort();
|
||||
for (const datei of dateien) {
|
||||
if (vorhanden.has(datei)) continue;
|
||||
const sql = await readFile(path.join(ORDNER, datei), "utf8");
|
||||
await c.query("begin");
|
||||
try {
|
||||
await c.query(sql);
|
||||
await c.query("insert into schema_version (name) values ($1)", [datei]);
|
||||
await c.query("commit");
|
||||
} catch (e) {
|
||||
await c.query("rollback");
|
||||
throw new Error(`Migration ${datei} fehlgeschlagen: ${(e as Error).message}`);
|
||||
}
|
||||
log(`Migration ${datei} eingespielt`);
|
||||
neu.push(datei);
|
||||
}
|
||||
} finally {
|
||||
await c.query("select pg_advisory_unlock(4711)").catch(() => {});
|
||||
c.release();
|
||||
}
|
||||
return neu;
|
||||
}
|
||||
203
src/server/migrations/001_grundlage.sql
Normal file
203
src/server/migrations/001_grundlage.sql
Normal file
@@ -0,0 +1,203 @@
|
||||
-- Stufe 0: Grundlage. Objekte aus V70 mit fester ID; Verknüpfungen nur über IDs.
|
||||
-- Beträge in Cent (bigint), Datumsangaben als date.
|
||||
-- Jede Tabelle speichert, wer wann geändert hat; jede Änderung landet im Protokoll.
|
||||
|
||||
create table protokoll (
|
||||
id bigserial primary key,
|
||||
zeitpunkt timestamptz not null default now(),
|
||||
benutzer text not null,
|
||||
tabelle text not null,
|
||||
datensatz uuid not null,
|
||||
aktion text not null check (aktion in ('anlegen', 'aendern', 'loeschen')),
|
||||
vorher jsonb,
|
||||
nachher jsonb
|
||||
);
|
||||
create index protokoll_datensatz on protokoll (datensatz);
|
||||
|
||||
create function stempel_und_protokoll() returns trigger language plpgsql as $$
|
||||
declare
|
||||
wer text := coalesce(nullif(current_setting('betrieb.benutzer', true), ''), 'system');
|
||||
begin
|
||||
if tg_op = 'DELETE' then
|
||||
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher)
|
||||
values (wer, tg_table_name, old.id, 'loeschen', to_jsonb(old));
|
||||
return old;
|
||||
end if;
|
||||
new.geaendert_am := now();
|
||||
new.geaendert_von := wer;
|
||||
if tg_op = 'INSERT' then
|
||||
new.angelegt_am := now();
|
||||
insert into protokoll (benutzer, tabelle, datensatz, aktion, nachher)
|
||||
values (wer, tg_table_name, new.id, 'anlegen', to_jsonb(new));
|
||||
else
|
||||
new.angelegt_am := old.angelegt_am;
|
||||
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher, nachher)
|
||||
values (wer, tg_table_name, new.id, 'aendern', to_jsonb(old), to_jsonb(new));
|
||||
end if;
|
||||
return new;
|
||||
end $$;
|
||||
|
||||
create table kontakt (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
name text not null,
|
||||
firma text,
|
||||
rolle text not null default 'sonstige'
|
||||
check (rolle in ('bauherr', 'subunternehmer', 'lieferant', 'planer', 'mitarbeiter', 'sonstige')),
|
||||
telefon text,
|
||||
email text,
|
||||
gewerk text,
|
||||
notiz text,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
|
||||
create table projekt (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
nummer text not null unique,
|
||||
bezeichnung text not null,
|
||||
bauherr_id uuid references kontakt (id) on delete set null,
|
||||
status text not null default 'auftrag'
|
||||
check (status in ('anfrage', 'angebot', 'auftrag', 'ausfuehrung', 'abgerechnet', 'gewaehrleistung', 'abgeschlossen')),
|
||||
-- Projektpauschalen aus V70 (Einzelposten werden davon abgezogen)
|
||||
umsatz_netto bigint not null default 0,
|
||||
material_kosten bigint not null default 0,
|
||||
fremd_kosten bigint not null default 0,
|
||||
sonstige_kosten bigint not null default 0,
|
||||
vertragsart text check (vertragsart in ('vob', 'bgb')),
|
||||
abnahme_am date,
|
||||
farbe text,
|
||||
nextcloud_link text,
|
||||
reihenfolge integer not null default 0,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
|
||||
-- Abschnitte und Meilensteine sind gleichrangig unter dem Projekt
|
||||
create table abschnitt (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
projekt_id uuid not null references projekt (id) on delete cascade,
|
||||
name text not null,
|
||||
ist_meilenstein boolean not null default false,
|
||||
reihenfolge integer not null default 0,
|
||||
erledigt boolean not null default false,
|
||||
-- nur für Meilensteine ohne Vorgänge
|
||||
termin date,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
create index abschnitt_projekt on abschnitt (projekt_id);
|
||||
|
||||
create table vorgang (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
abschnitt_id uuid not null references abschnitt (id) on delete cascade,
|
||||
name text not null,
|
||||
start date not null,
|
||||
-- Dauer in Arbeitstagen; 0 = Meilenstein
|
||||
dauer numeric(6, 1) not null default 1 check (dauer >= 0),
|
||||
stunden numeric(8, 2),
|
||||
kontakt_id uuid references kontakt (id) on delete set null,
|
||||
reihenfolge integer not null default 0,
|
||||
fortschritt integer not null default 0 check (fortschritt between 0 and 100),
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
create index vorgang_abschnitt on vorgang (abschnitt_id);
|
||||
|
||||
-- Mehrere Vorgänger je Vorgang sind im Modell vorgesehen (T5)
|
||||
create table vorgang_vorgaenger (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
vorgang_id uuid not null references vorgang (id) on delete cascade,
|
||||
vorgaenger_id uuid not null references vorgang (id) on delete cascade,
|
||||
art text not null default 'EA' check (art in ('EA', 'AA', 'EE', 'AE')),
|
||||
verzoegerung integer not null default 0,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system',
|
||||
unique (vorgang_id, vorgaenger_id),
|
||||
check (vorgang_id <> vorgaenger_id)
|
||||
);
|
||||
|
||||
create table zahlung (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
projekt_id uuid not null references projekt (id) on delete cascade,
|
||||
vorgang_id uuid references vorgang (id) on delete set null,
|
||||
art text not null default 'abschlag' check (art in ('anzahlung', 'abschlag', 'nachtrag', 'schluss', 'einbehalt')),
|
||||
bezeichnung text not null,
|
||||
netto bigint not null,
|
||||
termin date not null,
|
||||
status text not null default 'geplant' check (status in ('geplant', 'gestellt', 'bezahlt')),
|
||||
rechnungsdatum date,
|
||||
bezahlt_am date,
|
||||
reihenfolge integer not null default 0,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
create index zahlung_projekt on zahlung (projekt_id);
|
||||
|
||||
create table kosten (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
projekt_id uuid not null references projekt (id) on delete cascade,
|
||||
art text not null check (art in ('material', 'fremd', 'sonstiges')),
|
||||
bezeichnung text not null,
|
||||
netto bigint not null,
|
||||
termin date not null,
|
||||
kontakt_id uuid references kontakt (id) on delete set null,
|
||||
mit_vorsteuer boolean not null default true,
|
||||
status text not null default 'geplant' check (status in ('geplant', 'bestellt', 'bezahlt')),
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
create index kosten_projekt on kosten (projekt_id);
|
||||
|
||||
create table laufende_kosten (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
bezeichnung text not null,
|
||||
kategorie text not null default 'Sonstiges',
|
||||
betrag bigint not null,
|
||||
rhythmus text not null default 'monatlich' check (rhythmus in ('einmalig', 'monatlich', 'vierteljaehrlich', 'jaehrlich')),
|
||||
start date not null,
|
||||
ende date,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
|
||||
create table aufgabe (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
text text not null,
|
||||
faellig_am date,
|
||||
langfristig boolean not null default false,
|
||||
projekt_id uuid references projekt (id) on delete set null,
|
||||
kontakt_id uuid references kontakt (id) on delete set null,
|
||||
erledigt_am timestamptz,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
|
||||
-- Genau eine Zeile mit allen Einstellungen
|
||||
create table einstellungen (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
einzeln boolean not null default true unique check (einzeln),
|
||||
daten jsonb not null default '{}',
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
insert into einstellungen (daten) values ('{}');
|
||||
|
||||
do $$
|
||||
declare t text;
|
||||
begin
|
||||
foreach t in array array['kontakt', 'projekt', 'abschnitt', 'vorgang', 'vorgang_vorgaenger', 'zahlung',
|
||||
'kosten', 'laufende_kosten', 'aufgabe', 'einstellungen'] loop
|
||||
execute format('create trigger %I_protokoll before insert or update or delete on %I
|
||||
for each row execute function stempel_und_protokoll()', t, t);
|
||||
end loop;
|
||||
end $$;
|
||||
149
src/server/tabellen.ts
Normal file
149
src/server/tabellen.ts
Normal file
@@ -0,0 +1,149 @@
|
||||
// Eingabeprüfung für die Tabellen aus Stufe 0. Feldnamen = Spaltennamen.
|
||||
import { z } from "zod";
|
||||
|
||||
const datum = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Datum im Format JJJJ-MM-TT");
|
||||
const cent = z.number().int("Betrag in ganzen Cent");
|
||||
const id = z.uuid();
|
||||
const text = z.string().trim().min(1, "darf nicht leer sein");
|
||||
const optText = z.string().trim().nullable().optional();
|
||||
|
||||
export interface Tabelle {
|
||||
name: string;
|
||||
pfad: string;
|
||||
schema: z.ZodObject;
|
||||
sortierung: string;
|
||||
}
|
||||
|
||||
export const TABELLEN: Tabelle[] = [
|
||||
{
|
||||
name: "kontakt",
|
||||
pfad: "kontakte",
|
||||
sortierung: "name",
|
||||
schema: z.object({
|
||||
name: text,
|
||||
firma: optText,
|
||||
rolle: z.enum(["bauherr", "subunternehmer", "lieferant", "planer", "mitarbeiter", "sonstige"]).optional(),
|
||||
telefon: optText,
|
||||
email: optText,
|
||||
gewerk: optText,
|
||||
notiz: optText,
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "projekt",
|
||||
pfad: "projekte",
|
||||
sortierung: "reihenfolge, nummer",
|
||||
schema: z.object({
|
||||
nummer: text,
|
||||
bezeichnung: text,
|
||||
bauherr_id: id.nullable().optional(),
|
||||
status: z.enum(["anfrage", "angebot", "auftrag", "ausfuehrung", "abgerechnet", "gewaehrleistung", "abgeschlossen"]).optional(),
|
||||
umsatz_netto: cent.optional(),
|
||||
material_kosten: cent.optional(),
|
||||
fremd_kosten: cent.optional(),
|
||||
sonstige_kosten: cent.optional(),
|
||||
vertragsart: z.enum(["vob", "bgb"]).nullable().optional(),
|
||||
abnahme_am: datum.nullable().optional(),
|
||||
farbe: optText,
|
||||
nextcloud_link: optText,
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "abschnitt",
|
||||
pfad: "abschnitte",
|
||||
sortierung: "projekt_id, reihenfolge",
|
||||
schema: z.object({
|
||||
projekt_id: id,
|
||||
name: text,
|
||||
ist_meilenstein: z.boolean().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
erledigt: z.boolean().optional(),
|
||||
termin: datum.nullable().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "vorgang",
|
||||
pfad: "vorgaenge",
|
||||
sortierung: "abschnitt_id, reihenfolge, start",
|
||||
schema: z.object({
|
||||
abschnitt_id: id,
|
||||
name: text,
|
||||
start: datum,
|
||||
dauer: z.number().min(0).optional(),
|
||||
stunden: z.number().min(0).nullable().optional(),
|
||||
kontakt_id: id.nullable().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
fortschritt: z.number().int().min(0).max(100).optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "vorgang_vorgaenger",
|
||||
pfad: "verknuepfungen",
|
||||
sortierung: "vorgang_id",
|
||||
schema: z.object({
|
||||
vorgang_id: id,
|
||||
vorgaenger_id: id,
|
||||
art: z.enum(["EA", "AA", "EE", "AE"]).optional(),
|
||||
verzoegerung: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "zahlung",
|
||||
pfad: "zahlungen",
|
||||
sortierung: "projekt_id, reihenfolge, termin",
|
||||
schema: z.object({
|
||||
projekt_id: id,
|
||||
vorgang_id: id.nullable().optional(),
|
||||
art: z.enum(["anzahlung", "abschlag", "nachtrag", "schluss", "einbehalt"]).optional(),
|
||||
bezeichnung: text,
|
||||
netto: cent,
|
||||
termin: datum,
|
||||
status: z.enum(["geplant", "gestellt", "bezahlt"]).optional(),
|
||||
rechnungsdatum: datum.nullable().optional(),
|
||||
bezahlt_am: datum.nullable().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "kosten",
|
||||
pfad: "kosten",
|
||||
sortierung: "projekt_id, termin",
|
||||
schema: z.object({
|
||||
projekt_id: id,
|
||||
art: z.enum(["material", "fremd", "sonstiges"]),
|
||||
bezeichnung: text,
|
||||
netto: cent,
|
||||
termin: datum,
|
||||
kontakt_id: id.nullable().optional(),
|
||||
mit_vorsteuer: z.boolean().optional(),
|
||||
status: z.enum(["geplant", "bestellt", "bezahlt"]).optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "laufende_kosten",
|
||||
pfad: "laufende-kosten",
|
||||
sortierung: "kategorie, bezeichnung",
|
||||
schema: z.object({
|
||||
bezeichnung: text,
|
||||
kategorie: text.optional(),
|
||||
betrag: cent,
|
||||
rhythmus: z.enum(["einmalig", "monatlich", "vierteljaehrlich", "jaehrlich"]).optional(),
|
||||
start: datum,
|
||||
ende: datum.nullable().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "aufgabe",
|
||||
pfad: "aufgaben",
|
||||
sortierung: "erledigt_am nulls first, faellig_am nulls last, angelegt_am",
|
||||
schema: z.object({
|
||||
text: text,
|
||||
faellig_am: datum.nullable().optional(),
|
||||
langfristig: z.boolean().optional(),
|
||||
projekt_id: id.nullable().optional(),
|
||||
kontakt_id: id.nullable().optional(),
|
||||
erledigt_am: z.iso.datetime({ offset: true }).nullable().optional(),
|
||||
}),
|
||||
},
|
||||
];
|
||||
2
src/server/version.ts
Normal file
2
src/server/version.ts
Normal file
@@ -0,0 +1,2 @@
|
||||
// Wird beim Release aus dem Git-Tag gesetzt (Umgebungsvariable APP_VERSION im Image).
|
||||
export const VERSION = process.env.APP_VERSION ?? "entwicklung";
|
||||
Reference in New Issue
Block a user