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:
Claude
2026-10-17 16:37:54 +00:00
commit 92d26baa4b
45 changed files with 6143 additions and 0 deletions

View File

@@ -0,0 +1,14 @@
{
"name": "Betrieb",
"dockerComposeFile": "docker-compose.yml",
"service": "dev",
"workspaceFolder": "/workspace",
"forwardPorts": [3000],
"postCreateCommand": "npm ci",
"customizations": {
"vscode": {
"extensions": ["vitest.explorer", "ms-azuretools.vscode-docker"],
"settings": { "files.eol": "\n" }
}
}
}

View File

@@ -0,0 +1,18 @@
services:
dev:
image: mcr.microsoft.com/devcontainers/typescript-node:22
command: sleep infinity
volumes:
- ..:/workspace:cached
environment:
DATABASE_URL: postgres://betrieb:betrieb@db:5432/betrieb
TEST_DATABASE_URL: postgres://betrieb:betrieb@db:5432/betrieb_test
depends_on: [db]
db:
image: postgres:16-alpine
environment:
POSTGRES_USER: betrieb
POSTGRES_PASSWORD: betrieb
POSTGRES_DB: betrieb
volumes:
- ./init-test-db.sql:/docker-entrypoint-initdb.d/init-test-db.sql:ro

View File

@@ -0,0 +1 @@
create database betrieb_test owner betrieb;

5
.dockerignore Normal file
View File

@@ -0,0 +1,5 @@
node_modules
dist
.git
deploy/.env*
*.log

46
.github/workflows/ci.yml vendored Normal file
View File

@@ -0,0 +1,46 @@
name: Prüfung
on:
pull_request:
push:
branches: [main]
jobs:
tests:
runs-on: ubuntu-latest
services:
postgres:
image: postgres:16-alpine
env:
POSTGRES_USER: betrieb
POSTGRES_PASSWORD: betrieb
POSTGRES_DB: betrieb_test
ports: ["5432:5432"]
options: --health-cmd "pg_isready -U betrieb" --health-interval 5s --health-retries 20
env:
TEST_DATABASE_URL: postgres://betrieb:betrieb@localhost:5432/betrieb_test
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 22
cache: npm
- run: npm ci
- run: npm run typecheck
- run: npm test
- run: npm run build
container:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: docker/setup-buildx-action@v3
- name: Probe-Build App
uses: docker/build-push-action@v6
with:
context: .
push: false
- name: Probe-Build Sicherung
uses: docker/build-push-action@v6
with:
context: backup
push: false

38
.github/workflows/release.yml vendored Normal file
View File

@@ -0,0 +1,38 @@
# Freigabe: Versionsnummer als Tag setzen (z. B. v1.0.0). Daraus entsteht das Image
# ghcr.io/<besitzer>/<repo>:1.0.0, das auf dem Server mit deploy/update.sh eingespielt wird.
name: Release
on:
push:
tags: ["v*.*.*"]
permissions:
contents: write
packages: write
jobs:
image:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: docker/setup-buildx-action@v3
- uses: docker/login-action@v3
with:
registry: ghcr.io
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- id: v
run: |
echo "version=${GITHUB_REF_NAME#v}" >> "$GITHUB_OUTPUT"
echo "image=ghcr.io/${GITHUB_REPOSITORY,,}" >> "$GITHUB_OUTPUT"
- uses: docker/build-push-action@v6
with:
context: .
push: true
build-args: APP_VERSION=${{ steps.v.outputs.version }}
tags: ${{ steps.v.outputs.image }}:${{ steps.v.outputs.version }}
- name: Release-Notiz aus CHANGELOG.md
run: |
awk -v v="${{ steps.v.outputs.version }}" '$0 ~ "^## " v {f=1; next} /^## /{f=0} f' CHANGELOG.md > notiz.md
gh release create "$GITHUB_REF_NAME" --title "Version ${{ steps.v.outputs.version }}" --notes-file notiz.md
env:
GH_TOKEN: ${{ github.token }}

7
.gitignore vendored Normal file
View File

@@ -0,0 +1,7 @@
node_modules/
dist/
*.log
deploy/.env
deploy/.env.*
!deploy/.env.beispiel
deploy/.vorige-version-*

10
CHANGELOG.md Normal file
View File

@@ -0,0 +1,10 @@
# Änderungen
Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen.
## 0.1.0
- Grundgerüst für Stufe 0: Server mit Datenbank, Änderungsprotokoll (wer hat wann was geändert), Export als JSON.
- Rechenkern mit Tests: Arbeitstage Mo–Do, Feiertage Schleswig-Holstein, Beträge centgenau, Umsatzsteuer-Fälligkeit, Zahlungsplan 30/40/20/10, Liquiditätsvorschau.
- Erste Oberfläche mit den Reitern aus V70; Kontakte, Projekte (Liste), laufende Kosten, Aufgaben und Liquidität sind bedienbar.
- Docker-Betrieb mit Produktion und Testumgebung, nächtlicher Sicherung, Update und Rückkehr per Befehl.

23
Dockerfile Normal file
View File

@@ -0,0 +1,23 @@
# syntax=docker/dockerfile:1
# Baustufe: Abhängigkeiten, Prüfung, Build
FROM node:22-alpine AS build
WORKDIR /app
COPY package.json package-lock.json ./
# Optionales Zertifikat für Netze mit TLS-Proxy: docker build --secret id=ca,src=ca.crt
RUN --mount=type=secret,id=ca,required=false NODE_EXTRA_CA_CERTS=/run/secrets/ca npm ci
COPY . .
RUN npm run typecheck && npx vitest run && NODE_ENV=production npm run build && npm prune --omit=dev
# Laufzeit: nur was der Server braucht
FROM node:22-alpine
WORKDIR /app
ENV NODE_ENV=production PORT=3000
ARG APP_VERSION=entwicklung
ENV APP_VERSION=$APP_VERSION
COPY --from=build /app/package.json ./
COPY --from=build /app/node_modules ./node_modules
COPY --from=build /app/dist ./dist
USER node
EXPOSE 3000
HEALTHCHECK --interval=30s --timeout=5s CMD wget -qO- http://localhost:3000/api/status || exit 1
CMD ["node", "dist/server/index.js"]

55
README.md Normal file
View File

@@ -0,0 +1,55 @@
# Betrieb – Betriebsführungsprogramm Schaarschmidt Holzbau
Nachfolger des Projektplaners V70 als Serverversion. Anforderungen und Ausbaustufen stehen im
Lasten- und Pflichtenheft; dieses Repository setzt sie um, beginnend mit Stufe 0 (Grundlage).
## Aufbau
| Ordner | Inhalt |
|---|---|
| `src/domain` | Rechenkern ohne Datenbank: Arbeitstage und Feiertage SH, Beträge in Cent, Umsatzsteuer, Zahlungsplan, Liquidität |
| `src/server` | Server (Fastify), Datenbankzugriff, Migrationen in `migrations/` |
| `src/web` | Oberfläche im Browser |
| `test` | Automatische Tests; `api.test.ts` braucht eine Testdatenbank |
| `deploy` | Betrieb auf dem Server: Docker Compose, Proxy, Update und Rückkehr |
| `backup` | Container für die nächtliche Sicherung |
Grundregeln: Beträge immer als ganze Cent, Datumsangaben als `JJJJ-MM-TT`, Verknüpfungen nur über IDs.
Jede Tabelle hat `angelegt_am`, `geaendert_am`, `geaendert_von`; jede Änderung landet in `protokoll`.
## Entwickeln
Im Dev Container (VS Code oder GitHub Codespaces) ist alles eingerichtet:
```sh
npm run dev # Server auf http://localhost:3000, Datenbank aus dem Dev Container
npm test # alle Tests
npm run typecheck
```
Ohne Dev Container: Node 22 und PostgreSQL 16, dann `DATABASE_URL` und für die API-Tests
`TEST_DATABASE_URL` setzen. Datenbankänderungen nur als neue Datei in `src/server/migrations`
(`002_….sql`, `003_….sql`); sie laufen beim Start automatisch.
## Release
1. Änderung im eigenen Zweig, Pull Request, Prüfung muss grün sein.
2. Nach dem Zusammenführen `CHANGELOG.md` ergänzen und einen Tag setzen: `git tag v1.0.0 && git push --tags`.
3. GitHub baut daraus das Image `ghcr.io/<besitzer>/<repo>:1.0.0`.
4. Auf dem Server erst die Testumgebung, nach Freigabe die Produktion:
```sh
cd deploy
./update.sh test 1.0.0
./update.sh produktion 1.0.0
./zurueck.sh produktion # falls etwas schiefgeht: vorige Version und Sicherung
```
## Server einrichten (einmalig)
1. Virtueller Server in Deutschland mit Docker, zwei DNS-Einträge (Produktion und Test) auf seine Adresse.
2. Repository auf den Server holen, `deploy/.env.beispiel` nach `deploy/.env` kopieren und ausfüllen.
3. Beim Server bei `ghcr.io` anmelden (Lesezugriff auf das Image), dann `cd deploy && docker compose up -d`.
Sicherung: jede Nacht und vor jedem Update, 30 Tage aufbewahrt, Kopie per WebDAV in die Nextcloud.
Eine Sicherung von Hand: `docker compose exec backup sicherung`.

7
backup/Dockerfile Normal file
View File

@@ -0,0 +1,7 @@
FROM postgres:16-alpine
RUN apk add --no-cache curl
ENV TZ=Europe/Berlin
COPY sicherung.sh /usr/local/bin/sicherung
COPY zeitplan.sh /usr/local/bin/zeitplan
RUN chmod +x /usr/local/bin/sicherung /usr/local/bin/zeitplan
CMD ["zeitplan"]

15
backup/sicherung.sh Executable file
View File

@@ -0,0 +1,15 @@
#!/bin/sh
# Eine Sicherung der Datenbank: pg_dump, 30 Tagesstände behalten, Kopie in die Nextcloud.
# Aufruf ohne Argument: Tagessicherung. "sicherung vor-update": zusätzliche Sicherung vor einem Update.
set -eu
art="${1:-taeglich}"
stempel="$(date +%Y-%m-%d_%H%M%S)"
datei="/sicherungen/${NAME:-betrieb}_${stempel}_${art}.dump"
pg_dump --format=custom --file="$datei.tmp"
mv "$datei.tmp" "$datei"
echo "Sicherung geschrieben: $datei ($(du -h "$datei" | cut -f1))"
find /sicherungen -name '*.dump' -mtime +"${AUFBEWAHREN_TAGE:-30}" -print -delete
if [ -n "${NEXTCLOUD_URL:-}" ]; then
curl -fsS -u "$NEXTCLOUD_BENUTZER:$NEXTCLOUD_PASSWORT" -T "$datei" "$NEXTCLOUD_URL/$(basename "$datei")"
echo "Kopie in der Nextcloud abgelegt"
fi

10
backup/zeitplan.sh Executable file
View File

@@ -0,0 +1,10 @@
#!/bin/sh
# Wartet bis zur eingestellten Uhrzeit und sichert dann, jeden Tag.
set -u
while true; do
jetzt=$(date +%s)
ziel=$(date -d "$(date +%Y-%m-%d) ${UHRZEIT:-02:30}" +%s)
[ "$ziel" -le "$jetzt" ] && ziel=$((ziel + 86400))
sleep $((ziel - jetzt))
sicherung taeglich || echo "Sicherung fehlgeschlagen" >&2
done

