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:
14
.devcontainer/devcontainer.json
Normal file
14
.devcontainer/devcontainer.json
Normal 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" }
|
||||
}
|
||||
}
|
||||
}
|
||||
18
.devcontainer/docker-compose.yml
Normal file
18
.devcontainer/docker-compose.yml
Normal 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
|
||||
1
.devcontainer/init-test-db.sql
Normal file
1
.devcontainer/init-test-db.sql
Normal file
@@ -0,0 +1 @@
|
||||
create database betrieb_test owner betrieb;
|
||||
5
.dockerignore
Normal file
5
.dockerignore
Normal file
@@ -0,0 +1,5 @@
|
||||
node_modules
|
||||
dist
|
||||
.git
|
||||
deploy/.env*
|
||||
*.log
|
||||
46
.github/workflows/ci.yml
vendored
Normal file
46
.github/workflows/ci.yml
vendored
Normal 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
38
.github/workflows/release.yml
vendored
Normal 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
7
.gitignore
vendored
Normal file
@@ -0,0 +1,7 @@
|
||||
node_modules/
|
||||
dist/
|
||||
*.log
|
||||
deploy/.env
|
||||
deploy/.env.*
|
||||
!deploy/.env.beispiel
|
||||
deploy/.vorige-version-*
|
||||
10
CHANGELOG.md
Normal file
10
CHANGELOG.md
Normal 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
23
Dockerfile
Normal 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
55
README.md
Normal 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
7
backup/Dockerfile
Normal 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
15
backup/sicherung.sh
Executable 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
10
backup/zeitplan.sh
Executable 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
15
deploy/.env.beispiel
Normal 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
24
deploy/Caddyfile
Normal 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
102
deploy/docker-compose.yml
Normal 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
22
deploy/update.sh
Executable 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
19
deploy/zurueck.sh
Executable 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
3683
package-lock.json
generated
Normal file
File diff suppressed because it is too large
Load Diff
34
package.json
Normal file
34
package.json
Normal 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
15
scripts/build-web.mjs
Normal 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
40
src/domain/arbeitszeit.ts
Normal 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
64
src/domain/datum.ts
Normal 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
113
src/domain/geld.ts
Normal 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
123
src/domain/kalender.ts
Normal 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
173
src/domain/liquiditaet.ts
Normal 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 };
|
||||
});
|
||||
}
|
||||
44
src/domain/umsatzsteuer.ts
Normal file
44
src/domain/umsatzsteuer.ts
Normal 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
168
src/server/app.ts
Normal file
@@ -0,0 +1,168 @@
|
||||
import Fastify, { type FastifyInstance, type FastifyRequest } from "fastify";
|
||||
import fastifyStatic from "@fastify/static";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import path from "node:path";
|
||||
import { existsSync } from "node:fs";
|
||||
import { z, ZodError } from "zod";
|
||||
import { type Pool, transaktion } from "./db.js";
|
||||
import { TABELLEN } from "./tabellen.js";
|
||||
import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js";
|
||||
import { liquiditaet, type Daten } from "../domain/liquiditaet.js";
|
||||
import { VERSION } from "./version.js";
|
||||
|
||||
export interface Optionen {
|
||||
pool: Pool;
|
||||
webOrdner?: string;
|
||||
logger?: boolean;
|
||||
}
|
||||
|
||||
/** Benutzer kommt vom Proxy (Anmeldung); ohne Proxy, z. B. lokal, gilt "lokal". */
|
||||
function benutzer(req: FastifyRequest): string {
|
||||
const h = req.headers["x-benutzer"];
|
||||
return (Array.isArray(h) ? h[0] : h)?.trim() || "lokal";
|
||||
}
|
||||
|
||||
const IdParam = z.object({ id: z.uuid() });
|
||||
|
||||
export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
const app = Fastify({ logger: o.logger ?? false, bodyLimit: 50 * 1024 * 1024 });
|
||||
const { pool } = o;
|
||||
|
||||
app.setErrorHandler((err, _req, reply) => {
|
||||
if (err instanceof ZodError) {
|
||||
return reply.status(400).send({ fehler: "Eingabe ungültig", details: err.issues.map((i) => `${i.path.join(".")}: ${i.message}`) });
|
||||
}
|
||||
const pgCode = (err as { code?: string }).code;
|
||||
if (pgCode === "23503") return reply.status(409).send({ fehler: "Verknüpfter Datensatz fehlt oder wird noch verwendet" });
|
||||
if (pgCode === "23505") return reply.status(409).send({ fehler: "Eintrag gibt es schon" });
|
||||
if (pgCode === "23514" || pgCode === "22P02" || pgCode === "22007" || pgCode === "22008") {
|
||||
return reply.status(400).send({ fehler: "Eingabe ungültig" });
|
||||
}
|
||||
const status = (err as { statusCode?: number }).statusCode;
|
||||
if (status && status < 500) return reply.status(status).send({ fehler: (err as Error).message });
|
||||
app.log.error(err);
|
||||
return reply.status(500).send({ fehler: "Interner Fehler" });
|
||||
});
|
||||
|
||||
app.get("/api/status", async () => {
|
||||
await pool.query("select 1");
|
||||
return { ok: true, version: VERSION };
|
||||
});
|
||||
|
||||
for (const t of TABELLEN) {
|
||||
const felder = Object.keys(t.schema.shape);
|
||||
const teil = t.schema.partial();
|
||||
|
||||
app.get(`/api/${t.pfad}`, async () => (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows);
|
||||
|
||||
app.get(`/api/${t.pfad}/:id`, async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const r = await pool.query(`select * from ${t.name} where id = $1`, [id]);
|
||||
return r.rows[0] ?? reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
});
|
||||
|
||||
app.post(`/api/${t.pfad}`, async (req, reply) => {
|
||||
const daten = t.schema.parse(req.body) as Record<string, unknown>;
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
const row = await transaktion(pool, benutzer(req), async (c) =>
|
||||
(await c.query(
|
||||
spalten.length
|
||||
? `insert into ${t.name} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *`
|
||||
: `insert into ${t.name} default values returning *`,
|
||||
spalten.map((s) => daten[s]),
|
||||
)).rows[0],
|
||||
);
|
||||
return reply.status(201).send(row);
|
||||
});
|
||||
|
||||
app.patch(`/api/${t.pfad}/:id`, async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const daten = teil.parse(req.body) as Record<string, unknown>;
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
if (spalten.length === 0) return reply.status(400).send({ fehler: "Keine Änderung angegeben" });
|
||||
const row = await transaktion(pool, benutzer(req), async (c) =>
|
||||
(await c.query(
|
||||
`update ${t.name} set ${spalten.map((s, i) => `${s} = $${i + 2}`).join(", ")} where id = $1 returning *`,
|
||||
[id, ...spalten.map((s) => daten[s])],
|
||||
)).rows[0],
|
||||
);
|
||||
return row ?? reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
});
|
||||
|
||||
app.delete(`/api/${t.pfad}/:id`, async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const n = await transaktion(pool, benutzer(req), async (c) => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount);
|
||||
return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
});
|
||||
}
|
||||
|
||||
async function ladeEinstellungen(): Promise<Einstellungen> {
|
||||
const r = await pool.query<{ daten: unknown }>("select daten from einstellungen limit 1");
|
||||
return EinstellungenSchema.parse(r.rows[0]?.daten ?? {});
|
||||
}
|
||||
|
||||
app.get("/api/einstellungen", ladeEinstellungen);
|
||||
|
||||
app.put("/api/einstellungen", async (req) => {
|
||||
const neu = EinstellungenSchema.parse(req.body);
|
||||
await transaktion(pool, benutzer(req), (c) => c.query("update einstellungen set daten = $1", [neu]));
|
||||
return neu;
|
||||
});
|
||||
|
||||
const LiquiAnfrage = z.object({
|
||||
ansicht: z.enum(["woche", "monat"]).default("woche"),
|
||||
start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
|
||||
anzahl: z.coerce.number().int().min(1).max(104).default(12),
|
||||
});
|
||||
|
||||
app.get("/api/liquiditaet", async (req) => {
|
||||
const q = LiquiAnfrage.parse(req.query);
|
||||
const e = await ladeEinstellungen();
|
||||
const [zahlungen, kosten, laufend] = await Promise.all([
|
||||
pool.query(`select z.*, p.nummer from zahlung z join projekt p on p.id = z.projekt_id`),
|
||||
pool.query(`select k.*, p.nummer from kosten k join projekt p on p.id = k.projekt_id`),
|
||||
pool.query(`select * from laufende_kosten`),
|
||||
]);
|
||||
const daten: Daten = {
|
||||
einnahmen: zahlungen.rows.map((z) => ({
|
||||
projekt: z.nummer, bezeichnung: z.bezeichnung, netto: z.netto,
|
||||
termin: z.rechnungsdatum ?? z.termin, bezahltAm: z.bezahlt_am ?? undefined,
|
||||
})),
|
||||
ausgaben: kosten.rows.map((k) => ({
|
||||
projekt: k.nummer, bezeichnung: k.bezeichnung, art: k.art, netto: k.netto, termin: k.termin, mitVorsteuer: k.mit_vorsteuer,
|
||||
})),
|
||||
laufend: laufend.rows.map((l) => ({
|
||||
bezeichnung: l.bezeichnung, kategorie: l.kategorie, betrag: l.betrag, rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined,
|
||||
})),
|
||||
};
|
||||
const start = q.start ?? new Date().toISOString().slice(0, 10);
|
||||
return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust });
|
||||
});
|
||||
|
||||
// D1: kompletter Stand als JSON-Datei
|
||||
app.get("/api/export", async (_req, reply) => {
|
||||
const daten: Record<string, unknown[]> = {};
|
||||
for (const t of TABELLEN) daten[t.pfad] = (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows;
|
||||
const stand = new Date().toISOString();
|
||||
reply.header("content-disposition", `attachment; filename="betrieb-${stand.slice(0, 10)}.json"`);
|
||||
return { programm: "betrieb", version: VERSION, stand, einstellungen: await ladeEinstellungen(), daten };
|
||||
});
|
||||
|
||||
app.get("/api/protokoll", async (req) => {
|
||||
const q = z.object({ datensatz: z.uuid().optional(), limit: z.coerce.number().int().min(1).max(500).default(100) }).parse(req.query);
|
||||
const r = q.datensatz
|
||||
? await pool.query("select * from protokoll where datensatz = $1 order by id desc limit $2", [q.datensatz, q.limit])
|
||||
: await pool.query("select * from protokoll order by id desc limit $1", [q.limit]);
|
||||
return r.rows;
|
||||
});
|
||||
|
||||
const web = o.webOrdner ?? path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "web");
|
||||
if (existsSync(web)) {
|
||||
await app.register(fastifyStatic, { root: web, prefix: "/" });
|
||||
app.setNotFoundHandler((req, reply) =>
|
||||
req.url.startsWith("/api/") ? reply.status(404).send({ fehler: "Nicht gefunden" }) : reply.sendFile("index.html"),
|
||||
);
|
||||
}
|
||||
|
||||
return app;
|
||||
}
|
||||
34
src/server/db.ts
Normal file
34
src/server/db.ts
Normal file
@@ -0,0 +1,34 @@
|
||||
import pg from "pg";
|
||||
|
||||
// date als 'JJJJ-MM-TT' lassen, bigint (Cent) und numeric als Zahl liefern
|
||||
pg.types.setTypeParser(1082, (v) => v);
|
||||
pg.types.setTypeParser(20, (v) => {
|
||||
const n = Number(v);
|
||||
if (!Number.isSafeInteger(n)) throw new Error(`Betrag zu groß: ${v}`);
|
||||
return n;
|
||||
});
|
||||
pg.types.setTypeParser(1700, (v) => Number(v));
|
||||
|
||||
export type Pool = pg.Pool;
|
||||
export type Client = pg.PoolClient;
|
||||
|
||||
export function erstellePool(url: string): Pool {
|
||||
return new pg.Pool({ connectionString: url, max: 10 });
|
||||
}
|
||||
|
||||
/** Führt fn in einer Transaktion aus; der Benutzer landet im Änderungsprotokoll. */
|
||||
export async function transaktion<T>(pool: Pool, benutzer: string, fn: (c: Client) => Promise<T>): Promise<T> {
|
||||
const c = await pool.connect();
|
||||
try {
|
||||
await c.query("begin");
|
||||
await c.query("select set_config('betrieb.benutzer', $1, true)", [benutzer]);
|
||||
const ergebnis = await fn(c);
|
||||
await c.query("commit");
|
||||
return ergebnis;
|
||||
} catch (e) {
|
||||
await c.query("rollback");
|
||||
throw e;
|
||||
} finally {
|
||||
c.release();
|
||||
}
|
||||
}
|
||||
29
src/server/einstellungen.ts
Normal file
29
src/server/einstellungen.ts
Normal file
@@ -0,0 +1,29 @@
|
||||
import { z } from "zod";
|
||||
|
||||
export const EinstellungenSchema = z.object({
|
||||
arbeitstage: z.array(z.number().int().min(1).max(7)).default([1, 2, 3, 4]),
|
||||
stundenProTag: z.number().positive().default(8),
|
||||
produktivitaet: z.number().positive().max(1).default(1),
|
||||
rundung: z.enum(["auf", "kaufmaennisch", "halbe"]).default("auf"),
|
||||
zahlungsziele: z
|
||||
.object({
|
||||
kundenTage: z.number().int().min(0).default(14),
|
||||
materialTage: z.number().int().min(0).default(30),
|
||||
fremdTage: z.number().int().min(0).default(14),
|
||||
sonstigeTage: z.number().int().min(0).default(0),
|
||||
})
|
||||
.prefault({}),
|
||||
ust: z
|
||||
.object({
|
||||
satz: z.number().min(0).default(19),
|
||||
voranmeldung: z.enum(["monatlich", "vierteljaehrlich"]).default("monatlich"),
|
||||
dauerfristverlaengerung: z.boolean().default(false),
|
||||
versteuerung: z.enum(["soll", "ist"]).default("soll"),
|
||||
})
|
||||
.prefault({}),
|
||||
startsaldo: z.number().int().default(0),
|
||||
startsaldoDatum: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().default(null),
|
||||
mindestreserve: z.number().int().default(0),
|
||||
});
|
||||
|
||||
export type Einstellungen = z.infer<typeof EinstellungenSchema>;
|
||||
23
src/server/index.ts
Normal file
23
src/server/index.ts
Normal file
@@ -0,0 +1,23 @@
|
||||
import { erstellePool } from "./db.js";
|
||||
import { migriere } from "./migrate.js";
|
||||
import { baueApp } from "./app.js";
|
||||
|
||||
const url = process.env.DATABASE_URL;
|
||||
if (!url) {
|
||||
console.error("DATABASE_URL fehlt");
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
const pool = erstellePool(url);
|
||||
await migriere(pool, (t) => console.log(t));
|
||||
const app = await baueApp({ pool, logger: true });
|
||||
const port = Number(process.env.PORT ?? 3000);
|
||||
await app.listen({ host: "0.0.0.0", port });
|
||||
|
||||
for (const signal of ["SIGINT", "SIGTERM"] as const) {
|
||||
process.on(signal, async () => {
|
||||
await app.close();
|
||||
await pool.end();
|
||||
process.exit(0);
|
||||
});
|
||||
}
|
||||
40
src/server/migrate.ts
Normal file
40
src/server/migrate.ts
Normal file
@@ -0,0 +1,40 @@
|
||||
import { readdir, readFile } from "node:fs/promises";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import path from "node:path";
|
||||
import type { Pool } from "./db.js";
|
||||
|
||||
const ORDNER = path.join(path.dirname(fileURLToPath(import.meta.url)), "migrations");
|
||||
|
||||
/**
|
||||
* Spielt alle noch fehlenden Migrationen in Namensreihenfolge ein, jede in eigener Transaktion.
|
||||
* Eine Sperre verhindert, dass zwei Container gleichzeitig migrieren.
|
||||
*/
|
||||
export async function migriere(pool: Pool, log: (text: string) => void = () => {}): Promise<string[]> {
|
||||
const c = await pool.connect();
|
||||
const neu: string[] = [];
|
||||
try {
|
||||
await c.query("select pg_advisory_lock(4711)");
|
||||
await c.query("create table if not exists schema_version (name text primary key, eingespielt_am timestamptz not null default now())");
|
||||
const vorhanden = new Set((await c.query<{ name: string }>("select name from schema_version")).rows.map((r) => r.name));
|
||||
const dateien = (await readdir(ORDNER)).filter((d) => d.endsWith(".sql")).sort();
|
||||
for (const datei of dateien) {
|
||||
if (vorhanden.has(datei)) continue;
|
||||
const sql = await readFile(path.join(ORDNER, datei), "utf8");
|
||||
await c.query("begin");
|
||||
try {
|
||||
await c.query(sql);
|
||||
await c.query("insert into schema_version (name) values ($1)", [datei]);
|
||||
await c.query("commit");
|
||||
} catch (e) {
|
||||
await c.query("rollback");
|
||||
throw new Error(`Migration ${datei} fehlgeschlagen: ${(e as Error).message}`);
|
||||
}
|
||||
log(`Migration ${datei} eingespielt`);
|
||||
neu.push(datei);
|
||||
}
|
||||
} finally {
|
||||
await c.query("select pg_advisory_unlock(4711)").catch(() => {});
|
||||
c.release();
|
||||
}
|
||||
return neu;
|
||||
}
|
||||
203
src/server/migrations/001_grundlage.sql
Normal file
203
src/server/migrations/001_grundlage.sql
Normal file
@@ -0,0 +1,203 @@
|
||||
-- Stufe 0: Grundlage. Objekte aus V70 mit fester ID; Verknüpfungen nur über IDs.
|
||||
-- Beträge in Cent (bigint), Datumsangaben als date.
|
||||
-- Jede Tabelle speichert, wer wann geändert hat; jede Änderung landet im Protokoll.
|
||||
|
||||
create table protokoll (
|
||||
id bigserial primary key,
|
||||
zeitpunkt timestamptz not null default now(),
|
||||
benutzer text not null,
|
||||
tabelle text not null,
|
||||
datensatz uuid not null,
|
||||
aktion text not null check (aktion in ('anlegen', 'aendern', 'loeschen')),
|
||||
vorher jsonb,
|
||||
nachher jsonb
|
||||
);
|
||||
create index protokoll_datensatz on protokoll (datensatz);
|
||||
|
||||
create function stempel_und_protokoll() returns trigger language plpgsql as $$
|
||||
declare
|
||||
wer text := coalesce(nullif(current_setting('betrieb.benutzer', true), ''), 'system');
|
||||
begin
|
||||
if tg_op = 'DELETE' then
|
||||
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher)
|
||||
values (wer, tg_table_name, old.id, 'loeschen', to_jsonb(old));
|
||||
return old;
|
||||
end if;
|
||||
new.geaendert_am := now();
|
||||
new.geaendert_von := wer;
|
||||
if tg_op = 'INSERT' then
|
||||
new.angelegt_am := now();
|
||||
insert into protokoll (benutzer, tabelle, datensatz, aktion, nachher)
|
||||
values (wer, tg_table_name, new.id, 'anlegen', to_jsonb(new));
|
||||
else
|
||||
new.angelegt_am := old.angelegt_am;
|
||||
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher, nachher)
|
||||
values (wer, tg_table_name, new.id, 'aendern', to_jsonb(old), to_jsonb(new));
|
||||
end if;
|
||||
return new;
|
||||
end $$;
|
||||
|
||||
create table kontakt (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
name text not null,
|
||||
firma text,
|
||||
rolle text not null default 'sonstige'
|
||||
check (rolle in ('bauherr', 'subunternehmer', 'lieferant', 'planer', 'mitarbeiter', 'sonstige')),
|
||||
telefon text,
|
||||
email text,
|
||||
gewerk text,
|
||||
notiz text,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
|
||||
create table projekt (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
nummer text not null unique,
|
||||
bezeichnung text not null,
|
||||
bauherr_id uuid references kontakt (id) on delete set null,
|
||||
status text not null default 'auftrag'
|
||||
check (status in ('anfrage', 'angebot', 'auftrag', 'ausfuehrung', 'abgerechnet', 'gewaehrleistung', 'abgeschlossen')),
|
||||
-- Projektpauschalen aus V70 (Einzelposten werden davon abgezogen)
|
||||
umsatz_netto bigint not null default 0,
|
||||
material_kosten bigint not null default 0,
|
||||
fremd_kosten bigint not null default 0,
|
||||
sonstige_kosten bigint not null default 0,
|
||||
vertragsart text check (vertragsart in ('vob', 'bgb')),
|
||||
abnahme_am date,
|
||||
farbe text,
|
||||
nextcloud_link text,
|
||||
reihenfolge integer not null default 0,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
|
||||
-- Abschnitte und Meilensteine sind gleichrangig unter dem Projekt
|
||||
create table abschnitt (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
projekt_id uuid not null references projekt (id) on delete cascade,
|
||||
name text not null,
|
||||
ist_meilenstein boolean not null default false,
|
||||
reihenfolge integer not null default 0,
|
||||
erledigt boolean not null default false,
|
||||
-- nur für Meilensteine ohne Vorgänge
|
||||
termin date,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
create index abschnitt_projekt on abschnitt (projekt_id);
|
||||
|
||||
create table vorgang (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
abschnitt_id uuid not null references abschnitt (id) on delete cascade,
|
||||
name text not null,
|
||||
start date not null,
|
||||
-- Dauer in Arbeitstagen; 0 = Meilenstein
|
||||
dauer numeric(6, 1) not null default 1 check (dauer >= 0),
|
||||
stunden numeric(8, 2),
|
||||
kontakt_id uuid references kontakt (id) on delete set null,
|
||||
reihenfolge integer not null default 0,
|
||||
fortschritt integer not null default 0 check (fortschritt between 0 and 100),
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
create index vorgang_abschnitt on vorgang (abschnitt_id);
|
||||
|
||||
-- Mehrere Vorgänger je Vorgang sind im Modell vorgesehen (T5)
|
||||
create table vorgang_vorgaenger (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
vorgang_id uuid not null references vorgang (id) on delete cascade,
|
||||
vorgaenger_id uuid not null references vorgang (id) on delete cascade,
|
||||
art text not null default 'EA' check (art in ('EA', 'AA', 'EE', 'AE')),
|
||||
verzoegerung integer not null default 0,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system',
|
||||
unique (vorgang_id, vorgaenger_id),
|
||||
check (vorgang_id <> vorgaenger_id)
|
||||
);
|
||||
|
||||
create table zahlung (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
projekt_id uuid not null references projekt (id) on delete cascade,
|
||||
vorgang_id uuid references vorgang (id) on delete set null,
|
||||
art text not null default 'abschlag' check (art in ('anzahlung', 'abschlag', 'nachtrag', 'schluss', 'einbehalt')),
|
||||
bezeichnung text not null,
|
||||
netto bigint not null,
|
||||
termin date not null,
|
||||
status text not null default 'geplant' check (status in ('geplant', 'gestellt', 'bezahlt')),
|
||||
rechnungsdatum date,
|
||||
bezahlt_am date,
|
||||
reihenfolge integer not null default 0,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
create index zahlung_projekt on zahlung (projekt_id);
|
||||
|
||||
create table kosten (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
projekt_id uuid not null references projekt (id) on delete cascade,
|
||||
art text not null check (art in ('material', 'fremd', 'sonstiges')),
|
||||
bezeichnung text not null,
|
||||
netto bigint not null,
|
||||
termin date not null,
|
||||
kontakt_id uuid references kontakt (id) on delete set null,
|
||||
mit_vorsteuer boolean not null default true,
|
||||
status text not null default 'geplant' check (status in ('geplant', 'bestellt', 'bezahlt')),
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
create index kosten_projekt on kosten (projekt_id);
|
||||
|
||||
create table laufende_kosten (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
bezeichnung text not null,
|
||||
kategorie text not null default 'Sonstiges',
|
||||
betrag bigint not null,
|
||||
rhythmus text not null default 'monatlich' check (rhythmus in ('einmalig', 'monatlich', 'vierteljaehrlich', 'jaehrlich')),
|
||||
start date not null,
|
||||
ende date,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
|
||||
create table aufgabe (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
text text not null,
|
||||
faellig_am date,
|
||||
langfristig boolean not null default false,
|
||||
projekt_id uuid references projekt (id) on delete set null,
|
||||
kontakt_id uuid references kontakt (id) on delete set null,
|
||||
erledigt_am timestamptz,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
|
||||
-- Genau eine Zeile mit allen Einstellungen
|
||||
create table einstellungen (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
einzeln boolean not null default true unique check (einzeln),
|
||||
daten jsonb not null default '{}',
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
insert into einstellungen (daten) values ('{}');
|
||||
|
||||
do $$
|
||||
declare t text;
|
||||
begin
|
||||
foreach t in array array['kontakt', 'projekt', 'abschnitt', 'vorgang', 'vorgang_vorgaenger', 'zahlung',
|
||||
'kosten', 'laufende_kosten', 'aufgabe', 'einstellungen'] loop
|
||||
execute format('create trigger %I_protokoll before insert or update or delete on %I
|
||||
for each row execute function stempel_und_protokoll()', t, t);
|
||||
end loop;
|
||||
end $$;
|
||||
149
src/server/tabellen.ts
Normal file
149
src/server/tabellen.ts
Normal file
@@ -0,0 +1,149 @@
|
||||
// Eingabeprüfung für die Tabellen aus Stufe 0. Feldnamen = Spaltennamen.
|
||||
import { z } from "zod";
|
||||
|
||||
const datum = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Datum im Format JJJJ-MM-TT");
|
||||
const cent = z.number().int("Betrag in ganzen Cent");
|
||||
const id = z.uuid();
|
||||
const text = z.string().trim().min(1, "darf nicht leer sein");
|
||||
const optText = z.string().trim().nullable().optional();
|
||||
|
||||
export interface Tabelle {
|
||||
name: string;
|
||||
pfad: string;
|
||||
schema: z.ZodObject;
|
||||
sortierung: string;
|
||||
}
|
||||
|
||||
export const TABELLEN: Tabelle[] = [
|
||||
{
|
||||
name: "kontakt",
|
||||
pfad: "kontakte",
|
||||
sortierung: "name",
|
||||
schema: z.object({
|
||||
name: text,
|
||||
firma: optText,
|
||||
rolle: z.enum(["bauherr", "subunternehmer", "lieferant", "planer", "mitarbeiter", "sonstige"]).optional(),
|
||||
telefon: optText,
|
||||
email: optText,
|
||||
gewerk: optText,
|
||||
notiz: optText,
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "projekt",
|
||||
pfad: "projekte",
|
||||
sortierung: "reihenfolge, nummer",
|
||||
schema: z.object({
|
||||
nummer: text,
|
||||
bezeichnung: text,
|
||||
bauherr_id: id.nullable().optional(),
|
||||
status: z.enum(["anfrage", "angebot", "auftrag", "ausfuehrung", "abgerechnet", "gewaehrleistung", "abgeschlossen"]).optional(),
|
||||
umsatz_netto: cent.optional(),
|
||||
material_kosten: cent.optional(),
|
||||
fremd_kosten: cent.optional(),
|
||||
sonstige_kosten: cent.optional(),
|
||||
vertragsart: z.enum(["vob", "bgb"]).nullable().optional(),
|
||||
abnahme_am: datum.nullable().optional(),
|
||||
farbe: optText,
|
||||
nextcloud_link: optText,
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "abschnitt",
|
||||
pfad: "abschnitte",
|
||||
sortierung: "projekt_id, reihenfolge",
|
||||
schema: z.object({
|
||||
projekt_id: id,
|
||||
name: text,
|
||||
ist_meilenstein: z.boolean().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
erledigt: z.boolean().optional(),
|
||||
termin: datum.nullable().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "vorgang",
|
||||
pfad: "vorgaenge",
|
||||
sortierung: "abschnitt_id, reihenfolge, start",
|
||||
schema: z.object({
|
||||
abschnitt_id: id,
|
||||
name: text,
|
||||
start: datum,
|
||||
dauer: z.number().min(0).optional(),
|
||||
stunden: z.number().min(0).nullable().optional(),
|
||||
kontakt_id: id.nullable().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
fortschritt: z.number().int().min(0).max(100).optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "vorgang_vorgaenger",
|
||||
pfad: "verknuepfungen",
|
||||
sortierung: "vorgang_id",
|
||||
schema: z.object({
|
||||
vorgang_id: id,
|
||||
vorgaenger_id: id,
|
||||
art: z.enum(["EA", "AA", "EE", "AE"]).optional(),
|
||||
verzoegerung: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "zahlung",
|
||||
pfad: "zahlungen",
|
||||
sortierung: "projekt_id, reihenfolge, termin",
|
||||
schema: z.object({
|
||||
projekt_id: id,
|
||||
vorgang_id: id.nullable().optional(),
|
||||
art: z.enum(["anzahlung", "abschlag", "nachtrag", "schluss", "einbehalt"]).optional(),
|
||||
bezeichnung: text,
|
||||
netto: cent,
|
||||
termin: datum,
|
||||
status: z.enum(["geplant", "gestellt", "bezahlt"]).optional(),
|
||||
rechnungsdatum: datum.nullable().optional(),
|
||||
bezahlt_am: datum.nullable().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "kosten",
|
||||
pfad: "kosten",
|
||||
sortierung: "projekt_id, termin",
|
||||
schema: z.object({
|
||||
projekt_id: id,
|
||||
art: z.enum(["material", "fremd", "sonstiges"]),
|
||||
bezeichnung: text,
|
||||
netto: cent,
|
||||
termin: datum,
|
||||
kontakt_id: id.nullable().optional(),
|
||||
mit_vorsteuer: z.boolean().optional(),
|
||||
status: z.enum(["geplant", "bestellt", "bezahlt"]).optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "laufende_kosten",
|
||||
pfad: "laufende-kosten",
|
||||
sortierung: "kategorie, bezeichnung",
|
||||
schema: z.object({
|
||||
bezeichnung: text,
|
||||
kategorie: text.optional(),
|
||||
betrag: cent,
|
||||
rhythmus: z.enum(["einmalig", "monatlich", "vierteljaehrlich", "jaehrlich"]).optional(),
|
||||
start: datum,
|
||||
ende: datum.nullable().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "aufgabe",
|
||||
pfad: "aufgaben",
|
||||
sortierung: "erledigt_am nulls first, faellig_am nulls last, angelegt_am",
|
||||
schema: z.object({
|
||||
text: text,
|
||||
faellig_am: datum.nullable().optional(),
|
||||
langfristig: z.boolean().optional(),
|
||||
projekt_id: id.nullable().optional(),
|
||||
kontakt_id: id.nullable().optional(),
|
||||
erledigt_am: z.iso.datetime({ offset: true }).nullable().optional(),
|
||||
}),
|
||||
},
|
||||
];
|
||||
2
src/server/version.ts
Normal file
2
src/server/version.ts
Normal file
@@ -0,0 +1,2 @@
|
||||
// Wird beim Release aus dem Git-Tag gesetzt (Umgebungsvariable APP_VERSION im Image).
|
||||
export const VERSION = process.env.APP_VERSION ?? "entwicklung";
|
||||
357
src/web/app.ts
Normal file
357
src/web/app.ts
Normal 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) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" })[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
19
src/web/index.html
Normal 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
37
src/web/styles.css
Normal 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
99
test/api.test.ts
Normal 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
73
test/geld.test.ts
Normal 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
86
test/kalender.test.ts
Normal 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
82
test/liquiditaet.test.ts
Normal 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
15
tsconfig.json
Normal 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
5
tsconfig.web.json
Normal 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
2
vitest.config.ts
Normal file
@@ -0,0 +1,2 @@
|
||||
import { defineConfig } from "vitest/config";
|
||||
export default defineConfig({ test: { include: ["test/**/*.test.ts"], fileParallelism: false } });
|
||||
Reference in New Issue
Block a user