15
deploy/.env.beispiel Normal file
View File

@@ -0,0 +1,15 @@
# Kopieren nach .env und ausfüllen. Die Datei bleibt nur auf dem Server.
IMAGE=ghcr.io/besitzer/betrieb
APP_VERSION=1.0.0
TEST_VERSION=1.0.0
DOMAIN=betrieb.example.de
TEST_DOMAIN=test.betrieb.example.de
DB_PASSWORT=bitte-lang-und-zufaellig
APP_BENUTZER=henning
# Erzeugen mit: docker run --rm caddy:2-alpine caddy hash-password --plaintext 'geheim'
# In .env jedes $ verdoppeln ($$), sonst liest Compose es als Variable.
APP_PASSWORT_HASH=
BACKUP_UHRZEIT=02:30
NEXTCLOUD_URL=https://cloud.example.de/remote.php/dav/files/henning/Sicherungen/betrieb
NEXTCLOUD_BENUTZER=henning
NEXTCLOUD_PASSWORT=app-passwort-aus-nextcloud

24
deploy/Caddyfile Normal file
View File

@@ -0,0 +1,24 @@
# HTTPS mit automatischem Zertifikat für Produktion und Testumgebung.
# Bis zur eigenen Benutzerverwaltung (Modul 16) schützt eine Anmeldung am Proxy
# das Programm; der Name geht als X-Benutzer an die App und ins Änderungsprotokoll.
(anmeldung) {
basic_auth {
{$APP_BENUTZER} {$APP_PASSWORT_HASH}
}
}
{$DOMAIN} {
encode gzip
import anmeldung
reverse_proxy app:3000 {
header_up X-Benutzer {http.auth.user.id}
}
}
{$TEST_DOMAIN} {
encode gzip
import anmeldung
reverse_proxy app-test:3000 {
header_up X-Benutzer {http.auth.user.id}
}
}

102
deploy/docker-compose.yml Normal file
View File

@@ -0,0 +1,102 @@
# Betrieb auf dem Server: Produktion und Testumgebung nebeneinander,
# jede mit eigener Datenbank und eigener Sicherung, davor ein gemeinsamer Proxy.
# Start: docker compose up -d (Werte aus .env, Vorlage .env.beispiel)
x-app: &app
restart: unless-stopped
networks: [intern]
x-db: &db
image: postgres:16-alpine
restart: unless-stopped
environment:
POSTGRES_USER: betrieb
POSTGRES_PASSWORD: ${DB_PASSWORT}
POSTGRES_DB: betrieb
healthcheck:
test: ["CMD", "pg_isready", "-U", "betrieb"]
interval: 5s
retries: 20
networks: [intern]
x-backup: &backup
build: ../backup
image: betrieb-backup
restart: unless-stopped
networks: [intern]
x-backup-env: &backup-env
PGUSER: betrieb
PGPASSWORD: ${DB_PASSWORT}
PGDATABASE: betrieb
AUFBEWAHREN_TAGE: "30"
UHRZEIT: ${BACKUP_UHRZEIT:-02:30}
NEXTCLOUD_URL: ${NEXTCLOUD_URL:-}
NEXTCLOUD_BENUTZER: ${NEXTCLOUD_BENUTZER:-}
NEXTCLOUD_PASSWORT: ${NEXTCLOUD_PASSWORT:-}
services:
app:
<<: *app
image: ${IMAGE}:${APP_VERSION}
environment:
DATABASE_URL: postgres://betrieb:${DB_PASSWORT}@db:5432/betrieb
depends_on:
db: { condition: service_healthy }
db:
<<: *db
volumes: [db:/var/lib/postgresql/data]
backup:
<<: *backup
environment:
<<: *backup-env
PGHOST: db
NAME: produktion
volumes: [sicherungen:/sicherungen]
depends_on:
db: { condition: service_healthy }
app-test:
<<: *app
image: ${IMAGE}:${TEST_VERSION}
environment:
DATABASE_URL: postgres://betrieb:${DB_PASSWORT}@db-test:5432/betrieb
depends_on:
db-test: { condition: service_healthy }
db-test:
<<: *db
volumes: [db-test:/var/lib/postgresql/data]
backup-test:
<<: *backup
environment:
<<: *backup-env
PGHOST: db-test
NAME: test
NEXTCLOUD_URL: ""
volumes: [sicherungen-test:/sicherungen]
depends_on:
db-test: { condition: service_healthy }
proxy:
image: caddy:2-alpine
restart: unless-stopped
ports: ["80:80", "443:443"]
environment:
DOMAIN: ${DOMAIN}
TEST_DOMAIN: ${TEST_DOMAIN}
APP_BENUTZER: ${APP_BENUTZER}
APP_PASSWORT_HASH: ${APP_PASSWORT_HASH}
volumes:
- ./Caddyfile:/etc/caddy/Caddyfile:ro
- caddy:/data
networks: [intern]
volumes:
db:
db-test:
sicherungen:
sicherungen-test:
caddy:
networks:
intern:

22
deploy/update.sh Executable file
View File

@@ -0,0 +1,22 @@
#!/bin/sh
# Neue Version einspielen: erst Sicherung, dann neues Image starten.
# Migrationen laufen beim Start der App automatisch.
# ./update.sh test 1.1.0 Testumgebung
# ./update.sh produktion 1.1.0 Produktion (erst nach Freigabe in der Testumgebung)
set -eu
cd "$(dirname "$0")"
umgebung="$1"
version="$2"
case "$umgebung" in
test) app=app-test; backup=backup-test; variable=TEST_VERSION ;;
produktion) app=app; backup=backup; variable=APP_VERSION ;;
*) echo "Umgebung: test oder produktion" >&2; exit 1 ;;
esac
alt=$(grep "^$variable=" .env | cut -d= -f2)
echo "$umgebung: Update von $alt auf $version"
docker compose exec -T "$backup" sicherung vor-update
echo "$alt" > ".vorige-version-$umgebung"
sed -i "s/^$variable=.*/$variable=$version/" .env
docker compose pull "$app"
docker compose up -d "$app"
echo "Fertig. Zurück mit: ./zurueck.sh $umgebung"

19
deploy/zurueck.sh Executable file
View File

@@ -0,0 +1,19 @@
#!/bin/sh
# Rückkehr zur vorigen Version und zur Sicherung vor dem letzten Update.
# ./zurueck.sh produktion
set -eu
cd "$(dirname "$0")"
umgebung="$1"
case "$umgebung" in
test) app=app-test; backup=backup-test; variable=TEST_VERSION ;;
produktion) app=app; backup=backup; variable=APP_VERSION ;;
*) echo "Umgebung: test oder produktion" >&2; exit 1 ;;
esac
vorige=$(cat ".vorige-version-$umgebung")
sicherung=$(docker compose exec -T "$backup" sh -c 'ls -t /sicherungen/*_vor-update.dump | head -1' | tr -d '\r')
echo "$umgebung: zurück auf $vorige mit Sicherung $sicherung"
docker compose stop "$app"
docker compose exec -T "$backup" pg_restore --clean --if-exists --no-owner -d betrieb "$sicherung"
sed -i "s/^$variable=.*/$variable=$vorige/" .env
docker compose up -d "$app"
echo "Fertig."

3683
package-lock.json generated Normal file

File diff suppressed because it is too large Load Diff

34
package.json Normal file
View File

@@ -0,0 +1,34 @@
{
"name": "betrieb",
"version": "0.1.0",
"private": true,
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
"type": "module",
"engines": {
"node": ">=22"
},
"scripts": {
"dev": "npm run build:web && tsx watch src/server/index.ts",
"build": "npm run build:server && npm run build:web",
"build:server": "tsc -p tsconfig.json && cp -r src/server/migrations dist/server/",
"build:web": "node scripts/build-web.mjs",
"start": "node dist/server/index.js",
"typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.web.json --noEmit",
"test": "vitest run",
"test:watch": "vitest"
},
"dependencies": {
"@fastify/static": "^10.1.6",
"fastify": "^5.0.0",
"pg": "^8.13.0",
"zod": "^4.0.0"
},
"devDependencies": {
"@types/node": "^22.10.0",
"@types/pg": "^8.11.0",
"esbuild": "^0.25.0",
"tsx": "^4.19.0",
"typescript": "^5.9.0",
"vitest": "^3.2.0"
}
}

15
scripts/build-web.mjs Normal file
View File

@@ -0,0 +1,15 @@
import { build } from "esbuild";
import { cp, mkdir } from "node:fs/promises";
await mkdir("dist/web", { recursive: true });
await build({
entryPoints: ["src/web/app.ts"],
bundle: true,
format: "esm",
target: "es2022",
outfile: "dist/web/app.js",
sourcemap: true,
minify: process.env.NODE_ENV === "production",
});
await cp("src/web/index.html", "dist/web/index.html");
await cp("src/web/styles.css", "dist/web/styles.css");

40
src/domain/arbeitszeit.ts Normal file
View File

@@ -0,0 +1,40 @@
// Umrechnung geplanter Stunden in Arbeitstage (Arbeitszeitkalkulation aus V70).
// Die genaue V70-Rundung wird mit der V70-Datei abgeglichen, sobald sie vorliegt.
export type Rundung = "auf" | "kaufmaennisch" | "halbe";
export interface Arbeitszeitkalkulation {
stundenProTag: number;
/** Anteil produktiver Zeit, 1 = 100 % */
produktivitaet: number;
rundung: Rundung;
}
export const STANDARD_KALKULATION: Arbeitszeitkalkulation = {
stundenProTag: 8,
produktivitaet: 1,
rundung: "auf",
};
const EPS = 1e-9;
/** Stunden (Dezimalzahl) in Arbeitstage; mindestens 1 Tag, sobald Stunden > 0 sind. */
export function stundenZuArbeitstagen(stunden: number, k: Arbeitszeitkalkulation = STANDARD_KALKULATION): number {
if (!(stunden >= 0)) throw new Error(`Ungültige Stunden: ${stunden}`);
if (!(k.stundenProTag > 0) || !(k.produktivitaet > 0)) throw new Error("Ungültige Arbeitszeitkalkulation");
if (stunden === 0) return 0;
const roh = stunden / (k.stundenProTag * k.produktivitaet);
let tage: number;
switch (k.rundung) {
case "auf":
tage = Math.ceil(roh - EPS);
break;
case "kaufmaennisch":
tage = Math.floor(roh + 0.5 + EPS);
break;
case "halbe":
tage = Math.ceil(roh * 2 - EPS) / 2;
break;
}
return Math.max(tage, k.rundung === "halbe" ? 0.5 : 1);
}

64
src/domain/datum.ts Normal file
View File

@@ -0,0 +1,64 @@
// Kalenderdaten als ISO-Text 'JJJJ-MM-TT'. Gerechnet wird immer in UTC,
// damit Sommer- und Winterzeit keine Tage verschieben.
export type Datum = string;
const ISO = /^(\d{4})-(\d{2})-(\d{2})$/;
export function zuDate(d: Datum): Date {
const m = ISO.exec(d);
if (!m) throw new Error(`Ungültiges Datum: ${d}`);
const date = new Date(Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3])));
if (vonDate(date) !== d) throw new Error(`Ungültiges Datum: ${d}`);
return date;
}
export function vonDate(date: Date): Datum {
return date.toISOString().slice(0, 10);
}
export function datum(jahr: number, monat: number, tag: number): Datum {
return vonDate(new Date(Date.UTC(jahr, monat - 1, tag)));
}
export function plusTage(d: Datum, tage: number): Datum {
const date = zuDate(d);
date.setUTCDate(date.getUTCDate() + tage);
return vonDate(date);
}
/** Gleicher Tag n Monate später; fehlt der Tag (31.), gilt der Monatsletzte. */
export function plusMonate(d: Datum, monate: number): Datum {
const date = zuDate(d);
const tag = date.getUTCDate();
const ziel = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + monate, 1));
const letzter = new Date(Date.UTC(ziel.getUTCFullYear(), ziel.getUTCMonth() + 1, 0)).getUTCDate();
ziel.setUTCDate(Math.min(tag, letzter));
return vonDate(ziel);
}
/** 1 = Montag … 7 = Sonntag */
export function wochentag(d: Datum): number {
const w = zuDate(d).getUTCDay();
return w === 0 ? 7 : w;
}
export function tageZwischen(von: Datum, bis: Datum): number {
return Math.round((zuDate(bis).getTime() - zuDate(von).getTime()) / 86_400_000);
}
export function montagDerWoche(d: Datum): Datum {
return plusTage(d, 1 - wochentag(d));
}
export function monatsErster(d: Datum): Datum {
return d.slice(0, 8) + "01";
}
export function jahrVon(d: Datum): number {
return Number(d.slice(0, 4));
}
export function formatDatum(d: Datum): string {
return `${d.slice(8, 10)}.${d.slice(5, 7)}.${d.slice(0, 4)}`;
}

113
src/domain/geld.ts Normal file
View File

@@ -0,0 +1,113 @@
// Beträge werden überall als ganze Cent gespeichert und gerechnet.
// Prozentrechnung läuft über BigInt, damit kein Rundungsfehler entsteht.
// Gerundet wird kaufmännisch (ab ,5 vom Betrag weg).
export type Cent = number;
function pruefeCent(c: Cent): void {
if (!Number.isSafeInteger(c)) throw new Error(`Kein ganzer Centbetrag: ${c}`);
}
/** Teilt zaehler/nenner (BigInt) und rundet kaufmännisch. */
function teileKaufmaennisch(zaehler: bigint, nenner: bigint): bigint {
const negativ = zaehler < 0n !== nenner < 0n;
const z = zaehler < 0n ? -zaehler : zaehler;
const n = nenner < 0n ? -nenner : nenner;
const q = (2n * z + n) / (2n * n);
return negativ ? -q : q;
}
/** Prozentsatz als exakte Zahl mit bis zu 4 Nachkommastellen, z. B. 19 oder 12,5. */
function prozentSkaliert(prozent: number): bigint {
const s = Math.round(prozent * 10_000);
if (Math.abs(s / 10_000 - prozent) > 1e-9) throw new Error(`Zu viele Nachkommastellen: ${prozent}`);
return BigInt(s);
}
/** Anteil in Prozent eines Betrags, kaufmännisch auf den Cent gerundet. */
export function prozentVon(betrag: Cent, prozent: number): Cent {
pruefeCent(betrag);
return Number(teileKaufmaennisch(BigInt(betrag) * prozentSkaliert(prozent), 1_000_000n));
}
export function summe(betraege: Cent[]): Cent {
let s = 0;
for (const b of betraege) {
pruefeCent(b);
s += b;
}
pruefeCent(s);
return s;
}
/** Brutto aus Netto: Umsatzsteuer je Position kaufmännisch gerundet. */
export function brutto(netto: Cent, ustSatz: number): Cent {
return netto + prozentVon(netto, ustSatz);
}
export function ustAusNetto(netto: Cent, ustSatz: number): Cent {
return prozentVon(netto, ustSatz);
}
/** Text wie "1.234,56", "1234,5", "-12" oder "12.50" in Cent. */
export function parseEuro(text: string): Cent {
let t = text.trim().replace(/\s|€/g, "");
if (t === "") throw new Error("Leerer Betrag");
const negativ = t.startsWith("-");
if (negativ || t.startsWith("+")) t = t.slice(1);
if (t.includes(",")) {
t = t.replace(/\./g, "").replace(",", ".");
} else if (/^\d{1,3}(\.\d{3})+$/.test(t)) {
t = t.replace(/\./g, "");
}
const m = /^(\d+)(?:\.(\d{0,2}))?$/.exec(t);
if (!m) throw new Error(`Ungültiger Betrag: ${text}`);
const cent = Number(m[1]) * 100 + Number((m[2] ?? "").padEnd(2, "0"));
pruefeCent(cent);
return negativ ? -cent : cent;
}
/** Cent als "1.234,56 €" */
export function formatEuro(c: Cent, mitZeichen = true): string {
pruefeCent(c);
const negativ = c < 0;
const abs = Math.abs(c);
const euro = Math.floor(abs / 100)
.toString()
.replace(/\B(?=(\d{3})+(?!\d))/g, ".");
const text = `${negativ ? "-" : ""}${euro},${(abs % 100).toString().padStart(2, "0")}`;
return mitZeichen ? `${text} €` : text;
}
export interface Rate {
/** Anteil an der Auftragssumme in Prozent … */
prozent?: number;
/** … oder ein fester Betrag in Cent */
betrag?: Cent;
}
/**
* Zahlungsplan (P9): Jede Rate als Prozent oder fester Betrag. Die letzte Rate
* (Schlussrechnung) bekommt immer den Rest, damit die Summe der Auftragssumme entspricht.
*/
export function zahlungsplanBetraege(auftragssumme: Cent, raten: Rate[]): Cent[] {
pruefeCent(auftragssumme);
if (raten.length === 0) return [];
const vorne = raten.slice(0, -1).map((r) => {
if (r.betrag !== undefined) {
pruefeCent(r.betrag);
return r.betrag;
}
if (r.prozent !== undefined) return prozentVon(auftragssumme, r.prozent);
throw new Error("Rate ohne Prozent oder Betrag");
});
return [...vorne, auftragssumme - summe(vorne)];
}
/** Standard-Zahlungsplan bei neuen Projekten (Henning, 17.10.2026), je Projekt änderbar. */
export const STANDARD_ZAHLUNGSPLAN: { bezeichnung: string; prozent: number }[] = [
{ bezeichnung: "Anzahlung bei Auftrag", prozent: 30 },
{ bezeichnung: "Abschlag nach Abbund und Richten", prozent: 40 },
{ bezeichnung: "Abschlag nach Fertigstellung der Restarbeiten", prozent: 20 },
{ bezeichnung: "Schlussrechnung nach Abnahme", prozent: 10 },
];

123
src/domain/kalender.ts Normal file
View File

@@ -0,0 +1,123 @@
// Feiertage Schleswig-Holstein und Arbeitstage des Betriebs.
// Regel aus V70: gearbeitet wird Montag bis Donnerstag. Freitag ist immer frei
// (Büro, Aufräumen, Reserve), Wochenende und Feiertage zählen nicht.
import { type Datum, datum, plusTage, wochentag, jahrVon } from "./datum.js";
export interface Feiertag {
datum: Datum;
name: string;
}
/** Ostersonntag nach der Gaußschen Osterformel (gregorianisch, anonymer Algorithmus). */
export function ostersonntag(jahr: number): Datum {
const a = jahr % 19;
const b = Math.floor(jahr / 100);
const c = jahr % 100;
const d = Math.floor(b / 4);
const e = b % 4;
const f = Math.floor((b + 8) / 25);
const g = Math.floor((b - f + 1) / 3);
const h = (19 * a + b - d - g + 15) % 30;
const i = Math.floor(c / 4);
const k = c % 4;
const l = (32 + 2 * e + 2 * i - h - k) % 7;
const m = Math.floor((a + 11 * h + 22 * l) / 451);
const monat = Math.floor((h + l - 7 * m + 114) / 31);
const tag = ((h + l - 7 * m + 114) % 31) + 1;
return datum(jahr, monat, tag);
}
const cache = new Map<number, Feiertag[]>();
/** Gesetzliche Feiertage in Schleswig-Holstein. Reformationstag gilt seit 2018. */
export function feiertageSH(jahr: number): Feiertag[] {
const vorhanden = cache.get(jahr);
if (vorhanden) return vorhanden;
const ostern = ostersonntag(jahr);
const liste: Feiertag[] = [
{ datum: datum(jahr, 1, 1), name: "Neujahr" },
{ datum: plusTage(ostern, -2), name: "Karfreitag" },
{ datum: plusTage(ostern, 1), name: "Ostermontag" },
{ datum: datum(jahr, 5, 1), name: "Tag der Arbeit" },
{ datum: plusTage(ostern, 39), name: "Christi Himmelfahrt" },
{ datum: plusTage(ostern, 50), name: "Pfingstmontag" },
{ datum: datum(jahr, 10, 3), name: "Tag der Deutschen Einheit" },
...(jahr >= 2018 ? [{ datum: datum(jahr, 10, 31), name: "Reformationstag" }] : []),
{ datum: datum(jahr, 12, 25), name: "1. Weihnachtstag" },
{ datum: datum(jahr, 12, 26), name: "2. Weihnachtstag" },
];
liste.sort((x, y) => x.datum.localeCompare(y.datum));
cache.set(jahr, liste);
return liste;
}
export function feiertag(d: Datum): Feiertag | undefined {
return feiertageSH(jahrVon(d)).find((f) => f.datum === d);
}
export interface Arbeitswoche {
/** Wochentage 1 = Montag … 7 = Sonntag, an denen gearbeitet wird */
tage: number[];
}
export const STANDARDWOCHE: Arbeitswoche = { tage: [1, 2, 3, 4] };
export function istArbeitstag(d: Datum, woche: Arbeitswoche = STANDARDWOCHE): boolean {
return woche.tage.includes(wochentag(d)) && !feiertag(d);
}
/** Bankarbeitstag (Mo–Fr ohne Feiertag), z. B. für Steuerfälligkeiten. Freitagsregel gilt hier nicht. */
export function istBankarbeitstag(d: Datum): boolean {
return wochentag(d) <= 5 && !feiertag(d);
}
/** Der Tag selbst, falls Arbeitstag, sonst der nächste Arbeitstag. */
export function naechsterArbeitstag(d: Datum, woche: Arbeitswoche = STANDARDWOCHE): Datum {
let x = d;
for (let i = 0; i < 400; i++) {
if (istArbeitstag(x, woche)) return x;
x = plusTage(x, 1);
}
throw new Error("Kein Arbeitstag gefunden");
}
export function naechsterBankarbeitstag(d: Datum): Datum {
let x = d;
while (!istBankarbeitstag(x)) x = plusTage(x, 1);
return x;
}
/**
* Verschiebt um n Arbeitstage (n darf negativ sein). Ausgangspunkt ist der Tag selbst;
* n = 0 liefert ihn unverändert.
*/
export function verschiebeArbeitstage(d: Datum, n: number, woche: Arbeitswoche = STANDARDWOCHE): Datum {
let x = d;
const schritt = n >= 0 ? 1 : -1;
let rest = Math.abs(n);
while (rest > 0) {
x = plusTage(x, schritt);
if (istArbeitstag(x, woche)) rest--;
}
return x;
}
/**
* Letzter Arbeitstag eines Vorgangs, der am Start (bzw. dem nächsten Arbeitstag) beginnt
* und `dauer` Arbeitstage dauert. Dauer 0 ist ein Meilenstein: Ende = Start.
*/
export function endeNachDauer(start: Datum, dauer: number, woche: Arbeitswoche = STANDARDWOCHE): Datum {
if (!Number.isInteger(dauer) || dauer < 0) throw new Error(`Ungültige Dauer: ${dauer}`);
const beginn = naechsterArbeitstag(start, woche);
if (dauer === 0) return beginn;
return verschiebeArbeitstage(beginn, dauer - 1, woche);
}
/** Anzahl Arbeitstage von `von` bis `bis`, beide eingeschlossen. 0, wenn bis vor von liegt. */
export function arbeitstageZwischen(von: Datum, bis: Datum, woche: Arbeitswoche = STANDARDWOCHE): number {
if (bis < von) return 0;
let n = 0;
for (let x = von; x <= bis; x = plusTage(x, 1)) if (istArbeitstag(x, woche)) n++;
return n;
}

173
src/domain/liquiditaet.ts Normal file
View File

@@ -0,0 +1,173 @@
// Liquiditätsvorschau je Woche oder Monat.
// Grundregeln aus V70: Zahlungsziele für Kunden und Material, Umsatzsteuer, laufende Kosten.
// Offene V70-Details (Projektpauschale minus Einzelzahlungen, Freitagsregel bei
// Zahlungsterminen) werden mit der V70-Datei abgeglichen und hier ergänzt.
import { type Datum, plusTage, plusMonate, montagDerWoche, monatsErster } from "./datum.js";
import { type Cent, ustAusNetto, summe } from "./geld.js";
import { type UstEinstellungen, STANDARD_UST, zeitraumVon, faelligkeit } from "./umsatzsteuer.js";
export type Gruppe = "Projekteinnahmen" | "Projektkosten" | "Laufende Kosten" | "Umsatzsteuer";
export type Kostenart = "material" | "fremd" | "sonstiges";
export type Rhythmus = "einmalig" | "monatlich" | "vierteljaehrlich" | "jaehrlich";
export interface Einnahme {
projekt?: string;
bezeichnung: string;
netto: Cent;
/** Rechnungs- bzw. geplanter Termin */
termin: Datum;
zahlungszielTage?: number;
bezahltAm?: Datum;
}
export interface Ausgabe {
projekt?: string;
bezeichnung: string;
art: Kostenart;
netto: Cent;
termin: Datum;
zahlungszielTage?: number;
/** false z. B. bei Subunternehmern im Reverse-Charge oder Kleinunternehmern */
mitVorsteuer?: boolean;
}
export interface LaufendeKosten {
bezeichnung: string;
kategorie?: string;
/** Betrag, der vom Konto abgeht */
betrag: Cent;
rhythmus: Rhythmus;
start: Datum;
ende?: Datum;
}
export interface Zahlungsziele {
kundenTage: number;
materialTage: number;
fremdTage: number;
sonstigeTage: number;
}
export const STANDARD_ZIELE: Zahlungsziele = { kundenTage: 14, materialTage: 30, fremdTage: 14, sonstigeTage: 0 };
export interface Vorschau {
ansicht: "woche" | "monat";
start: Datum;
anzahl: number;
startsaldo: Cent;
ziele?: Zahlungsziele;
ust?: UstEinstellungen;
}
export interface Posten {
datum: Datum;
gruppe: Gruppe;
projekt?: string;
bezeichnung: string;
/** positiv = Eingang, negativ = Ausgang */
betrag: Cent;
}
export interface Periode {
von: Datum;
bis: Datum;
einnahmen: Cent;
ausgaben: Cent;
saldo: Cent;
kontostand: Cent;
posten: Posten[];
}
function zielFuer(art: Kostenart, z: Zahlungsziele): number {
return art === "material" ? z.materialTage : art === "fremd" ? z.fremdTage : z.sonstigeTage;
}
const MONATE_JE_RHYTHMUS: Record<Exclude<Rhythmus, "einmalig">, number> = {
monatlich: 1,
vierteljaehrlich: 3,
jaehrlich: 12,
};
/** Alle Termine einer laufenden Kostenposition zwischen von und bis (eingeschlossen). */
export function termineLaufend(k: LaufendeKosten, von: Datum, bis: Datum): Datum[] {
if (k.rhythmus === "einmalig") return k.start >= von && k.start <= bis ? [k.start] : [];
const schritt = MONATE_JE_RHYTHMUS[k.rhythmus];
const ende = k.ende && k.ende < bis ? k.ende : bis;
const termine: Datum[] = [];
for (let i = 0; ; i++) {
const t = plusMonate(k.start, i * schritt);
if (t > ende) break;
if (t >= von) termine.push(t);
}
return termine;
}
export function periodenGrenzen(v: Pick<Vorschau, "ansicht" | "start" | "anzahl">): { von: Datum; bis: Datum }[] {
const grenzen: { von: Datum; bis: Datum }[] = [];
let von = v.ansicht === "woche" ? montagDerWoche(v.start) : monatsErster(v.start);
for (let i = 0; i < v.anzahl; i++) {
const naechste = v.ansicht === "woche" ? plusTage(von, 7) : plusMonate(von, 1);
grenzen.push({ von, bis: plusTage(naechste, -1) });
von = naechste;
}
return grenzen;
}
export interface Daten {
einnahmen: Einnahme[];
ausgaben: Ausgabe[];
laufend: LaufendeKosten[];
}
/** Alle Zahlungsbewegungen mit ihrem Zahltag, ohne Zeitraumfilter (außer laufende Kosten). */
export function bewegungen(d: Daten, v: Vorschau, bis: Datum): Posten[] {
const ziele = v.ziele ?? STANDARD_ZIELE;
const ust = v.ust ?? STANDARD_UST;
const posten: Posten[] = [];
const ustJeZeitraum = new Map<string, Cent>();
const buche = (zeitraum: string, betrag: Cent) => ustJeZeitraum.set(zeitraum, (ustJeZeitraum.get(zeitraum) ?? 0) + betrag);
for (const e of d.einnahmen) {
const steuer = ustAusNetto(e.netto, ust.satz);
const zahltag = e.bezahltAm ?? plusTage(e.termin, e.zahlungszielTage ?? ziele.kundenTage);
posten.push({ datum: zahltag, gruppe: "Projekteinnahmen", projekt: e.projekt, bezeichnung: e.bezeichnung, betrag: e.netto + steuer });
buche(zeitraumVon(ust.versteuerung === "ist" ? zahltag : e.termin, ust.voranmeldung), steuer);
}
for (const a of d.ausgaben) {
const vorsteuer = a.mitVorsteuer === false ? 0 : ustAusNetto(a.netto, ust.satz);
const zahltag = plusTage(a.termin, a.zahlungszielTage ?? zielFuer(a.art, ziele));
posten.push({ datum: zahltag, gruppe: "Projektkosten", projekt: a.projekt, bezeichnung: a.bezeichnung, betrag: -(a.netto + vorsteuer) });
if (vorsteuer) buche(zeitraumVon(a.termin, ust.voranmeldung), -vorsteuer);
}
for (const k of d.laufend) {
for (const t of termineLaufend(k, v.start < k.start ? v.start : k.start, bis)) {
posten.push({ datum: t, gruppe: "Laufende Kosten", bezeichnung: k.bezeichnung, betrag: -k.betrag });
}
}
for (const [zeitraum, zahllast] of [...ustJeZeitraum].sort()) {
if (zahllast === 0) continue;
posten.push({
datum: faelligkeit(zeitraum, ust),
gruppe: "Umsatzsteuer",
bezeichnung: `${zahllast > 0 ? "USt-Vorauszahlung" : "USt-Erstattung"} ${zeitraum}`,
betrag: -zahllast,
});
}
return posten;
}
export function liquiditaet(d: Daten, v: Vorschau): Periode[] {
const grenzen = periodenGrenzen(v);
if (grenzen.length === 0) return [];
const alle = bewegungen(d, v, grenzen[grenzen.length - 1]!.bis);
let kontostand = v.startsaldo;
return grenzen.map(({ von, bis }) => {
const posten = alle.filter((p) => p.datum >= von && p.datum <= bis).sort((a, b) => a.datum.localeCompare(b.datum));
const einnahmen = summe(posten.filter((p) => p.betrag > 0).map((p) => p.betrag));
const ausgaben = summe(posten.filter((p) => p.betrag < 0).map((p) => p.betrag));
const saldo = einnahmen + ausgaben;
kontostand += saldo;
return { von, bis, einnahmen, ausgaben, saldo, kontostand, posten };
});
}

View File

@@ -0,0 +1,44 @@
// Fälligkeit der Umsatzsteuer-Vorauszahlung.
// Fällig am 10. nach Ablauf des Voranmeldungszeitraums, mit Dauerfristverlängerung
// einen Monat später. Fällt der Tag auf Wochenende oder Feiertag, gilt der nächste
// Werktag (§ 108 Abs. 3 AO). Die Freitagsregel des Betriebs gilt hier nicht.
import { type Datum, datum, jahrVon } from "./datum.js";
import { naechsterBankarbeitstag } from "./kalender.js";
export type Voranmeldung = "monatlich" | "vierteljaehrlich";
export type Versteuerung = "soll" | "ist";
export interface UstEinstellungen {
satz: number;
voranmeldung: Voranmeldung;
dauerfristverlaengerung: boolean;
/** Soll: nach Rechnungsdatum. Ist: nach Zahlungseingang (offene Entscheidung E5). */
versteuerung: Versteuerung;
}
export const STANDARD_UST: UstEinstellungen = {
satz: 19,
voranmeldung: "monatlich",
dauerfristverlaengerung: false,
versteuerung: "soll",
};
/** Schlüssel des Voranmeldungszeitraums, z. B. "2026-03" oder "2026-Q1". */
export function zeitraumVon(d: Datum, v: Voranmeldung): string {
const monat = Number(d.slice(5, 7));
return v === "monatlich" ? d.slice(0, 7) : `${jahrVon(d)}-Q${Math.ceil(monat / 3)}`;
}
export function faelligkeit(zeitraum: string, e: Pick<UstEinstellungen, "dauerfristverlaengerung">): Datum {
let jahr = Number(zeitraum.slice(0, 4));
let letzterMonat: number;
if (zeitraum.includes("Q")) letzterMonat = Number(zeitraum.slice(6)) * 3;
else letzterMonat = Number(zeitraum.slice(5, 7));
let monat = letzterMonat + 1 + (e.dauerfristverlaengerung ? 1 : 0);
while (monat > 12) {
monat -= 12;
jahr++;
}
return naechsterBankarbeitstag(datum(jahr, monat, 10));
}

168
src/server/app.ts Normal file
View 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
View 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();
}
}

View 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
View 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
View 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;
}

View 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
View 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
View 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";

357
src/web/app.ts Normal file
View File

@@ -0,0 +1,357 @@
// Oberfläche Stufe 0. Die Reiter folgen V70; Terminplan und Projektdetails
// kommen mit der Übernahme der V70-Oberfläche.
import { formatEuro, parseEuro } from "../domain/geld.js";
import { formatDatum } from "../domain/datum.js";
type Zeile = Record<string, any>;
// ---------- Hilfen ----------
function esc(v: unknown): string {
return String(v ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]!);
}
async function api<T = any>(pfad: string, methode = "GET", body?: unknown): Promise<T> {
const r = await fetch(`/api/${pfad}`, {
method: methode,
headers: body === undefined ? {} : { "content-type": "application/json" },
body: body === undefined ? undefined : JSON.stringify(body),
});
if (r.status === 204) return undefined as T;
const j = await r.json().catch(() => ({}));
if (!r.ok) throw new Error([j.fehler ?? `Fehler ${r.status}`, ...(j.details ?? [])].join("\n"));
return j as T;
}
const inhalt = document.getElementById("inhalt")!;
const huelle = document.getElementById("dialog-huelle")!;
const heute = () => new Date().toISOString().slice(0, 10);
const euro = (c: number | null | undefined) => (c == null ? "" : formatEuro(c));
const dat = (d: string | null | undefined) => (d ? formatDatum(d) : "");
// ---------- Eigene Dialoge (keine Browser-Abfragen) ----------
interface Feld {
name: string;
titel: string;
art?: "text" | "euro" | "datum" | "auswahl" | "zahl" | "langtext";
optionen?: [string, string][];
pflicht?: boolean;
}
function dialog(titel: string, felder: Feld[], werte: Zeile, mitLoeschen: boolean): Promise<{ aktion: "speichern"; daten: Zeile } | { aktion: "loeschen" } | null> {
return new Promise((fertig) => {
const feldHtml = felder
.map((f) => {
const v = werte[f.name];
const id = `f-${f.name}`;
let eingabe: string;
if (f.art === "auswahl") {
eingabe = `<select id="${id}">${f.optionen!.map(([w, t]) => `<option value="${esc(w)}"${w === (v ?? "") ? " selected" : ""}>${esc(t)}</option>`).join("")}</select>`;
} else if (f.art === "langtext") {
eingabe = `<textarea id="${id}" rows="3">${esc(v)}</textarea>`;
} else {
const typ = f.art === "datum" ? "date" : "text";
const anzeige = f.art === "euro" && v != null ? formatEuro(v, false) : v;
eingabe = `<input id="${id}" type="${typ}" value="${esc(anzeige)}"${f.art === "euro" || f.art === "zahl" ? ' inputmode="decimal"' : ""}>`;
}
return `<label for="${id}">${esc(f.titel)}${f.pflicht ? " *" : ""}</label>${eingabe}`;
})
.join("");
huelle.innerHTML = `<form class="dialog"><h2>${esc(titel)}</h2>${feldHtml}<p class="fehler" id="dialog-fehler"></p>
<div class="knoepfe">${mitLoeschen ? '<button type="button" class="neben links" data-a="loeschen">Löschen</button>' : ""}
<button type="button" class="neben" data-a="abbrechen">Abbrechen</button><button type="submit" class="haupt">Speichern</button></div></form>`;
huelle.hidden = false;
const form = huelle.querySelector("form")!;
const schliessen = (e: Parameters<typeof fertig>[0]) => {
huelle.hidden = true;
huelle.innerHTML = "";
document.removeEventListener("keydown", taste);
fertig(e);
};
const taste = (ev: KeyboardEvent) => ev.key === "Escape" && schliessen(null);
document.addEventListener("keydown", taste);
(form.querySelector("input,select,textarea") as HTMLElement | null)?.focus();
form.addEventListener("click", (ev) => {
const a = (ev.target as HTMLElement).dataset.a;
if (a === "abbrechen") schliessen(null);
if (a === "loeschen") bestaetigen("Wirklich löschen?").then((ja) => ja && schliessen({ aktion: "loeschen" }));
});
form.addEventListener("submit", (ev) => {
ev.preventDefault();
const daten: Zeile = {};
try {
for (const f of felder) {
const roh = (form.querySelector(`#f-${f.name}`) as HTMLInputElement).value.trim();
if (f.pflicht && !roh) throw new Error(`${f.titel} fehlt`);
if (f.art === "euro") daten[f.name] = roh ? parseEuro(roh) : f.pflicht ? 0 : null;
else if (f.art === "zahl") daten[f.name] = roh ? Number(roh.replace(",", ".")) : null;
else daten[f.name] = roh || null;
}
} catch (e) {
form.querySelector("#dialog-fehler")!.textContent = (e as Error).message;
return;
}
schliessen({ aktion: "speichern", daten });
});
});
}
function bestaetigen(frage: string): Promise<boolean> {
return new Promise((fertig) => {
const box = document.createElement("div");
box.className = "dialog";
box.style.position = "fixed";
box.innerHTML = `<h2>${esc(frage)}</h2><div class="knoepfe"><button class="neben" data-a="nein">Abbrechen</button><button class="haupt" data-a="ja">Ja</button></div>`;
huelle.appendChild(box);
box.addEventListener("click", (ev) => {
const a = (ev.target as HTMLElement).dataset.a;
if (!a) return;
box.remove();
fertig(a === "ja");
});
});
}
async function bearbeiten(pfad: string, titel: string, felder: Feld[], zeile: Zeile | null, vorgaben: Zeile = {}): Promise<boolean> {
const e = await dialog(titel, felder, zeile ?? vorgaben, !!zeile);
if (!e) return false;
if (e.aktion === "loeschen") await api(`${pfad}/${zeile!.id}`, "DELETE");
else if (zeile) await api(`${pfad}/${zeile.id}`, "PATCH", e.daten);
else await api(pfad, "POST", { ...vorgaben, ...e.daten });
return true;
}
function tabelle(spalten: { titel: string; wert: (z: Zeile) => string; klasse?: string }[], zeilen: Zeile[], klick?: (z: Zeile) => void): HTMLTableElement {
const t = document.createElement("table");
t.innerHTML = `<thead><tr>${spalten.map((s) => `<th class="${s.klasse ?? ""}">${esc(s.titel)}</th>`).join("")}</tr></thead>
<tbody>${zeilen.map((z, i) => `<tr data-i="${i}" class="${klick ? "klickbar" : ""}">${spalten.map((s) => `<td class="${s.klasse ?? ""}">${s.wert(z)}</td>`).join("")}</tr>`).join("")}</tbody>`;
if (klick) t.addEventListener("click", (ev) => {
const tr = (ev.target as HTMLElement).closest("tr[data-i]") as HTMLElement | null;
if (tr) klick(zeilen[Number(tr.dataset.i)]!);
});
return t;
}
function seite(titel: string, knopf?: { text: string; aktion: () => void }): HTMLElement {
inhalt.innerHTML = `<h1>${esc(titel)}</h1>`;
const leiste = document.createElement("div");
leiste.className = "leiste";
if (knopf) {
const b = document.createElement("button");
b.className = "haupt";
b.textContent = knopf.text;
b.onclick = knopf.aktion;
leiste.appendChild(b);
}
inhalt.appendChild(leiste);
return leiste;
}
// ---------- Reiter ----------
const ROLLEN: [string, string][] = [
["bauherr", "Bauherr"], ["subunternehmer", "Subunternehmer"], ["lieferant", "Lieferant"],
["planer", "Planer"], ["mitarbeiter", "Mitarbeiter"], ["sonstige", "Sonstige"],
];
const KONTAKT_FELDER: Feld[] = [
{ name: "name", titel: "Name", pflicht: true }, { name: "firma", titel: "Firma" },
{ name: "rolle", titel: "Rolle", art: "auswahl", optionen: ROLLEN }, { name: "gewerk", titel: "Gewerk" },
{ name: "telefon", titel: "Telefon" }, { name: "email", titel: "E-Mail" }, { name: "notiz", titel: "Notiz", art: "langtext" },
];
async function kontakte(): Promise<void> {
const neu = async () => (await bearbeiten("kontakte", "Neuer Kontakt", KONTAKT_FELDER, null)) && kontakte();
seite("Kontakte", { text: "Neuer Kontakt", aktion: neu });
const zeilen = await api<Zeile[]>("kontakte");
const rolle = Object.fromEntries(ROLLEN);
inhalt.appendChild(tabelle([
{ titel: "Name", wert: (z) => esc(z.name) },
{ titel: "Firma", wert: (z) => esc(z.firma), klasse: "optional" },
{ titel: "Rolle", wert: (z) => esc(rolle[z.rolle]) },
{ titel: "Telefon", wert: (z) => (z.telefon ? `<a href="tel:${esc(z.telefon)}">${esc(z.telefon)}</a>` : "") },
{ titel: "E-Mail", wert: (z) => esc(z.email), klasse: "optional" },
], zeilen, async (z) => (await bearbeiten("kontakte", "Kontakt bearbeiten", KONTAKT_FELDER, z)) && kontakte()));
}
async function projekte(): Promise<void> {
const kontaktListe = await api<Zeile[]>("kontakte");
const felder: Feld[] = [
{ name: "nummer", titel: "Nummer", pflicht: true }, { name: "bezeichnung", titel: "Baustelle", pflicht: true },
{ name: "bauherr_id", titel: "Bauherr", art: "auswahl", optionen: [["", "–"], ...kontaktListe.map((k): [string, string] => [k.id, k.name])] },
{ name: "umsatz_netto", titel: "Umsatz netto", art: "euro" }, { name: "material_kosten", titel: "Materialkosten", art: "euro" },
{ name: "fremd_kosten", titel: "Fremdkosten", art: "euro" }, { name: "sonstige_kosten", titel: "Sonstige Kosten", art: "euro" },
];
const ohneNull = (z: Zeile | null) => z && { ...z, ...Object.fromEntries(["umsatz_netto", "material_kosten", "fremd_kosten", "sonstige_kosten"].map((k) => [k, z[k] ?? 0])) };
const speichern = async (z: Zeile | null) => {
if (await bearbeiten("projekte", z ? "Projekt bearbeiten" : "Neues Projekt", felder, z)) projekte();
};
seite("Projekte", { text: "Neues Projekt", aktion: () => speichern(null) });
const zeilen = await api<Zeile[]>("projekte");
const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name]));
const kostenSumme = (z: Zeile) => z.material_kosten + z.fremd_kosten + z.sonstige_kosten;
inhalt.appendChild(tabelle([
{ titel: "Nr.", wert: (z) => esc(z.nummer) },
{ titel: "Baustelle", wert: (z) => esc(z.bezeichnung) },
{ titel: "Bauherr", wert: (z) => esc(name[z.bauherr_id]), klasse: "optional" },
{ titel: "Umsatz netto", wert: (z) => euro(z.umsatz_netto), klasse: "zahl" },
{ titel: "Kosten", wert: (z) => euro(kostenSumme(z)), klasse: "zahl optional" },
{ titel: "Rohertrag", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), klasse: "zahl" },
], zeilen, (z) => speichern(ohneNull(z))));
const gesamt = zeilen.reduce((s, z) => s + z.umsatz_netto - kostenSumme(z), 0);
inhalt.insertAdjacentHTML("beforeend", `<p>Rohertrag gesamt: <strong>${euro(gesamt)}</strong></p>
<p class="hinweis">Projektdetailseite, Einzelposten und Zahlungsplan folgen mit der V70-Übernahme.</p>`);
}
async function terminplan(): Promise<void> {
seite("Terminplan");
inhalt.insertAdjacentHTML("beforeend", `<p class="hinweis">Der Gantt-Terminplan aus V70 wird als Nächstes übernommen. Arbeitstage (Mo–Do, Feiertage Schleswig-Holstein) und Stundenumrechnung sind bereits fertig und geprüft.</p>`);
}
async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {
const leiste = seite("Liquidität");
leiste.innerHTML = `<select id="l-ansicht"><option value="woche">Wochen</option><option value="monat">Monate</option></select>
<select id="l-anzahl">${[4, 8, 12, 26, 52].map((n) => `<option>${n}</option>`).join("")}</select>`;
const a = leiste.querySelector("#l-ansicht") as HTMLSelectElement;
const n = leiste.querySelector("#l-anzahl") as HTMLSelectElement;
a.value = ansicht;
n.value = String(anzahl);
a.onchange = n.onchange = () => liquiditaetSeite(a.value, Number(n.value));
const perioden = await api<Zeile[]>(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`);
inhalt.appendChild(tabelle([
{ titel: ansicht === "woche" ? "Woche ab" : "Monat", wert: (p) => (ansicht === "woche" ? dat(p.von) : esc(p.von.slice(5, 7) + "/" + p.von.slice(0, 4))) },
{ titel: "Einnahmen", wert: (p) => euro(p.einnahmen), klasse: "zahl" },
{ titel: "Ausgaben", wert: (p) => euro(p.ausgaben), klasse: "zahl" },
{ titel: "Saldo", wert: (p) => euro(p.saldo), klasse: "zahl optional" },
{ titel: "Kontostand", wert: (p) => `<span class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</span>`, klasse: "zahl" },
], perioden, (p) => {
const text = p.posten.map((x: Zeile) => `${dat(x.datum)} ${x.gruppe} ${x.projekt ?? ""} ${x.bezeichnung}: ${formatEuro(x.betrag)}`).join("\n") || "Keine Bewegungen";
dialog(`${dat(p.von)} bis ${dat(p.bis)}`, [{ name: "t", titel: "Bewegungen", art: "langtext" }], { t: text }, false);
}));
}
const RHYTHMEN: [string, string][] = [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"], ["jaehrlich", "jährlich"], ["einmalig", "einmalig"]];
const LK_FELDER: Feld[] = [
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "kategorie", titel: "Kategorie" },
{ name: "betrag", titel: "Betrag", art: "euro", pflicht: true }, { name: "rhythmus", titel: "Rhythmus", art: "auswahl", optionen: RHYTHMEN },
{ name: "start", titel: "Erste Zahlung", art: "datum", pflicht: true }, { name: "ende", titel: "Endet am", art: "datum" },
];
async function laufendeKosten(): Promise<void> {
const neu = async () => (await bearbeiten("laufende-kosten", "Neue laufende Kosten", LK_FELDER, null, { start: heute(), rhythmus: "monatlich" })) && laufendeKosten();
seite("Laufende Kosten", { text: "Neue Position", aktion: neu });
const zeilen = await api<Zeile[]>("laufende-kosten");
const r = Object.fromEntries(RHYTHMEN);
inhalt.appendChild(tabelle([
{ titel: "Kategorie", wert: (z) => esc(z.kategorie) }, { titel: "Bezeichnung", wert: (z) => esc(z.bezeichnung) },
{ titel: "Rhythmus", wert: (z) => esc(r[z.rhythmus]) }, { titel: "Ab", wert: (z) => dat(z.start), klasse: "optional" },
{ titel: "Betrag", wert: (z) => euro(z.betrag), klasse: "zahl" },
], zeilen, async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && laufendeKosten()));
const monat = zeilen.filter((z) => z.rhythmus === "monatlich" && (!z.ende || z.ende >= heute())).reduce((s, z) => s + z.betrag, 0);
inhalt.insertAdjacentHTML("beforeend", `<p>Monatlich: <strong>${euro(monat)}</strong></p>`);
}
const AUFGABE_FELDER: Feld[] = [
{ name: "text", titel: "Aufgabe", pflicht: true }, { name: "faellig_am", titel: "Fällig am", art: "datum" },
];
function aufgabenTabelle(zeilen: Zeile[], neuLaden: () => void): HTMLTableElement {
const t = tabelle([
{ titel: "", wert: (z) => `<input type="checkbox" data-id="${z.id}"${z.erledigt_am ? " checked" : ""}>` },
{ titel: "Aufgabe", wert: (z) => (z.erledigt_am ? `<s>${esc(z.text)}</s>` : esc(z.text)) },
{ titel: "Fällig", wert: (z) => `<span class="${!z.erledigt_am && z.faellig_am && z.faellig_am < heute() ? "fehler" : ""}">${dat(z.faellig_am)}</span>` },
], zeilen, async (z) => (await bearbeiten("aufgaben", "Aufgabe bearbeiten", AUFGABE_FELDER, z)) && neuLaden());
t.addEventListener("click", async (ev) => {
const box = ev.target as HTMLInputElement;
if (box.type !== "checkbox") return;
ev.stopPropagation();
await api(`aufgaben/${box.dataset.id}`, "PATCH", { erledigt_am: box.checked ? new Date().toISOString() : null });
neuLaden();
}, true);
return t;
}
async function aufgaben(): Promise<void> {
const neu = async () => (await bearbeiten("aufgaben", "Neue Aufgabe", AUFGABE_FELDER, null)) && aufgaben();
seite("Aufgaben", { text: "Neue Aufgabe", aktion: neu });
inhalt.appendChild(aufgabenTabelle(await api<Zeile[]>("aufgaben"), aufgaben));
}
async function uebersicht(): Promise<void> {
seite("Übersicht");
const [alle, perioden] = await Promise.all([api<Zeile[]>("aufgaben"), api<Zeile[]>(`liquiditaet?ansicht=woche&anzahl=4&start=${heute()}`)]);
const bisSonntag = new Date(Date.now() + 7 * 86400000).toISOString().slice(0, 10);
const anstehend = alle.filter((a) => !a.erledigt_am && a.faellig_am && a.faellig_am <= bisSonntag);
inhalt.insertAdjacentHTML("beforeend", `<h2>Anstehende Aufgaben</h2>`);
inhalt.appendChild(anstehend.length ? aufgabenTabelle(anstehend, uebersicht) : Object.assign(document.createElement("p"), { className: "hinweis", textContent: "Nichts fällig in den nächsten 7 Tagen." }));
inhalt.insertAdjacentHTML("beforeend", `<h2>Liquidität 4 Wochen</h2>`);
inhalt.appendChild(tabelle([
{ titel: "Woche ab", wert: (p) => dat(p.von) },
{ titel: "Saldo", wert: (p) => euro(p.saldo), klasse: "zahl" },
{ titel: "Kontostand", wert: (p) => `<span class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</span>`, klasse: "zahl" },
], perioden));
}
async function daten(): Promise<void> {
seite("Daten und Einstellungen");
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>
<h2>Einstellungen</h2>`);
const felder: Feld[] = [
{ name: "startsaldo", titel: "Kontostand (Startsaldo)", art: "euro" },
{ name: "kundenTage", titel: "Zahlungsziel Kunden (Tage)", art: "zahl" },
{ name: "materialTage", titel: "Zahlungsziel Material (Tage)", art: "zahl" },
{ name: "fremdTage", titel: "Zahlungsziel Subunternehmer (Tage)", art: "zahl" },
{ name: "versteuerung", titel: "Umsatzsteuer nach", art: "auswahl", optionen: [["soll", "Soll (vereinbarte Entgelte)"], ["ist", "Ist (vereinnahmte Entgelte)"]] },
{ name: "voranmeldung", titel: "Voranmeldung", art: "auswahl", optionen: [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"]] },
{ name: "stundenProTag", titel: "Stunden pro Arbeitstag", art: "zahl" },
];
const knopf = document.createElement("button");
knopf.className = "neben";
knopf.textContent = "Einstellungen bearbeiten";
knopf.onclick = async () => {
const r = await dialog("Einstellungen", felder, { ...e, ...e.zahlungsziele, ...e.ust }, false);
if (r?.aktion !== "speichern") return;
const d = r.daten;
await api("einstellungen", "PUT", {
...e, startsaldo: d.startsaldo ?? 0, stundenProTag: d.stundenProTag ?? e.stundenProTag,
zahlungsziele: { ...e.zahlungsziele, kundenTage: d.kundenTage ?? 0, materialTage: d.materialTage ?? 0, fremdTage: d.fremdTage ?? 0 },
ust: { ...e.ust, versteuerung: d.versteuerung, voranmeldung: d.voranmeldung },
});
daten();
};
inhalt.appendChild(knopf);
}
const REITER: [string, string, () => Promise<void>][] = [
["uebersicht", "Übersicht", uebersicht], ["projekte", "Projekte", projekte], ["terminplan", "Terminplan", terminplan],
["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten],
["kontakte", "Kontakte", kontakte], ["aufgaben", "Aufgaben", aufgaben], ["daten", "Daten", daten],
];
const nav = document.getElementById("reiter")!;
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${titel}</button>`).join("");
nav.addEventListener("click", (ev) => {
const r = (ev.target as HTMLElement).dataset.r;
if (r) location.hash = r;
});
async function zeige(): Promise<void> {
const id = location.hash.slice(1) || "uebersicht";
const reiter = REITER.find(([r]) => r === id) ?? REITER[0]!;
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0]));
try {
await reiter[2]();
} catch (e) {
inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`);
}
}
window.addEventListener("hashchange", zeige);
window.addEventListener("unhandledrejection", (ev) => {
inhalt.insertAdjacentHTML("afterbegin", `<p class="fehler">${esc(ev.reason?.message ?? ev.reason)}</p>`);
});
zeige();
api("status").then((s) => (document.getElementById("version")!.textContent = `Version ${s.version}`)).catch(() => {});

19
src/web/index.html Normal file
View File

@@ -0,0 +1,19 @@
<!doctype html>
<html lang="de">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Betrieb · Schaarschmidt Holzbau</title>
<link rel="stylesheet" href="/styles.css">
</head>
<body>
<header>
<strong>Schaarschmidt Holzbau</strong>
<nav id="reiter"></nav>
<span id="version"></span>
</header>
<main id="inhalt"></main>
<div id="dialog-huelle" hidden></div>
<script type="module" src="/app.js"></script>
</body>
</html>

37
src/web/styles.css Normal file
View File

@@ -0,0 +1,37 @@
:root {
--bg: #f6f5f2; --fl: #ffffff; --text: #1f1f1d; --leise: #6b6a65; --linie: #dedcd5;
--akzent: #8a4b14; --akzent-text: #ffffff; --warn: #b42318;
font-family: system-ui, -apple-system, "Segoe UI", sans-serif; font-size: 15px;
}
@media (prefers-color-scheme: dark) {
:root { --bg: #1b1b1a; --fl: #262624; --text: #ecebe6; --leise: #a3a29b; --linie: #3a3936; --akzent: #d9893f; --akzent-text: #1b1b1a; --warn: #f97066; }
}
* { box-sizing: border-box; }
body { margin: 0; background: var(--bg); color: var(--text); }
header { display: flex; gap: 16px; align-items: center; flex-wrap: wrap; padding: 10px 16px; background: var(--fl); border-bottom: 1px solid var(--linie); }
header nav { display: flex; gap: 4px; flex-wrap: wrap; flex: 1; }
header nav button { background: none; border: 0; padding: 6px 10px; border-radius: 6px; color: var(--leise); cursor: pointer; font: inherit; }
header nav button.aktiv { background: var(--bg); color: var(--text); font-weight: 600; }
#version { color: var(--leise); font-size: 12px; }
main { padding: 16px; max-width: 1200px; margin: 0 auto; }
h1 { font-size: 20px; margin: 4px 0 16px; }
.leiste { display: flex; gap: 8px; margin-bottom: 12px; align-items: center; }
button.haupt { background: var(--akzent); color: var(--akzent-text); border: 0; border-radius: 6px; padding: 7px 14px; font: inherit; cursor: pointer; }
button.neben { background: var(--fl); color: var(--text); border: 1px solid var(--linie); border-radius: 6px; padding: 6px 12px; font: inherit; cursor: pointer; }
table { width: 100%; border-collapse: collapse; background: var(--fl); border: 1px solid var(--linie); border-radius: 8px; overflow: hidden; }
th, td { text-align: left; padding: 7px 10px; border-bottom: 1px solid var(--linie); }
th { font-size: 12px; color: var(--leise); font-weight: 600; }
td.zahl, th.zahl { text-align: right; font-variant-numeric: tabular-nums; }
tr.klickbar { cursor: pointer; }
tr.klickbar:hover td { background: var(--bg); }
.hinweis { color: var(--leise); }
.fehler { color: var(--warn); }
#dialog-huelle { position: fixed; inset: 0; background: rgb(0 0 0 / 0.35); display: grid; place-items: center; padding: 16px; }
#dialog-huelle[hidden] { display: none; }
.dialog { background: var(--fl); border-radius: 10px; padding: 18px; width: min(460px, 100%); box-shadow: 0 10px 30px rgb(0 0 0 / 0.25); }
.dialog h2 { font-size: 17px; margin: 0 0 12px; }
.dialog label { display: block; font-size: 12px; color: var(--leise); margin: 10px 0 3px; }
.dialog input, .dialog select, .dialog textarea { width: 100%; padding: 7px 8px; border: 1px solid var(--linie); border-radius: 6px; background: var(--bg); color: var(--text); font: inherit; }
.dialog .knoepfe { display: flex; justify-content: flex-end; gap: 8px; margin-top: 16px; }
.dialog .knoepfe .links { margin-right: auto; }
@media (max-width: 640px) { th.optional, td.optional { display: none; } }

99
test/api.test.ts Normal file
View File

@@ -0,0 +1,99 @@
// Prüft Server und Datenbank zusammen. Läuft nur mit TEST_DATABASE_URL (lokal und in der CI).
import { describe, it, expect, beforeAll, afterAll } from "vitest";
import type { FastifyInstance } from "fastify";
import { erstellePool, type Pool } from "../src/server/db.js";
import { migriere } from "../src/server/migrate.js";
import { baueApp } from "../src/server/app.js";
const url = process.env.TEST_DATABASE_URL;
describe.skipIf(!url)("API mit Datenbank", () => {
let pool: Pool;
let app: FastifyInstance;
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
const anlegen = async (pfad: string, body: object, benutzer = "henning") => {
const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body, headers: { "x-benutzer": benutzer } });
expect(r.statusCode, r.body).toBe(201);
return r.json();
};
it("Migrationen laufen nur einmal", async () => {
expect(await migriere(pool)).toEqual([]);
});
it("Status", async () => {
const r = await app.inject("/api/status");
expect(r.json()).toMatchObject({ ok: true });
});
it("umbenannter Kontakt erscheint überall mit neuem Namen (Abnahme Stufe 0)", async () => {
const k = await anlegen("kontakte", { name: "Dachdeckerei Meier", rolle: "subunternehmer" });
const p = await anlegen("projekte", { nummer: "26-01", bezeichnung: "Dachstuhl Musterweg", bauherr_id: k.id, umsatz_netto: 4_500_000 });
const a = await anlegen("abschnitte", { projekt_id: p.id, name: "Montage" });
const v = await anlegen("vorgaenge", { abschnitt_id: a.id, name: "Eindecken", start: "2026-11-02", dauer: 3, kontakt_id: k.id });
const r = await app.inject({ method: "PATCH", url: `/api/kontakte/${k.id}`, payload: { name: "Meier Bedachungen GmbH" } });
expect(r.statusCode).toBe(200);
const sicht = await pool.query(
`select kp.name as bauherr, kv.name as ausfuehrend from projekt p
join kontakt kp on kp.id = p.bauherr_id join vorgang v on v.id = $2 join kontakt kv on kv.id = v.kontakt_id where p.id = $1`,
[p.id, v.id],
);
expect(sicht.rows[0]).toEqual({ bauherr: "Meier Bedachungen GmbH", ausfuehrend: "Meier Bedachungen GmbH" });
});
it("Beträge bleiben centgenau", async () => {
const p = await anlegen("projekte", { nummer: "26-02", bezeichnung: "Carport" });
const z = await anlegen("zahlungen", { projekt_id: p.id, bezeichnung: "Anzahlung", netto: 123_456_789_01, termin: "2026-11-02" });
expect(z.netto).toBe(123_456_789_01);
expect(z.termin).toBe("2026-11-02");
});
it("lehnt ungültige Eingaben ab", async () => {
const r1 = await app.inject({ method: "POST", url: "/api/kontakte", payload: { name: "" } });
expect(r1.statusCode).toBe(400);
const r2 = await app.inject({ method: "POST", url: "/api/zahlungen", payload: { projekt_id: crypto.randomUUID(), bezeichnung: "x", netto: 1, termin: "2026-01-01" } });
expect(r2.statusCode).toBe(409);
const r3 = await app.inject({ method: "POST", url: "/api/zahlungen", payload: { projekt_id: crypto.randomUUID(), bezeichnung: "x", netto: 1.5, termin: "2026-01-01" } });
expect(r3.statusCode).toBe(400);
});
it("Protokoll hält fest, wer was geändert hat", async () => {
const k = await anlegen("kontakte", { name: "Holzhandel Nord" }, "henning");
await app.inject({ method: "PATCH", url: `/api/kontakte/${k.id}`, payload: { telefon: "04541 123" }, headers: { "x-benutzer": "buero" } });
await app.inject({ method: "DELETE", url: `/api/kontakte/${k.id}`, headers: { "x-benutzer": "henning" } });
const r = (await app.inject(`/api/protokoll?datensatz=${k.id}`)).json();
expect(r.map((x: { aktion: string; benutzer: string }) => [x.aktion, x.benutzer])).toEqual([
["loeschen", "henning"], ["aendern", "buero"], ["anlegen", "henning"],
]);
});
it("Einstellungen mit Vorgaben und Liquidität aus der Datenbank", async () => {
const e = (await app.inject("/api/einstellungen")).json();
expect(e.arbeitstage).toEqual([1, 2, 3, 4]);
expect(e.ust.satz).toBe(19);
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, startsaldo: 500_000 } });
const p = await anlegen("projekte", { nummer: "26-03", bezeichnung: "Gaube" });
await anlegen("zahlungen", { projekt_id: p.id, bezeichnung: "Abschlag", netto: 1_000_000, termin: "2027-03-01" });
await anlegen("laufende-kosten", { bezeichnung: "Kfz-Versicherung", betrag: 60_000, rhythmus: "jaehrlich", start: "2027-03-20" });
const l = (await app.inject("/api/liquiditaet?ansicht=monat&start=2027-03-01&anzahl=1")).json();
expect(l[0]).toMatchObject({ einnahmen: 1_190_000, ausgaben: -60_000, kontostand: 500_000 + 1_190_000 - 60_000 });
});
it("Export enthält alle Tabellen", async () => {
const r = await app.inject("/api/export");
const j = r.json();
expect(Object.keys(j.daten)).toContain("vorgaenge");
expect(j.daten.kontakte.length).toBeGreaterThan(0);
});
});

73
test/geld.test.ts Normal file
View File

@@ -0,0 +1,73 @@
import { describe, it, expect } from "vitest";
import { prozentVon, brutto, parseEuro, formatEuro, zahlungsplanBetraege, STANDARD_ZAHLUNGSPLAN, summe } from "../src/domain/geld.js";
import { stundenZuArbeitstagen } from "../src/domain/arbeitszeit.js";
describe("Prozent und Umsatzsteuer", () => {
it("rundet kaufmännisch", () => {
expect(prozentVon(1, 50)).toBe(1); // 0,5 Cent -> 1
expect(prozentVon(-1, 50)).toBe(-1);
expect(prozentVon(105, 19)).toBe(20); // 19,95 -> 20
expect(prozentVon(1234567, 12.5)).toBe(154321); // 154320,875
});
it("kein Gleitkommafehler", () => {
// 0.1 + 0.2 in Euro wäre ungenau; in Cent exakt
expect(prozentVon(1000, 0.1)).toBe(1);
expect(brutto(1, 19)).toBe(1);
expect(brutto(1000000, 19)).toBe(1190000);
expect(brutto(1999, 19)).toBe(2379); // 3,7981 € USt -> 3,80
});
it("große Beträge exakt", () => {
expect(prozentVon(9_000_000_000_00, 19)).toBe(1_710_000_000_00);
});
});
describe("Beträge lesen und schreiben", () => {
it.each([
["1.234,56", 123456], ["1234,5", 123450], ["12", 1200], ["-12,01", -1201],
["1.000", 100000], ["12.50", 1250], ["0,07 €", 7],
])("%s", (text, cent) => expect(parseEuro(text)).toBe(cent));
it("lehnt Unsinn ab", () => {
expect(() => parseEuro("12,345")).toThrow();
expect(() => parseEuro("abc")).toThrow();
});
it("formatiert deutsch", () => {
expect(formatEuro(123456789)).toBe("1.234.567,89 €");
expect(formatEuro(-5)).toBe("-0,05 €");
expect(formatEuro(0, false)).toBe("0,00");
});
});
describe("Zahlungsplan P9", () => {
it("Standard 30/40/20/10", () => {
const b = zahlungsplanBetraege(10000000, STANDARD_ZAHLUNGSPLAN);
expect(b).toEqual([3000000, 4000000, 2000000, 1000000]);
});
it("Rest fällt auf die Schlussrechnung, Summe stimmt immer", () => {
const auftrag = 3333333; // 33.333,33 €
const b = zahlungsplanBetraege(auftrag, STANDARD_ZAHLUNGSPLAN);
expect(b).toEqual([1000000, 1333333, 666667, 333333]);
expect(summe(b)).toBe(auftrag);
});
it("fester Betrag gemischt mit Prozent", () => {
expect(zahlungsplanBetraege(5000000, [{ betrag: 500000 }, { prozent: 50 }, { prozent: 99 }])).toEqual([500000, 2500000, 2000000]);
});
});
describe("Stunden in Arbeitstage", () => {
it("rundet auf ganze Tage", () => {
expect(stundenZuArbeitstagen(0)).toBe(0);
expect(stundenZuArbeitstagen(1)).toBe(1);
expect(stundenZuArbeitstagen(8)).toBe(1);
expect(stundenZuArbeitstagen(8.5)).toBe(2);
expect(stundenZuArbeitstagen(24)).toBe(3);
});
it("Produktivität verlängert", () => {
expect(stundenZuArbeitstagen(24, { stundenProTag: 8, produktivitaet: 0.75, rundung: "auf" })).toBe(4);
expect(stundenZuArbeitstagen(0.3 * 8 * 10, { stundenProTag: 8, produktivitaet: 0.3, rundung: "auf" })).toBe(10);
});
it("halbe Tage und kaufmännisch", () => {
expect(stundenZuArbeitstagen(10, { stundenProTag: 8, produktivitaet: 1, rundung: "halbe" })).toBe(1.5);
expect(stundenZuArbeitstagen(11, { stundenProTag: 8, produktivitaet: 1, rundung: "kaufmaennisch" })).toBe(1);
expect(stundenZuArbeitstagen(12, { stundenProTag: 8, produktivitaet: 1, rundung: "kaufmaennisch" })).toBe(2);
});
});

86
test/kalender.test.ts Normal file
View File

@@ -0,0 +1,86 @@
import { describe, it, expect } from "vitest";
import { ostersonntag, feiertageSH, istArbeitstag, endeNachDauer, verschiebeArbeitstage, arbeitstageZwischen, naechsterArbeitstag } from "../src/domain/kalender.js";
import { plusMonate, wochentag, zuDate } from "../src/domain/datum.js";
describe("Ostersonntag", () => {
it.each([
[2024, "2024-03-31"], [2025, "2025-04-20"], [2026, "2026-04-05"], [2027, "2027-03-28"],
[2028, "2028-04-16"], [2030, "2030-04-21"], [2038, "2038-04-25"], [2000, "2000-04-23"],
])("%i", (jahr, erwartet) => expect(ostersonntag(jahr)).toBe(erwartet));
});
describe("Feiertage Schleswig-Holstein", () => {
it("2026 vollständig", () => {
expect(feiertageSH(2026).map((f) => f.datum)).toEqual([
"2026-01-01", "2026-04-03", "2026-04-06", "2026-05-01", "2026-05-14",
"2026-05-25", "2026-10-03", "2026-10-31", "2026-12-25", "2026-12-26",
]);
});
it("2027 vollständig", () => {
expect(feiertageSH(2027).map((f) => f.datum)).toEqual([
"2027-01-01", "2027-03-26", "2027-03-29", "2027-05-01", "2027-05-06",
"2027-05-17", "2027-10-03", "2027-10-31", "2027-12-25", "2027-12-26",
]);
});
it("keine Feiertage anderer Länder", () => {
const tage = feiertageSH(2026).map((f) => f.datum);
expect(tage).not.toContain("2026-01-06"); // Heilige Drei Könige
expect(tage).not.toContain("2026-06-04"); // Fronleichnam
expect(tage).not.toContain("2026-11-18"); // Buß- und Bettag (nur Sachsen)
});
it("Reformationstag erst ab 2018", () => {
expect(feiertageSH(2017).some((f) => f.name === "Reformationstag")).toBe(false);
expect(feiertageSH(2018).some((f) => f.name === "Reformationstag")).toBe(true);
});
});
describe("Arbeitstage Mo–Do", () => {
it("Freitag, Samstag, Sonntag sind frei", () => {
expect(istArbeitstag("2026-10-12")).toBe(true); // Mo
expect(istArbeitstag("2026-10-15")).toBe(true); // Do
expect(istArbeitstag("2026-10-16")).toBe(false); // Fr
expect(istArbeitstag("2026-10-17")).toBe(false); // Sa
expect(istArbeitstag("2026-10-18")).toBe(false); // So
});
it("Feiertag ist kein Arbeitstag", () => {
expect(istArbeitstag("2026-04-06")).toBe(false); // Ostermontag
expect(istArbeitstag("2026-05-14")).toBe(false); // Himmelfahrt (Do)
});
it("Start am Freitag beginnt am Montag", () => {
expect(naechsterArbeitstag("2026-10-16")).toBe("2026-10-19");
});
it("Dauer 4 Tage ab Montag endet Donnerstag", () => {
expect(endeNachDauer("2026-10-12", 4)).toBe("2026-10-15");
});
it("Dauer 5 Tage springt über Freitag bis Wochenende", () => {
expect(endeNachDauer("2026-10-12", 5)).toBe("2026-10-19");
});
it("Dauer über Ostern", () => {
// Do 02.04. ist Arbeitstag, Karfreitag und Ostermontag frei
expect(endeNachDauer("2026-04-01", 3)).toBe("2026-04-07");
});
it("Meilenstein mit Dauer 0", () => {
expect(endeNachDauer("2026-10-13", 0)).toBe("2026-10-13");
expect(endeNachDauer("2026-10-16", 0)).toBe("2026-10-19");
});
it("Verzögerung rückwärts", () => {
expect(verschiebeArbeitstage("2026-10-19", -1)).toBe("2026-10-15");
expect(verschiebeArbeitstage("2026-10-19", 0)).toBe("2026-10-19");
});
it("Arbeitstage im Oktober 2026", () => {
// 1.10.2026 ist Donnerstag: 5 Do + je 4 Mo, Di, Mi; 3.10. und 31.10. sind Samstage
expect(arbeitstageZwischen("2026-10-01", "2026-10-31")).toBe(17);
});
it("ganzes Jahr 2026", () => {
// 209 Mo–Do minus Neujahr (Do), Ostermontag, Himmelfahrt, Pfingstmontag
expect(arbeitstageZwischen("2026-01-01", "2026-12-31")).toBe(205);
});
it("rechnet unabhängig von der Zeitzone", () => {
expect(wochentag("2026-03-29")).toBe(7); // Zeitumstellung
expect(() => zuDate("2026-02-30")).toThrow();
});
it("Monatsende bleibt Monatsende", () => {
expect(plusMonate("2026-01-31", 1)).toBe("2026-02-28");
expect(plusMonate("2026-01-31", 2)).toBe("2026-03-31");
});
});

82
test/liquiditaet.test.ts Normal file
View File

@@ -0,0 +1,82 @@
import { describe, it, expect } from "vitest";
import { liquiditaet, periodenGrenzen, termineLaufend } from "../src/domain/liquiditaet.js";
import { faelligkeit, zeitraumVon } from "../src/domain/umsatzsteuer.js";
describe("Umsatzsteuer-Fälligkeit", () => {
it("10. des Folgemonats, Wochenende verschiebt auf Montag", () => {
expect(faelligkeit("2026-09", { dauerfristverlaengerung: false })).toBe("2026-10-12"); // 10.10. ist Sa
expect(faelligkeit("2026-10", { dauerfristverlaengerung: false })).toBe("2026-11-10"); // Di
});
it("Freitag bleibt Freitag (Freitagsregel gilt nicht)", () => {
expect(faelligkeit("2026-06", { dauerfristverlaengerung: false })).toBe("2026-07-10"); // Fr
});
it("Dauerfristverlängerung und Jahreswechsel", () => {
expect(faelligkeit("2026-12", { dauerfristverlaengerung: true })).toBe("2027-02-10");
expect(faelligkeit("2026-Q4", { dauerfristverlaengerung: false })).toBe("2027-01-11"); // 10.01.27 So
});
it("Zeitraum", () => {
expect(zeitraumVon("2026-05-31", "vierteljaehrlich")).toBe("2026-Q2");
});
});
describe("Perioden", () => {
it("Wochen beginnen montags", () => {
expect(periodenGrenzen({ ansicht: "woche", start: "2026-10-15", anzahl: 2 })).toEqual([
{ von: "2026-10-12", bis: "2026-10-18" },
{ von: "2026-10-19", bis: "2026-10-25" },
]);
});
it("Monate", () => {
expect(periodenGrenzen({ ansicht: "monat", start: "2026-12-15", anzahl: 2 })).toEqual([
{ von: "2026-12-01", bis: "2026-12-31" },
{ von: "2027-01-01", bis: "2027-01-31" },
]);
});
it("laufende Kosten vierteljährlich mit Ende", () => {
expect(termineLaufend({ bezeichnung: "Vers.", betrag: 1, rhythmus: "vierteljaehrlich", start: "2026-01-15", ende: "2026-09-30" }, "2026-01-01", "2026-12-31"))
.toEqual(["2026-01-15", "2026-04-15", "2026-07-15"]);
});
});
describe("Liquiditätsvorschau", () => {
const vorschau = { ansicht: "monat" as const, start: "2026-11-01", anzahl: 3, startsaldo: 1_000_000 };
it("rechnet Einnahmen, Kosten, laufende Kosten und USt centgenau", () => {
const p = liquiditaet(
{
einnahmen: [{ projekt: "26-01", bezeichnung: "Anzahlung", netto: 3_000_000, termin: "2026-11-02" }],
ausgaben: [{ projekt: "26-01", bezeichnung: "KVH", art: "material", netto: 1_000_000, termin: "2026-11-05" }],
laufend: [{ bezeichnung: "Miete", betrag: 80_000, rhythmus: "monatlich", start: "2026-01-03" }],
},
vorschau,
);
// November: Anzahlung 35.700 € (Ziel 14 Tage), Miete -800 €
expect(p[0]!.einnahmen).toBe(3_570_000);
expect(p[0]!.ausgaben).toBe(-80_000);
expect(p[0]!.kontostand).toBe(1_000_000 + 3_570_000 - 80_000);
// Dezember: Material 11.900 € (Ziel 30 Tage -> 05.12.), Miete, USt Nov (5.700 - 1.900 = 3.800) am 10.12.
expect(p[1]!.posten.map((x) => [x.datum, x.gruppe, x.betrag])).toEqual([
["2026-12-03", "Laufende Kosten", -80_000],
["2026-12-05", "Projektkosten", -1_190_000],
["2026-12-10", "Umsatzsteuer", -380_000],
]);
expect(p[2]!.kontostand).toBe(1_000_000 + 3_570_000 - 1_190_000 - 380_000 - 3 * 80_000);
});
it("Ist-Versteuerung verschiebt die USt in den Zahlungsmonat", () => {
const p = liquiditaet(
{ einnahmen: [{ bezeichnung: "Schluss", netto: 1_000_000, termin: "2026-11-25" }], ausgaben: [], laufend: [] },
{ ...vorschau, ust: { satz: 19, voranmeldung: "monatlich", dauerfristverlaengerung: false, versteuerung: "ist" } },
);
// Zahlung 09.12. -> USt Dezember fällig 11.01.2027 (10.01. ist Sonntag)
expect(p[2]!.posten).toEqual([{ datum: "2027-01-11", gruppe: "Umsatzsteuer", bezeichnung: "USt-Vorauszahlung 2026-12", betrag: -190_000 }]);
});
it("bezahlte Einnahme zählt am Zahltag", () => {
const p = liquiditaet(
{ einnahmen: [{ bezeichnung: "A", netto: 100, termin: "2026-10-01", bezahltAm: "2026-11-30" }], ausgaben: [], laufend: [] },
vorschau,
);
expect(p[0]!.einnahmen).toBe(119);
});
});

15
tsconfig.json Normal file
View File

@@ -0,0 +1,15 @@
{
"compilerOptions": {
"target": "ES2023",
"module": "NodeNext",
"moduleResolution": "NodeNext",
"strict": true,
"noUncheckedIndexedAccess": true,
"esModuleInterop": true,
"skipLibCheck": true,
"outDir": "dist",
"rootDir": "src",
"sourceMap": true
},
"include": ["src/server/**/*.ts", "src/domain/**/*.ts"]
}

5
tsconfig.web.json Normal file
View File

@@ -0,0 +1,5 @@
{
"extends": "./tsconfig.json",
"compilerOptions": { "lib": ["ES2023", "DOM", "DOM.Iterable"], "noEmit": true },
"include": ["src/web/**/*.ts", "src/domain/**/*.ts"]
}

2
vitest.config.ts Normal file
View File

@@ -0,0 +1,2 @@
import { defineConfig } from "vitest/config";
export default defineConfig({ test: { include: ["test/**/*.test.ts"], fileParallelism: false } });