Compare commits
6 Commits
v0.43.1
...
a384bc3409
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
a384bc3409 | ||
|
|
c68fadbc60 | ||
|
|
7e18b7f4de | ||
|
|
6d05766f9a | ||
|
|
1a1c464a64 | ||
|
|
8fde24a8a2 |
2
.gitignore
vendored
2
.gitignore
vendored
@@ -5,3 +5,5 @@ deploy/.env
|
||||
deploy/.env.*
|
||||
!deploy/.env.beispiel
|
||||
deploy/.vorige-version-*
|
||||
deploy/data/
|
||||
deploy/.vorige-version
|
||||
|
||||
28
CHANGELOG.md
28
CHANGELOG.md
@@ -2,6 +2,34 @@
|
||||
|
||||
Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen.
|
||||
|
||||
## 0.44.5 (04.11.2026)
|
||||
|
||||
- Nextcloud: Ein unter Einstellungen > Daten eingetragener Zugang gilt jetzt vor dem Zugang aus der Server-Datei `.env`. Die Maske zeigt an, welcher Zugang gerade gilt.
|
||||
- Server: Platzhalter wie `cloud.example.de` in der `.env` werden ignoriert. `.env.beispiel` enthält für die Nextcloud keine Beispielwerte mehr; die nächtliche Sicherung lädt nur hoch, wenn `NEXTCLOUD_URL` gesetzt ist.
|
||||
|
||||
## 0.44.4 (04.11.2026)
|
||||
|
||||
- Nextcloud: Ist die Nextcloud nicht erreichbar, nennt die Meldung jetzt die Ursache (z. B. Zertifikat, DNS, Verbindung abgelehnt) statt nur „fetch failed“. Gilt für Verbindung prüfen, Projektordner, Ablage und Kontakte-Abgleich.
|
||||
|
||||
## 0.44.3 (04.11.2026)
|
||||
|
||||
- Server: vorerst nur die Produktion, ohne Testumgebung. Daten in Ordnern statt Docker-Volumes: `deploy/data/db` (Datenbank) und `deploy/data/backup` (Sicherungen). `update.sh` kopiert vorhandene Daten aus den bisherigen Volumes einmalig herüber. Aufruf jetzt `./update.sh <version>` und `./zurueck.sh`.
|
||||
|
||||
## 0.44.2 (04.11.2026)
|
||||
|
||||
- Server: Caddy entfällt, TLS macht der vorhandene HAProxy. Die Produktion lauscht an 100.64.0.8:33181, die Testumgebung an 100.64.0.8:33182 (in `.env` änderbar: APP_ADRESSE, APP_PORT, TEST_PORT).
|
||||
|
||||
## 0.44.1 (04.11.2026)
|
||||
|
||||
- Server: Healthcheck fragt 127.0.0.1 statt localhost ab; unter Alpine zeigte localhost auf ::1, der Container galt dauerhaft als „unhealthy“.
|
||||
- Server: Das Datenbank-Passwort geht als PGPASSWORD an die App statt in der DATABASE_URL; Sonderzeichen im Passwort sind jetzt erlaubt.
|
||||
|
||||
## 0.44.0 (04.11.2026)
|
||||
|
||||
- Kontakte mit dem Handy abgleichen: über ein Adressbuch in der Nextcloud, das auch das iPhone als CardDAV-Account abgleicht. Alle 5 Minuten in beide Richtungen (Name, Firma, Telefon, Mobil, E-Mail, Adresse); Rolle, Gewerk und Notiz bleiben im Programm. Geändert auf beiden Seiten gilt die neuere Änderung. Im Handy gelöscht bleibt der Kontakt im Programm und wird markiert; im Programm gelöscht verschwindet die Karte. Beim ersten Abgleich werden gleiche Kontakte (E-Mail, Telefon oder Name) zusammengeführt. Einrichtung unter Daten, nur auf dem Server.
|
||||
- .vcf-Datei einlesen (Apple-Kontakte exportiert): neue Kontakte anlegen, vorhandene ergänzen. Geht auch in der Testversion.
|
||||
- Kontakte haben jetzt Mobil, Straße, PLZ und Ort; die Kontaktliste zeigt den Ort und, sobald der Abgleich läuft, „↔ Handy“.
|
||||
|
||||
## 0.43.1 (04.11.2026)
|
||||
|
||||
- Favicon: das Symbol von Holzbau Schaarschmidt (Dach und Baum, ohne Schrift) statt des ganzen Logos.
|
||||
|
||||
@@ -19,5 +19,5 @@ 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
|
||||
HEALTHCHECK --interval=30s --timeout=5s CMD wget -qO- http://127.0.0.1:3000/api/status || exit 1
|
||||
CMD ["node", "dist/server/index.js"]
|
||||
|
||||
11
README.md
11
README.md
@@ -36,20 +36,19 @@ Ohne Dev Container: Node 22 und PostgreSQL 16, dann `DATABASE_URL` und für die
|
||||
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. Auf dem Server baut `update.sh` das Image aus diesem Tag (git.deichnet.com), eine Registry ist nicht nötig.
|
||||
4. Auf dem Server erst die Testumgebung, nach Freigabe die Produktion:
|
||||
4. Auf dem Server (vorerst nur Produktion, ohne Testumgebung):
|
||||
|
||||
```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
|
||||
./update.sh 1.0.0
|
||||
./zurueck.sh # falls etwas schiefgeht: vorige Version und Sicherung
|
||||
```
|
||||
|
||||
## Server einrichten (einmalig)
|
||||
|
||||
1. Server mit Docker und git, Ports 80 und 443 frei, zwei DNS-Einträge (Produktion und Test) auf seine Adresse.
|
||||
1. Server mit Docker und git; ein Reverse Proxy (HAProxy) mit TLS leitet an `APP_ADRESSE:APP_PORT` aus `.env` weiter.
|
||||
2. Repository von git.deichnet.com auf den Server klonen, `deploy/.env.beispiel` nach `deploy/.env` kopieren und ausfüllen.
|
||||
3. `cd deploy && ./update.sh test 0.43.0 && ./update.sh produktion 0.43.0` baut das Image und startet beide Umgebungen samt Caddy (`docker compose up -d`).
|
||||
3. `cd deploy && ./update.sh 0.44.5` baut das Image und startet Programm, Datenbank und Sicherung (`docker compose up -d`). Die Daten liegen in `deploy/data/db` und `deploy/data/backup`. HTTPS macht der vorhandene HAProxy; er setzt `X-Forwarded-Proto: https`.
|
||||
4. Beim ersten Aufruf fragt das Programm nach dem Inhaber und dem Einrichtungscode (aus `.env` oder `docker compose logs app | grep Einrichtungscode`). Alle weiteren Zugänge legt der Inhaber unter „Benutzer“ an.
|
||||
|
||||
Sicherung: jede Nacht und vor jedem Update, 30 Tage aufbewahrt, Kopie per WebDAV in die Nextcloud.
|
||||
|
||||
@@ -29,6 +29,7 @@ import m024 from "../src/server/migrations/024_nextcloud_zugang.sql";
|
||||
import m025 from "../src/server/migrations/025_status_intern.sql";
|
||||
import m026 from "../src/server/migrations/026_zahlung_bezahlt.sql";
|
||||
import m027 from "../src/server/migrations/027_zaehlt.sql";
|
||||
import m028 from "../src/server/migrations/028_kontakte_abgleich.sql";
|
||||
|
||||
const MIGRATIONEN: [string, string][] = [
|
||||
["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004],
|
||||
@@ -53,6 +54,7 @@ const MIGRATIONEN: [string, string][] = [
|
||||
["025_status_intern.sql", m025],
|
||||
["026_zahlung_bezahlt.sql", m026],
|
||||
["027_zaehlt.sql", m027],
|
||||
["028_kontakte_abgleich.sql", m028],
|
||||
];
|
||||
|
||||
export async function starte(db: PGlite, v70?: unknown) {
|
||||
|
||||
@@ -1,18 +1,21 @@
|
||||
# Kopieren nach .env und ausfüllen. Die Datei bleibt nur auf dem Server.
|
||||
# Name des Images, das update.sh aus dem Git-Tag baut
|
||||
IMAGE=betrieb
|
||||
APP_VERSION=0.43.0
|
||||
TEST_VERSION=0.43.0
|
||||
DOMAIN=betrieb.schaarschmidt-holzbau.de
|
||||
TEST_DOMAIN=betrieb-test.schaarschmidt-holzbau.de
|
||||
APP_VERSION=0.44.5
|
||||
# Hier lauscht das Programm für den HAProxy (Adresse des Docker-Rechners im VPN)
|
||||
APP_ADRESSE=100.64.0.8
|
||||
APP_PORT=33181
|
||||
# Lang und zufällig, z. B. openssl rand -hex 24. Sonderzeichen sind erlaubt; enthält es ein $, den Wert in einfache Anführungszeichen setzen.
|
||||
DB_PASSWORT=bitte-lang-und-zufaellig
|
||||
# Code für die Einrichtung beim ersten Start (Inhaber anlegen). Leer lassen: das Programm
|
||||
# erzeugt einen und schreibt ihn ins Protokoll (docker compose logs app | grep Einrichtungscode).
|
||||
EINRICHTUNGSCODE=
|
||||
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
|
||||
# Optional: Kopie der nächtlichen Sicherung in die Nextcloud, z. B.
|
||||
# https://cloud.meine-firma.de/remote.php/dav/files/henning/Sicherungen/betrieb (leer = keine Kopie)
|
||||
NEXTCLOUD_URL=
|
||||
NEXTCLOUD_BENUTZER=
|
||||
NEXTCLOUD_PASSWORT=
|
||||
# Optional und besser im Programm unter Daten → Nextcloud einzutragen (der Zugang dort geht vor):
|
||||
# Ordner, in dem „01 Angebot“, „02 laufende Projekte“, „03 Gewährl.-Projekte“ und „04 Archiv“ liegen (P10)
|
||||
# Optional: der Zugang lässt sich auch im Programm unter Einstellungen > Daten eintragen (ab 0.31.0)
|
||||
NEXTCLOUD_PROJEKTE_URL=https://cloud.example.de/remote.php/dav/files/henning/Projekte
|
||||
NEXTCLOUD_PROJEKTE_URL=
|
||||
|
||||
@@ -1,13 +0,0 @@
|
||||
# HTTPS mit automatischem Zertifikat für Produktion und Testumgebung.
|
||||
# Anmeldung und Rollen macht das Programm selbst (U1/U2, ab 0.7.0); Caddy reicht nur durch.
|
||||
# Die Kalender-Abos unter /kalender/ sind durch ein Geheimnis im Link geschützt, das die App prüft.
|
||||
|
||||
{$DOMAIN} {
|
||||
encode gzip
|
||||
reverse_proxy app:3000
|
||||
}
|
||||
|
||||
{$TEST_DOMAIN} {
|
||||
encode gzip
|
||||
reverse_proxy app-test:3000
|
||||
}
|
||||
@@ -1,105 +1,57 @@
|
||||
# Betrieb auf dem Server: Produktion und Testumgebung nebeneinander,
|
||||
# jede mit eigener Datenbank und eigener Sicherung, davor ein gemeinsamer Proxy.
|
||||
# Betrieb auf dem Server: Programm, Datenbank und Sicherung (vorerst ohne Testumgebung, Henning 04.11.2026).
|
||||
# TLS macht Hennings HAProxy; er erreicht das Programm über das VPN an APP_ADRESSE:APP_PORT.
|
||||
# Die Daten liegen in Ordnern neben dieser Datei: ./data/db (Datenbank) und ./data/backup (Sicherungen).
|
||||
# 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}
|
||||
restart: unless-stopped
|
||||
ports: ["${APP_ADRESSE:-100.64.0.8}:${APP_PORT:-33181}:3000"]
|
||||
environment:
|
||||
DATABASE_URL: postgres://betrieb:${DB_PASSWORT}@db:5432/betrieb
|
||||
DATABASE_URL: postgres://betrieb@db:5432/betrieb
|
||||
PGPASSWORD: ${DB_PASSWORT}
|
||||
EINRICHTUNGSCODE: ${EINRICHTUNGSCODE:-}
|
||||
NEXTCLOUD_PROJEKTE_URL: ${NEXTCLOUD_PROJEKTE_URL:-}
|
||||
NEXTCLOUD_BENUTZER: ${NEXTCLOUD_BENUTZER:-}
|
||||
NEXTCLOUD_PASSWORT: ${NEXTCLOUD_PASSWORT:-}
|
||||
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
|
||||
EINRICHTUNGSCODE: ${EINRICHTUNGSCODE:-}
|
||||
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}
|
||||
volumes:
|
||||
- ./Caddyfile:/etc/caddy/Caddyfile:ro
|
||||
- caddy:/data
|
||||
networks: [intern]
|
||||
|
||||
volumes:
|
||||
db:
|
||||
db-test:
|
||||
sicherungen:
|
||||
sicherungen-test:
|
||||
caddy:
|
||||
image: postgres:16-alpine
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
POSTGRES_USER: betrieb
|
||||
POSTGRES_PASSWORD: ${DB_PASSWORT}
|
||||
POSTGRES_DB: betrieb
|
||||
volumes: ["./data/db:/var/lib/postgresql/data"]
|
||||
healthcheck:
|
||||
test: ["CMD", "pg_isready", "-U", "betrieb"]
|
||||
interval: 5s
|
||||
retries: 20
|
||||
networks: [intern]
|
||||
|
||||
backup:
|
||||
build: ../backup
|
||||
image: betrieb-backup
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
PGHOST: db
|
||||
PGUSER: betrieb
|
||||
PGPASSWORD: ${DB_PASSWORT}
|
||||
PGDATABASE: betrieb
|
||||
NAME: produktion
|
||||
AUFBEWAHREN_TAGE: "30"
|
||||
UHRZEIT: ${BACKUP_UHRZEIT:-02:30}
|
||||
NEXTCLOUD_URL: ${NEXTCLOUD_URL:-}
|
||||
NEXTCLOUD_BENUTZER: ${NEXTCLOUD_BENUTZER:-}
|
||||
NEXTCLOUD_PASSWORT: ${NEXTCLOUD_PASSWORT:-}
|
||||
volumes: ["./data/backup:/sicherungen"]
|
||||
depends_on:
|
||||
db: { condition: service_healthy }
|
||||
networks: [intern]
|
||||
|
||||
networks:
|
||||
intern:
|
||||
|
||||
@@ -1,29 +1,39 @@
|
||||
#!/bin/sh
|
||||
# Neue Version einspielen: Image aus dem Git-Tag bauen, Sicherung, dann 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)
|
||||
# ./update.sh 0.44.3
|
||||
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"
|
||||
# frühere Aufrufform „./update.sh produktion 0.44.3“ geht weiter
|
||||
[ "${1:-}" = "produktion" ] && shift
|
||||
version="${1:?Version angeben, z. B. ./update.sh 0.44.3}"
|
||||
alt=$(grep "^APP_VERSION=" .env | cut -d= -f2)
|
||||
echo "Update von $alt auf $version"
|
||||
image=$(grep "^IMAGE=" .env | cut -d= -f2)
|
||||
git fetch --tags origin
|
||||
if ! docker image inspect "$image:$version" >/dev/null 2>&1; then
|
||||
git -C .. archive "v$version" | docker build ${BUILD_OPTS:-} -t "$image:$version" --build-arg APP_VERSION="$version" -
|
||||
fi
|
||||
# Bei der ersten Einrichtung läuft noch nichts, dann gibt es auch nichts zu sichern.
|
||||
if [ -n "$(docker compose ps -q --status running "$backup")" ]; then
|
||||
docker compose exec -T "$backup" sicherung vor-update
|
||||
if [ -n "$(docker compose ps -q --status running backup)" ]; then
|
||||
docker compose exec -T backup sicherung vor-update
|
||||
fi
|
||||
echo "$alt" > ".vorige-version-$umgebung"
|
||||
sed -i "s/^$variable=.*/$variable=$version/" .env
|
||||
docker compose up -d "$app" "$backup" proxy
|
||||
echo "Fertig. Zurück mit: ./zurueck.sh $umgebung"
|
||||
mkdir -p data/db data/backup
|
||||
# Umstellung von Docker-Volumes auf ./data (0.44.3): vorhandene Daten einmalig herüberkopieren, die Volumes bleiben stehen
|
||||
projekt=${COMPOSE_PROJECT_NAME:-$(basename "$PWD")}
|
||||
umziehen() {
|
||||
if [ -z "$(ls -A "data/$2")" ] && docker volume inspect "${projekt}_$1" >/dev/null 2>&1; then
|
||||
echo "Kopiere Volume ${projekt}_$1 nach data/$2"
|
||||
docker run --rm -v "${projekt}_$1:/von:ro" -v "$PWD/data/$2:/nach" postgres:16-alpine sh -c 'cp -a /von/. /nach/'
|
||||
fi
|
||||
}
|
||||
if [ -z "$(ls -A data/db)" ] && docker volume inspect "${projekt}_db" >/dev/null 2>&1; then
|
||||
docker compose stop >/dev/null 2>&1 || true
|
||||
docker stop "${projekt}-db-1" >/dev/null 2>&1 || true
|
||||
umziehen db db
|
||||
umziehen sicherungen backup
|
||||
fi
|
||||
echo "$alt" > .vorige-version
|
||||
sed -i "s/^APP_VERSION=.*/APP_VERSION=$version/" .env
|
||||
docker compose up -d --remove-orphans
|
||||
echo "Fertig. Zurück mit: ./zurueck.sh"
|
||||
|
||||
@@ -1,19 +1,13 @@
|
||||
#!/bin/sh
|
||||
# Rückkehr zur vorigen Version und zur Sicherung vor dem letzten Update.
|
||||
# ./zurueck.sh produktion
|
||||
# ./zurueck.sh
|
||||
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"
|
||||
vorige=$(cat .vorige-version)
|
||||
sicherung=$(docker compose exec -T backup sh -c 'ls -t /sicherungen/*_vor-update.dump | head -1' | tr -d '\r')
|
||||
echo "Zurück auf $vorige mit Sicherung $sicherung (liegt auch unter ./data/backup)"
|
||||
docker compose stop app
|
||||
docker compose exec -T backup pg_restore --clean --if-exists --no-owner -d betrieb "$sicherung"
|
||||
sed -i "s/^APP_VERSION=.*/APP_VERSION=$vorige/" .env
|
||||
docker compose up -d app
|
||||
echo "Fertig."
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "betrieb",
|
||||
"version": "0.43.1",
|
||||
"version": "0.44.5",
|
||||
"private": true,
|
||||
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
|
||||
"type": "module",
|
||||
|
||||
132
src/domain/vcard.ts
Normal file
132
src/domain/vcard.ts
Normal file
@@ -0,0 +1,132 @@
|
||||
// Kontakte mit dem Handy abgleichen (Henning, 04.11.2026): vCard lesen und schreiben (RFC 2426/6350, wie Apple sie liefert).
|
||||
// Das Programm pflegt nur Name, Firma, Telefon, Mobil, E-Mail und Adresse; alles andere in der Karte (Foto,
|
||||
// Geburtstag, weitere Nummern) bleibt beim Zurückschreiben unverändert stehen.
|
||||
|
||||
export interface KontaktFelder {
|
||||
name: string;
|
||||
firma: string | null;
|
||||
telefon: string | null;
|
||||
mobil: string | null;
|
||||
email: string | null;
|
||||
strasse: string | null;
|
||||
plz: string | null;
|
||||
ort: string | null;
|
||||
}
|
||||
|
||||
export const FELDER: (keyof KontaktFelder)[] = ["name", "firma", "telefon", "mobil", "email", "strasse", "plz", "ort"];
|
||||
|
||||
interface Zeile {
|
||||
/** Gruppe wie „item1“ bei Apple */
|
||||
gruppe: string;
|
||||
name: string;
|
||||
params: string;
|
||||
wert: string;
|
||||
}
|
||||
|
||||
/** Fortsetzungszeilen zusammenführen und in Eigenschaften zerlegen */
|
||||
function zeilen(text: string): Zeile[] {
|
||||
const roh = text.replace(/\r\n|\r/g, "\n").replace(/\n[ \t]/g, "").split("\n").filter((z) => z.trim());
|
||||
return roh.map((z) => {
|
||||
const i = z.indexOf(":");
|
||||
const kopf = i < 0 ? z : z.slice(0, i);
|
||||
const wert = i < 0 ? "" : z.slice(i + 1);
|
||||
const [nameTeil, ...params] = kopf.split(";");
|
||||
const punkt = nameTeil!.lastIndexOf(".");
|
||||
return { gruppe: punkt < 0 ? "" : nameTeil!.slice(0, punkt), name: nameTeil!.slice(punkt + 1).toUpperCase(), params: params.join(";"), wert };
|
||||
});
|
||||
}
|
||||
|
||||
const ent = (s: string) => s.replace(/\\n/gi, "\n").replace(/\\([,;\\])/g, "$1").trim();
|
||||
const esc = (s: string) => s.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/([,;])/g, "\\$1");
|
||||
/** Strukturierte Werte (N, ADR, ORG) an unmaskierten Semikolons teilen */
|
||||
const teile = (s: string) => s.split(/(?<!\\);/).map(ent);
|
||||
const leer = (s: string | undefined | null) => (s && s.trim() ? s.trim() : null);
|
||||
const istMobil = (z: Zeile) => /type=[^;:]*\b(cell|iphone|mobile)\b/i.test(z.params) || /\bcell\b/i.test(z.params);
|
||||
const istTelefon = (z: Zeile) => z.name === "TEL" && !/\bfax\b/i.test(z.params);
|
||||
|
||||
/** Einzelne Karten aus einer .vcf-Datei mit vielen Kontakten */
|
||||
export function kartenAus(text: string): string[] {
|
||||
return [...text.replace(/\r\n|\r/g, "\n").matchAll(/BEGIN:VCARD[\s\S]*?END:VCARD/gi)].map((m) => m[0]);
|
||||
}
|
||||
|
||||
export function uidVon(karte: string): string | null {
|
||||
return leer(zeilen(karte).find((z) => z.name === "UID")?.wert);
|
||||
}
|
||||
|
||||
/** Letzte Änderung laut Karte (REV), falls angegeben */
|
||||
export function revVon(karte: string): string | null {
|
||||
const w = leer(zeilen(karte).find((z) => z.name === "REV")?.wert);
|
||||
if (!w) return null;
|
||||
const m = /^(\d{4})-?(\d{2})-?(\d{2})(?:T(\d{2}):?(\d{2}):?(\d{2}))?/.exec(w);
|
||||
return m ? `${m[1]}-${m[2]}-${m[3]}T${m[4] ?? "00"}:${m[5] ?? "00"}:${m[6] ?? "00"}Z` : null;
|
||||
}
|
||||
|
||||
export function felderAus(karte: string): KontaktFelder {
|
||||
const z = zeilen(karte);
|
||||
const erstes = (n: string) => z.find((x) => x.name === n);
|
||||
const org = leer(teile(erstes("ORG")?.wert ?? "").filter(Boolean).join(", "));
|
||||
const n = teile(erstes("N")?.wert ?? "");
|
||||
const ausN = leer([n[3], n[1], n[2], n[0], n[4]].filter((x) => x && x.trim()).join(" "));
|
||||
const fn = leer(ent(erstes("FN")?.wert ?? ""));
|
||||
const tels = z.filter(istTelefon);
|
||||
const mobil = tels.find(istMobil);
|
||||
const telefon = tels.find((t) => t !== mobil);
|
||||
const adr = z.find((x) => x.name === "ADR");
|
||||
const a = adr ? teile(adr.wert) : [];
|
||||
return {
|
||||
name: fn ?? ausN ?? org ?? "(ohne Namen)",
|
||||
firma: org,
|
||||
telefon: leer(telefon?.wert),
|
||||
mobil: leer(mobil?.wert),
|
||||
email: leer(erstes("EMAIL")?.wert),
|
||||
strasse: leer([a[1], a[2]].filter((x) => x && x.trim()).join(" ")),
|
||||
plz: leer(a[5]),
|
||||
ort: leer(a[3]),
|
||||
};
|
||||
}
|
||||
|
||||
/** Gleiche Inhalte erkennen, ohne auf Schreibweise von Leerzeichen zu achten */
|
||||
export function fingerabdruck(f: Partial<KontaktFelder>): string {
|
||||
return JSON.stringify(FELDER.map((k) => (f[k] ?? "").toString().replace(/\s+/g, " ").trim()));
|
||||
}
|
||||
|
||||
/** Telefonnummern vergleichbar machen: nur Ziffern, +49/0049 wie 0 */
|
||||
export function nummer(t: string | null | undefined): string {
|
||||
const d = (t ?? "").replace(/^\+/, "00").replace(/\D/g, "");
|
||||
return d.replace(/^0049/, "0");
|
||||
}
|
||||
|
||||
/**
|
||||
* Karte mit den Feldern aus dem Programm. Eine vorhandene Karte wird nur in den gepflegten Zeilen geändert;
|
||||
* ohne Karte entsteht eine neue (vCard 3.0, wie Apple sie anlegt).
|
||||
*/
|
||||
export function karteMit(f: KontaktFelder, uid: string, alt: string | null, jetzt = new Date()): string {
|
||||
const z = alt ? zeilen(alt).filter((x) => !["BEGIN", "END"].includes(x.name)) : [{ gruppe: "", name: "VERSION", params: "", wert: "3.0" }];
|
||||
const setze = (finde: (x: Zeile) => boolean, name: string, params: string, wert: string | null) => {
|
||||
const i = z.findIndex(finde);
|
||||
if (!wert) { if (i >= 0) z.splice(i, 1); return; }
|
||||
if (i >= 0) z[i] = { ...z[i]!, wert };
|
||||
else z.push({ gruppe: "", name, params, wert });
|
||||
};
|
||||
const firmaKontakt = !!f.firma && f.name === f.firma;
|
||||
const altFn = ent(z.find((x) => x.name === "FN")?.wert ?? "");
|
||||
setze((x) => x.name === "FN", "FN", "", esc(f.name));
|
||||
// N: Nachname;Vorname – bei Firmen bleibt N leer wie bei Apple
|
||||
const worte = f.name.trim().split(/\s+/);
|
||||
const nWert = firmaKontakt ? ";;;;" : worte.length > 1 ? `${esc(worte.at(-1)!)};${esc(worte.slice(0, -1).join(" "))};;;` : `${esc(f.name)};;;;`;
|
||||
// N nur neu setzen, wenn sich der Name geändert hat; sonst bleibt Apples Aufteilung (z. B. Titel, Namenszusatz)
|
||||
if (!z.some((x) => x.name === "N") || altFn !== f.name) setze((x) => x.name === "N", "N", "", nWert);
|
||||
setze((x) => x.name === "ORG", "ORG", "", f.firma ? `${esc(f.firma)};` : null);
|
||||
setze((x) => istTelefon(x) && istMobil(x), "TEL", "type=CELL;type=VOICE", f.mobil);
|
||||
setze((x) => istTelefon(x) && !istMobil(x), "TEL", "type=WORK;type=VOICE", f.telefon);
|
||||
setze((x) => x.name === "EMAIL", "EMAIL", "type=INTERNET;type=WORK", f.email);
|
||||
const adr = f.strasse || f.plz || f.ort ? `;;${esc(f.strasse ?? "")};${esc(f.ort ?? "")};;${esc(f.plz ?? "")};` : null;
|
||||
const altAdr = z.find((x) => x.name === "ADR");
|
||||
// Land und Region einer vorhandenen Adresse bleiben stehen
|
||||
const adrWert = adr && altAdr ? (() => { const t = altAdr.wert.split(/(?<!\\);/); return [t[0] ?? "", t[1] ?? "", esc(f.strasse ?? ""), esc(f.ort ?? ""), t[4] ?? "", esc(f.plz ?? ""), t[6] ?? ""].join(";"); })() : adr;
|
||||
setze((x) => x.name === "ADR", "ADR", "type=WORK", adrWert);
|
||||
setze((x) => x.name === "UID", "UID", "", uid);
|
||||
setze((x) => x.name === "REV", "REV", "", jetzt.toISOString().replace(/\.\d+Z$/, "Z"));
|
||||
const zeile = (x: Zeile) => `${x.gruppe ? `${x.gruppe}.` : ""}${x.name}${x.params ? `;${x.params}` : ""}:${x.wert}`;
|
||||
return ["BEGIN:VCARD", ...z.map(zeile), "END:VCARD"].join("\r\n") + "\r\n";
|
||||
}
|
||||
@@ -11,7 +11,8 @@ import { legeZahlungsplanAn, restNachziehen, zahlungsplanFest, zahlungsplaeneAut
|
||||
import { uebersicht } from "./uebersicht.js";
|
||||
import { aufgabenKalender, baustellenKalender } from "./kalender.js";
|
||||
import { nummernAufraeumen, projektNummerVorbereiten } from "./nummern.js";
|
||||
import { Nextcloud, STATUSORDNER, ordnerAbgleichen, webdavBasis } from "./nextcloud.js";
|
||||
import { Nextcloud, STATUSORDNER, fehlerText, ordnerAbgleichen, webdavBasis } from "./nextcloud.js";
|
||||
import { CardDav, ergebnisText, kontakteAbgleichen, vcfEinlesen } from "./kontaktabgleich.js";
|
||||
import { NUR_SICHERUNG, TABELLEN } from "./tabellen.js";
|
||||
import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js";
|
||||
import { liquiditaet } from "../domain/liquiditaet.js";
|
||||
@@ -49,6 +50,8 @@ export interface Optionen {
|
||||
anmeldung?: Anmeldeart;
|
||||
/** Nur auf dem Server: Code, mit dem der erste Benutzer (Inhaber) angelegt wird */
|
||||
einrichtungsCode?: string;
|
||||
/** Nur auf dem Server: Kontakte so oft (ms) mit dem Handy-Adressbuch abgleichen, wenn eingeschaltet */
|
||||
kontaktTakt?: number;
|
||||
}
|
||||
|
||||
/** Wer angemeldet ist, steht im Änderungsprotokoll */
|
||||
@@ -91,15 +94,20 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
// P10: Ordner nach dem Speichern abgleichen. Ein Fehler in der Nextcloud macht die Änderung nicht
|
||||
// rückgängig; der Hinweis kommt mit zurück, und der Abgleich lässt sich wiederholen.
|
||||
const einrichtbar = o.nextcloudEinrichtbar !== false;
|
||||
/** Der Zugang gilt sofort nach dem Speichern unter Daten, ohne Neustart */
|
||||
async function nextcloud(): Promise<Nextcloud | undefined> {
|
||||
if (o.nextcloud) return o.nextcloud;
|
||||
/**
|
||||
* Der Zugang gilt sofort nach dem Speichern unter Daten, ohne Neustart. Ein vollständig eingetragener Zugang aus der
|
||||
* Maske geht vor dem aus der .env (04.11.2026: dort standen noch Platzhalter und verdeckten die Maske).
|
||||
*/
|
||||
async function maskenZugang(): Promise<Nextcloud | undefined> {
|
||||
if (!einrichtbar) return undefined;
|
||||
const z = (await ladeEinstellungen()).nextcloud;
|
||||
if (!z.adresse || !z.benutzer) return undefined;
|
||||
const passwort = (await pool.query<{ passwort: string }>("select passwort from nextcloud_zugang")).rows[0]?.passwort;
|
||||
return passwort ? new Nextcloud({ url: webdavBasis(z), benutzer: z.benutzer, passwort }, o.nextcloudAbruf) : undefined;
|
||||
}
|
||||
async function nextcloud(): Promise<Nextcloud | undefined> {
|
||||
return (await maskenZugang()) ?? o.nextcloud;
|
||||
}
|
||||
|
||||
async function mitOrdner(p: Record<string, any>, wer: string): Promise<Record<string, unknown>> {
|
||||
const nc = await nextcloud();
|
||||
@@ -132,7 +140,9 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
app.get("/api/nextcloud", async () => {
|
||||
const z = (await ladeEinstellungen()).nextcloud;
|
||||
const pw = (await pool.query("select geaendert_am from nextcloud_zugang")).rows[0];
|
||||
return { ...z, passwortGesetzt: !!pw, passwortGeaendert: pw?.geaendert_am ?? null, fest: !!o.nextcloud, einrichtbar,
|
||||
const maske = !!(await maskenZugang());
|
||||
return { ...z, passwortGesetzt: !!pw, passwortGeaendert: pw?.geaendert_am ?? null, fest: !!o.nextcloud, festAdresse: o.nextcloud?.z.url ?? null,
|
||||
quelle: maske ? "maske" : o.nextcloud ? "server" : null, einrichtbar,
|
||||
webdav: z.adresse && z.benutzer ? webdavBasis(z) : null };
|
||||
});
|
||||
const ZugangEingabe = z.object({
|
||||
@@ -172,7 +182,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
} catch (err) {
|
||||
const text = (err as Error).message;
|
||||
if (/ 401 /.test(text)) return { ok: false, fehler: "Die Nextcloud lehnt die Anmeldung ab: Benutzer oder App-Passwort stimmt nicht." };
|
||||
return { ok: false, fehler: `Keine Verbindung: ${text}` };
|
||||
return { ok: false, fehler: `Keine Verbindung zu ${nc.z.url}: ${text || fehlerText(err)}` };
|
||||
}
|
||||
});
|
||||
// Alle Projekte einmal abgleichen: vorhandene Ordner mit gleicher Nummer übernehmen, fehlende anlegen, falsche verschieben
|
||||
@@ -189,6 +199,80 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
return { ok, fehler };
|
||||
});
|
||||
|
||||
// Kontakte mit dem Handy abgleichen (Henning, 04.11.2026): Adressbuch in derselben Nextcloud wie die Projektordner
|
||||
async function cardDav(): Promise<CardDav | undefined> {
|
||||
const nc = await nextcloud();
|
||||
return nc ? new CardDav(nc.z, nc.abruf) : undefined;
|
||||
}
|
||||
let laeuft: Promise<unknown> | null = null;
|
||||
async function kontakteLauf(): Promise<{ ok: boolean; meldung: string }> {
|
||||
const e = (await ladeEinstellungen()).kontakteAbgleich;
|
||||
const cd = await cardDav();
|
||||
if (!cd) return { ok: false, meldung: "Für den Abgleich fehlt der Nextcloud-Zugang." };
|
||||
if (!e.adressbuch) return { ok: false, meldung: "Bitte zuerst das Adressbuch wählen." };
|
||||
const stand = (meldung: string | null, fehler: string | null) => pool.query(`insert into abgleich_stand (art, zuletzt, meldung, fehler) values ('kontakte', now(), $1, $2)
|
||||
on conflict (art) do update set zuletzt = now(), meldung = coalesce(excluded.meldung, abgleich_stand.meldung), fehler = excluded.fehler`, [meldung, fehler]);
|
||||
try {
|
||||
const meldung = ergebnisText(await kontakteAbgleichen(pool, cd, e.adressbuch));
|
||||
await stand(meldung, null);
|
||||
return { ok: true, meldung };
|
||||
} catch (err) {
|
||||
await stand(null, (err as Error).message);
|
||||
return { ok: false, meldung: (err as Error).message };
|
||||
}
|
||||
}
|
||||
/** nie zwei Läufe gleichzeitig */
|
||||
const kontakteEinmal = async () => {
|
||||
while (laeuft) await laeuft.catch(() => {});
|
||||
const p = kontakteLauf();
|
||||
laeuft = p;
|
||||
try { return await p; } finally { laeuft = null; }
|
||||
};
|
||||
if (o.kontaktTakt) {
|
||||
const takt = setInterval(() => {
|
||||
void (async () => { if ((await ladeEinstellungen()).kontakteAbgleich.an) await kontakteEinmal(); })().catch((err) => app.log.error(err));
|
||||
}, o.kontaktTakt);
|
||||
app.addHook("onClose", async () => clearInterval(takt));
|
||||
}
|
||||
app.get("/api/kontakte-abgleich", async () => {
|
||||
const e = (await ladeEinstellungen()).kontakteAbgleich;
|
||||
const stand = (await pool.query("select zuletzt, meldung, fehler from abgleich_stand where art = 'kontakte'")).rows[0] ?? null;
|
||||
const n = (await pool.query("select count(*) filter (where not geloescht) as verknuepft, count(*) filter (where geloescht) as geloescht from kontakt_abgleich")).rows[0];
|
||||
return { ...e, moeglich: !!(await cardDav()), stand, verknuepft: Number(n.verknuepft), geloescht: Number(n.geloescht) };
|
||||
});
|
||||
app.get("/api/kontakte-abgleich/adressbuecher", async (_req, reply) => {
|
||||
const cd = await cardDav();
|
||||
if (!cd) return reply.status(409).send({ fehler: einrichtbar || o.nextcloud ? "Bitte zuerst den Nextcloud-Zugang eintragen." : "Der Abgleich mit dem Handy geht erst auf dem Server." });
|
||||
try { return await cd.adressbuecher(); } catch (err) { return reply.status(502).send({ fehler: (err as Error).message }); }
|
||||
});
|
||||
app.put("/api/kontakte-abgleich", async (req) => {
|
||||
const d = z.object({ adressbuch: z.string().trim().max(500), an: z.boolean() }).parse(req.body);
|
||||
const e = await ladeEinstellungen();
|
||||
const neu = EinstellungenSchema.parse({ ...e, kontakteAbgleich: d });
|
||||
await transaktion(pool, benutzer(req), async (c) => {
|
||||
await c.query("update einstellungen set daten = $1", [neu]);
|
||||
// anderes Adressbuch: Zuordnung neu aufbauen (der erste Lauf führt gleiche Kontakte zusammen)
|
||||
if (d.adressbuch !== e.kontakteAbgleich.adressbuch) {
|
||||
await c.query("delete from kontakt_abgleich");
|
||||
await c.query("delete from abgleich_stand where art = 'kontakte'");
|
||||
}
|
||||
});
|
||||
return { ok: true };
|
||||
});
|
||||
app.post("/api/kontakte-abgleich/jetzt", async (_req, reply) => {
|
||||
const r = await kontakteEinmal();
|
||||
return r.ok ? r : reply.status(409).send({ fehler: r.meldung });
|
||||
});
|
||||
/** welche Kontakte im Handy stehen, für die Markierung in der Kontaktliste */
|
||||
app.get("/api/kontakte-abgleich/kontakte", async () =>
|
||||
(await pool.query("select kontakt_id, geloescht from kontakt_abgleich where kontakt_id is not null")).rows);
|
||||
// .vcf-Datei einlesen (Apple: Kontakte auswählen → Exportieren); geht auch in der Testversion
|
||||
app.post("/api/kontakte/vcf", async (req, reply) => {
|
||||
const d = z.object({ text: z.string().max(20 * 1024 * 1024) }).parse(req.body);
|
||||
if (!/BEGIN:VCARD/i.test(d.text)) return reply.status(400).send({ fehler: "Das ist keine Kontaktdatei (vCard, .vcf)." });
|
||||
return transaktion(pool, benutzer(req), (c) => vcfEinlesen(c, d.text));
|
||||
});
|
||||
|
||||
// Ablage auf der Projektseite (Henning, 20.10.2026): Inhalt des Nextcloud-Projektordners anzeigen und Dateien öffnen
|
||||
const AblageAnfrage = z.object({ pfad: z.string().max(500).default("") })
|
||||
.refine((q) => !q.pfad.split("/").some((t) => t === ".." || t === "."), { message: "Pfad ungültig" });
|
||||
|
||||
@@ -58,6 +58,13 @@ export const EinstellungenSchema = z.object({
|
||||
// geheimer Teil der Kalender-Links (T11); Outlook classic kann sich nicht anmelden
|
||||
kalenderToken: z.string().min(20).nullable().default(null),
|
||||
// P10: Nextcloud-Zugang für die Projektordner (Henning, 23.10.2026); das App-Passwort steht nicht hier, sondern in nextcloud_zugang
|
||||
// Kontakte mit dem Handy abgleichen (Henning, 04.11.2026): Adressbuch (CardDAV-Adresse) in derselben Nextcloud
|
||||
kontakteAbgleich: z
|
||||
.object({
|
||||
adressbuch: z.string().trim().max(500).default(""),
|
||||
an: z.boolean().default(false),
|
||||
})
|
||||
.prefault({}),
|
||||
nextcloud: z
|
||||
.object({
|
||||
adresse: z.string().trim().max(300).default(""),
|
||||
|
||||
@@ -28,14 +28,17 @@ await migriere(pool, (t) => console.log(t));
|
||||
}
|
||||
// P10: Ordner der Projekte; gleicher Zugang wie für die Sicherung, eigene Adresse
|
||||
const { NEXTCLOUD_PROJEKTE_URL: ncUrl, NEXTCLOUD_BENUTZER: ncBenutzer, NEXTCLOUD_PASSWORT: ncPasswort } = process.env;
|
||||
const nextcloud = ncUrl && ncBenutzer && ncPasswort ? new Nextcloud({ url: ncUrl, benutzer: ncBenutzer, passwort: ncPasswort }) : undefined;
|
||||
// Platzhalter aus .env.beispiel (cloud.example.de) zählen nicht
|
||||
const platzhalter = !!ncUrl && /\bexample\.(de|com|org)\b/i.test(ncUrl);
|
||||
if (platzhalter) console.log("NEXTCLOUD_PROJEKTE_URL in .env ist noch der Platzhalter aus .env.beispiel und wird ignoriert");
|
||||
const nextcloud = ncUrl && ncBenutzer && ncPasswort && !platzhalter ? new Nextcloud({ url: ncUrl, benutzer: ncBenutzer, passwort: ncPasswort }) : undefined;
|
||||
// U1: Den ersten Benutzer (Inhaber) legt nur an, wer diesen Code kennt. Er steht im Log, solange niemand eingerichtet ist.
|
||||
let einrichtungsCode = process.env.EINRICHTUNGSCODE;
|
||||
if (Number((await pool.query("select count(*) as n from benutzer")).rows[0].n) === 0) {
|
||||
einrichtungsCode ||= randomBytes(6).toString("hex");
|
||||
console.log(`Noch kein Benutzer angelegt. Einrichtungscode für den Inhaber: ${einrichtungsCode}`);
|
||||
}
|
||||
const app = await baueApp({ pool, logger: true, nextcloud, anmeldung: "passwort", einrichtungsCode });
|
||||
const app = await baueApp({ pool, logger: true, nextcloud, anmeldung: "passwort", einrichtungsCode, kontaktTakt: 5 * 60 * 1000 });
|
||||
const port = Number(process.env.PORT ?? 3000);
|
||||
await app.listen({ host: "0.0.0.0", port });
|
||||
|
||||
|
||||
217
src/server/kontaktabgleich.ts
Normal file
217
src/server/kontaktabgleich.ts
Normal file
@@ -0,0 +1,217 @@
|
||||
// Kontakte mit dem Handy abgleichen (Henning, 04.11.2026): ein Adressbuch in der Nextcloud (CardDAV), das auch
|
||||
// das iPhone als CardDAV-Account abgleicht. In beide Richtungen; geändert auf beiden Seiten gilt die neuere Änderung.
|
||||
// Im Handy gelöscht bleibt der Kontakt im Programm (nur markiert); im Programm gelöscht verschwindet die Karte.
|
||||
|
||||
import type { Client, Pool } from "./db.js";
|
||||
import { transaktion } from "./db.js";
|
||||
import { type NextcloudZugang, abrufMitUrsache } from "./nextcloud.js";
|
||||
import { FELDER, type KontaktFelder, felderAus, fingerabdruck, karteMit, kartenAus, nummer, revVon, uidVon } from "../domain/vcard.js";
|
||||
|
||||
export interface Adressbuch { href: string; name: string }
|
||||
export interface Karte { href: string; etag: string | null; karte: string }
|
||||
|
||||
const xml = (s: string) => s.replace(/</g, "<").replace(/>/g, ">").replace(/"/g, '"').replace(/'/g, "'").replace(/ /g, "\r").replace(/ /g, "\n").replace(/&/g, "&");
|
||||
const tag = (teil: string, name: string) => new RegExp(`<(?:[\\w-]+:)?${name}\\b[^>]*>([\\s\\S]*?)</(?:[\\w-]+:)?${name}>`, "i").exec(teil)?.[1];
|
||||
const antworten = (text: string) => [...text.matchAll(/<(?:[\w-]+:)?response\b[^>]*>([\s\S]*?)<\/(?:[\w-]+:)?response>/gi)].map((m) => m[1]!);
|
||||
|
||||
/** Adressbücher des Benutzers in derselben Nextcloud wie die Projektordner */
|
||||
export class CardDav {
|
||||
private origin: string;
|
||||
readonly heim: string;
|
||||
constructor(private z: NextcloudZugang, private abruf: typeof fetch = fetch) {
|
||||
const u = new URL(z.url);
|
||||
this.origin = u.origin;
|
||||
const i = u.pathname.indexOf("/remote.php/");
|
||||
const basis = i >= 0 ? u.pathname.slice(0, i) : u.pathname.replace(/\/+$/, "");
|
||||
this.heim = `${basis}/remote.php/dav/addressbooks/users/${encodeURIComponent(z.benutzer)}/`;
|
||||
}
|
||||
|
||||
private anfrage(methode: string, href: string, kopf: Record<string, string> = {}, body?: string): Promise<Response> {
|
||||
return abrufMitUrsache(this.abruf, this.origin + href, {
|
||||
method: methode,
|
||||
headers: { authorization: `Basic ${btoa(`${this.z.benutzer}:${this.z.passwort}`)}`, ...kopf },
|
||||
body,
|
||||
});
|
||||
}
|
||||
|
||||
private static fehler(r: Response, was: string): Error {
|
||||
return new Error(r.status === 401 ? "Die Nextcloud lehnt die Anmeldung ab: Benutzer oder App-Passwort stimmt nicht." : `Nextcloud antwortet mit ${r.status} (${was})`);
|
||||
}
|
||||
|
||||
async adressbuecher(): Promise<Adressbuch[]> {
|
||||
const r = await this.anfrage("PROPFIND", this.heim, { depth: "1", "content-type": "application/xml; charset=utf-8" },
|
||||
'<?xml version="1.0" encoding="utf-8"?><d:propfind xmlns:d="DAV:"><d:prop><d:displayname/><d:resourcetype/></d:prop></d:propfind>');
|
||||
if (r.status !== 207) throw CardDav.fehler(r, "Adressbücher");
|
||||
return antworten(await r.text())
|
||||
.filter((t) => /<(?:[\w-]+:)?addressbook\s*\/?>/i.test(tag(t, "resourcetype") ?? ""))
|
||||
.map((t) => {
|
||||
const href = decodeURIComponent(tag(t, "href")!.trim());
|
||||
return { href, name: xml(tag(t, "displayname") ?? "").trim() || href.split("/").filter(Boolean).at(-1)! };
|
||||
});
|
||||
}
|
||||
|
||||
async karten(adressbuch: string): Promise<Karte[]> {
|
||||
const r = await this.anfrage("REPORT", adressbuch, { depth: "1", "content-type": "application/xml; charset=utf-8" },
|
||||
'<?xml version="1.0" encoding="utf-8"?><card:addressbook-query xmlns:d="DAV:" xmlns:card="urn:ietf:params:xml:ns:carddav"><d:prop><d:getetag/><card:address-data/></d:prop></card:addressbook-query>');
|
||||
if (r.status !== 207) throw CardDav.fehler(r, "Kontakte lesen");
|
||||
return antworten(await r.text())
|
||||
.map((t) => ({ href: decodeURIComponent(tag(t, "href")!.trim()), etag: tag(t, "getetag") ? xml(tag(t, "getetag")!).trim() : null, karte: xml(tag(t, "address-data") ?? "") }))
|
||||
.filter((k) => k.karte.includes("BEGIN:VCARD"));
|
||||
}
|
||||
|
||||
/** Karte schreiben; ohne etag nur, wenn es sie noch nicht gibt. Gibt das neue etag zurück, falls die Nextcloud es nennt. */
|
||||
async schreibe(href: string, karte: string, etag: string | null): Promise<string | null> {
|
||||
const r = await this.anfrage("PUT", href, { "content-type": "text/vcard; charset=utf-8", ...(etag ? { "if-match": etag } : { "if-none-match": "*" }) }, karte);
|
||||
if (!(r.status === 201 || r.status === 204 || r.status === 200)) throw CardDav.fehler(r, "Kontakt schreiben");
|
||||
return r.headers.get("etag");
|
||||
}
|
||||
|
||||
async loesche(href: string): Promise<void> {
|
||||
const r = await this.anfrage("DELETE", href);
|
||||
if (!(r.status === 204 || r.status === 200 || r.status === 404)) throw CardDav.fehler(r, "Kontakt löschen");
|
||||
}
|
||||
}
|
||||
|
||||
type Kontakt = KontaktFelder & { id: string; geaendert_am: Date | string };
|
||||
const SPALTEN = `id, ${FELDER.join(", ")}, geaendert_am`;
|
||||
const nurFelder = (k: KontaktFelder): KontaktFelder => Object.fromEntries(FELDER.map((f) => [f, k[f] ?? null])) as unknown as KontaktFelder;
|
||||
|
||||
async function kontaktSetzen(c: Client, id: string, f: KontaktFelder): Promise<void> {
|
||||
await c.query(`update kontakt set ${FELDER.map((x, i) => `${x} = $${i + 2}`).join(", ")}, geaendert_am = now() where id = $1`, [id, ...FELDER.map((x) => f[x])]);
|
||||
}
|
||||
async function kontaktNeu(c: Client, f: KontaktFelder): Promise<string> {
|
||||
return (await c.query(`insert into kontakt (${FELDER.join(", ")}) values (${FELDER.map((_, i) => `$${i + 1}`).join(", ")}) returning id`, FELDER.map((x) => f[x]))).rows[0].id;
|
||||
}
|
||||
|
||||
/** Derselbe Mensch: gleiche E-Mail, gleiche Nummer oder gleicher Name */
|
||||
export function passend<T extends KontaktFelder>(kontakte: T[], f: KontaktFelder): T | undefined {
|
||||
const mail = f.email?.toLowerCase();
|
||||
const nrn = [f.telefon, f.mobil].map(nummer).filter((n) => n.length >= 6);
|
||||
return (mail ? kontakte.find((k) => k.email?.toLowerCase() === mail) : undefined)
|
||||
?? kontakte.find((k) => [k.telefon, k.mobil].map(nummer).some((n) => n.length >= 6 && nrn.includes(n)))
|
||||
?? kontakte.find((k) => k.name.trim().toLowerCase() === f.name.trim().toLowerCase());
|
||||
}
|
||||
|
||||
/** Leere Felder im Programm aus der Karte füllen; was im Programm steht, bleibt */
|
||||
const ergaenzt = (k: KontaktFelder, f: KontaktFelder): KontaktFelder => nurFelder(Object.fromEntries(FELDER.map((x) => [x, k[x] ?? f[x]])) as unknown as KontaktFelder);
|
||||
|
||||
/** .vcf-Datei einlesen (auch ohne Nextcloud): neue Kontakte anlegen, vorhandene nur ergänzen */
|
||||
export async function vcfEinlesen(c: Client, text: string): Promise<{ neu: number; ergaenzt: number; gleich: number }> {
|
||||
const kontakte = (await c.query<Kontakt>(`select ${SPALTEN} from kontakt`)).rows;
|
||||
const e = { neu: 0, ergaenzt: 0, gleich: 0 };
|
||||
for (const karte of kartenAus(text)) {
|
||||
const f = felderAus(karte);
|
||||
const k = passend(kontakte, f);
|
||||
if (!k) { kontakte.push({ ...f, id: await kontaktNeu(c, f), geaendert_am: new Date() }); e.neu++; continue; }
|
||||
const m = ergaenzt(k, f);
|
||||
if (fingerabdruck(m) === fingerabdruck(k)) { e.gleich++; continue; }
|
||||
await kontaktSetzen(c, k.id, m);
|
||||
Object.assign(k, m);
|
||||
e.ergaenzt++;
|
||||
}
|
||||
return e;
|
||||
}
|
||||
|
||||
export interface Ergebnis { vomHandy: number; insHandy: number; neuVomHandy: number; neuInsHandy: number; imHandyGeloescht: number; entfernt: number; zusammengefuehrt: number }
|
||||
|
||||
export const ergebnisText = (e: Ergebnis) => {
|
||||
const t = [
|
||||
e.neuVomHandy && `${e.neuVomHandy} neu vom Handy`, e.vomHandy && `${e.vomHandy} vom Handy übernommen`,
|
||||
e.neuInsHandy && `${e.neuInsHandy} neu ins Handy`, e.insHandy && `${e.insHandy} ins Handy geschrieben`,
|
||||
e.zusammengefuehrt && `${e.zusammengefuehrt} zusammengeführt`, e.imHandyGeloescht && `${e.imHandyGeloescht} im Handy gelöscht`,
|
||||
e.entfernt && `${e.entfernt} aus dem Adressbuch entfernt`,
|
||||
].filter(Boolean);
|
||||
return t.length ? t.join(", ") : "alles gleich";
|
||||
};
|
||||
|
||||
/** Ein Abgleich mit dem Adressbuch. Jede Änderung steht im Protokoll unter „Handy-Abgleich“. */
|
||||
export async function kontakteAbgleichen(pool: Pool, cd: CardDav, adressbuch: string): Promise<Ergebnis> {
|
||||
const WER = "Handy-Abgleich";
|
||||
const e: Ergebnis = { vomHandy: 0, insHandy: 0, neuVomHandy: 0, neuInsHandy: 0, imHandyGeloescht: 0, entfernt: 0, zusammengefuehrt: 0 };
|
||||
const basis = adressbuch.endsWith("/") ? adressbuch : `${adressbuch}/`;
|
||||
const fern = new Map((await cd.karten(basis)).map((k) => [k.href, k]));
|
||||
const links = (await pool.query("select * from kontakt_abgleich")).rows as { href: string; kontakt_id: string | null; uid: string; etag: string | null; karte: string; stand: string; geloescht: boolean }[];
|
||||
const kontakte = new Map((await pool.query<Kontakt>(`select ${SPALTEN} from kontakt`)).rows.map((k) => [k.id, k]));
|
||||
const verknuepft = new Set<string>();
|
||||
const speichere = (href: string, kontaktId: string | null, uid: string, etag: string | null, karte: string, stand: string, geloescht = false) =>
|
||||
pool.query(`insert into kontakt_abgleich (href, kontakt_id, uid, etag, karte, stand, geloescht) values ($1, $2, $3, $4, $5, $6, $7)
|
||||
on conflict (href) do update set kontakt_id = excluded.kontakt_id, uid = excluded.uid, etag = excluded.etag, karte = excluded.karte, stand = excluded.stand,
|
||||
geloescht = excluded.geloescht, geaendert_am = now()`, [href, kontaktId, uid, etag, karte, stand, geloescht]);
|
||||
const insHandy = async (k: Kontakt, href: string, uid: string, alt: Karte | null) => {
|
||||
const karte = karteMit(nurFelder(k), uid, alt?.karte ?? null);
|
||||
const etag = await cd.schreibe(href, karte, alt?.etag ?? null);
|
||||
await speichere(href, k.id, uid, etag, karte, fingerabdruck(k));
|
||||
};
|
||||
const vomHandy = async (k: Kontakt, r: Karte, uid: string) => {
|
||||
const f = felderAus(r.karte);
|
||||
await transaktion(pool, WER, (c) => kontaktSetzen(c, k.id, f));
|
||||
Object.assign(k, f);
|
||||
await speichere(r.href, k.id, uid, r.etag, r.karte, fingerabdruck(f));
|
||||
};
|
||||
|
||||
for (const l of links) {
|
||||
const r = fern.get(l.href);
|
||||
fern.delete(l.href);
|
||||
const k = l.kontakt_id ? kontakte.get(l.kontakt_id) : undefined;
|
||||
if (!k) {
|
||||
// im Programm gelöscht
|
||||
if (r) await cd.loesche(l.href);
|
||||
await pool.query("delete from kontakt_abgleich where href = $1", [l.href]);
|
||||
e.entfernt++;
|
||||
continue;
|
||||
}
|
||||
verknuepft.add(k.id);
|
||||
const lokal = fingerabdruck(k) !== l.stand;
|
||||
if (!r) {
|
||||
if (!l.geloescht) {
|
||||
await pool.query("update kontakt_abgleich set geloescht = true, stand = $2, geaendert_am = now() where href = $1", [l.href, fingerabdruck(k)]);
|
||||
e.imHandyGeloescht++;
|
||||
} else if (lokal) {
|
||||
// nach dem Löschen im Handy im Programm geändert: wieder ins Handy
|
||||
await pool.query("delete from kontakt_abgleich where href = $1", [l.href]);
|
||||
const uid = crypto.randomUUID();
|
||||
await insHandy(k, `${basis}${uid}.vcf`, uid, null);
|
||||
e.neuInsHandy++;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
const fernGeaendert = r.etag !== l.etag;
|
||||
if (!fernGeaendert && !lokal) continue;
|
||||
if (fernGeaendert && fingerabdruck(felderAus(r.karte)) === fingerabdruck(k)) { await speichere(l.href, k.id, l.uid, r.etag, r.karte, fingerabdruck(k)); continue; }
|
||||
// beide geändert: die neuere Änderung gilt; ohne Zeitstempel in der Karte das Handy
|
||||
const rev = revVon(r.karte);
|
||||
const handyNeuer = !lokal || (fernGeaendert && (!rev || rev >= new Date(k.geaendert_am).toISOString()));
|
||||
if (handyNeuer) { await vomHandy(k, r, l.uid); e.vomHandy++; }
|
||||
else { await insHandy(k, l.href, l.uid, r); e.insHandy++; }
|
||||
}
|
||||
|
||||
// Karten, die das Programm noch nicht kennt: zu einem vorhandenen Kontakt oder neu
|
||||
const frei = () => [...kontakte.values()].filter((k) => !verknuepft.has(k.id));
|
||||
for (const r of fern.values()) {
|
||||
const f = felderAus(r.karte);
|
||||
const uid = uidVon(r.karte) ?? crypto.randomUUID();
|
||||
const k = passend(frei(), f);
|
||||
if (!k) {
|
||||
const id = await transaktion(pool, WER, (c) => kontaktNeu(c, f));
|
||||
const neu = { ...f, id, geaendert_am: new Date() };
|
||||
kontakte.set(id, neu);
|
||||
verknuepft.add(id);
|
||||
await speichere(r.href, id, uid, r.etag, r.karte, fingerabdruck(f));
|
||||
e.neuVomHandy++;
|
||||
continue;
|
||||
}
|
||||
verknuepft.add(k.id);
|
||||
const m = ergaenzt(k, f);
|
||||
if (fingerabdruck(m) !== fingerabdruck(k)) { await transaktion(pool, WER, (c) => kontaktSetzen(c, k.id, m)); Object.assign(k, m); }
|
||||
if (fingerabdruck(m) !== fingerabdruck(f)) await insHandy(k, r.href, uid, r);
|
||||
else await speichere(r.href, k.id, uid, r.etag, r.karte, fingerabdruck(k));
|
||||
e.zusammengefuehrt++;
|
||||
}
|
||||
|
||||
// Kontakte, die es im Handy noch nicht gibt
|
||||
for (const k of frei()) {
|
||||
await insHandy(k, `${basis}${k.id}.vcf`, k.id, null);
|
||||
e.neuInsHandy++;
|
||||
}
|
||||
return e;
|
||||
}
|
||||
31
src/server/migrations/028_kontakte_abgleich.sql
Normal file
31
src/server/migrations/028_kontakte_abgleich.sql
Normal file
@@ -0,0 +1,31 @@
|
||||
-- Kontakte mit dem Handy abgleichen über ein Adressbuch in der Nextcloud (Henning, 04.11.2026).
|
||||
-- Der Kontakt bekommt Mobilnummer und Adresse, wie sie im Handy stehen.
|
||||
alter table kontakt
|
||||
add column mobil text,
|
||||
add column strasse text,
|
||||
add column plz text,
|
||||
add column ort text;
|
||||
|
||||
-- Je Karte im Adressbuch: zu welchem Kontakt sie gehört und welcher Stand zuletzt auf beiden Seiten gleich war.
|
||||
-- Ohne Änderungsprotokoll und nicht in der Sicherungsdatei: der Abgleich baut sie neu auf.
|
||||
create table kontakt_abgleich (
|
||||
href text primary key,
|
||||
-- null: im Programm gelöscht, die Karte wird beim nächsten Abgleich im Adressbuch entfernt
|
||||
kontakt_id uuid unique references kontakt (id) on delete set null,
|
||||
uid text not null,
|
||||
etag text,
|
||||
karte text not null,
|
||||
-- Fingerabdruck der gepflegten Felder beim letzten Abgleich
|
||||
stand text not null,
|
||||
-- im Handy gelöscht; der Kontakt bleibt im Programm
|
||||
geloescht boolean not null default false,
|
||||
geaendert_am timestamptz not null default now()
|
||||
);
|
||||
|
||||
-- letzter Lauf je Abgleich, ohne Protokoll (läuft alle paar Minuten)
|
||||
create table abgleich_stand (
|
||||
art text primary key,
|
||||
zuletzt timestamptz,
|
||||
meldung text,
|
||||
fehler text
|
||||
);
|
||||
@@ -49,17 +49,39 @@ export function webdavBasis(z: { adresse: string; benutzer: string; ordner: stri
|
||||
return teile.length ? `${a}/${teile.map(encodeURIComponent).join("/")}` : a;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fehlertext mit Ursache: „fetch failed“ allein sagt nichts; die Ursache (z. B. Zertifikat, DNS, Verbindung abgelehnt)
|
||||
* steckt in err.cause mit code und message.
|
||||
*/
|
||||
export function fehlerText(err: unknown): string {
|
||||
const teile: string[] = [];
|
||||
for (let e = err as { message?: string; code?: string; cause?: unknown } | undefined, n = 0; e && n < 4; e = e.cause as typeof e, n++) {
|
||||
const t = [e.code, e.message].filter(Boolean).join(": ");
|
||||
if (t && !teile.includes(t)) teile.push(t);
|
||||
}
|
||||
return teile.join(" – ") || String(err);
|
||||
}
|
||||
|
||||
/** Netzfehler mit Ziel und Ursache weiterreichen */
|
||||
export async function abrufMitUrsache(abruf: typeof fetch, adresse: string, init: RequestInit): Promise<Response> {
|
||||
try {
|
||||
return await abruf(adresse, init);
|
||||
} catch (err) {
|
||||
throw new Error(`${new URL(adresse).host} nicht erreichbar: ${fehlerText(err)}`, { cause: err });
|
||||
}
|
||||
}
|
||||
|
||||
const kodiert = (pfad: string) => pfad.split("/").map(encodeURIComponent).join("/");
|
||||
|
||||
export class Nextcloud {
|
||||
constructor(private z: NextcloudZugang, private abruf: typeof fetch = fetch) {}
|
||||
constructor(readonly z: NextcloudZugang, readonly abruf: typeof fetch = fetch) {}
|
||||
|
||||
private adresse(pfad: string): string {
|
||||
return `${this.z.url.replace(/\/+$/, "")}/${kodiert(pfad)}`;
|
||||
}
|
||||
|
||||
private async anfrage(methode: string, pfad: string, kopf: Record<string, string> = {}, body?: string): Promise<Response> {
|
||||
return this.abruf(this.adresse(pfad), {
|
||||
return abrufMitUrsache(this.abruf, this.adresse(pfad), {
|
||||
method: methode,
|
||||
headers: { authorization: `Basic ${btoa(`${this.z.benutzer}:${this.z.passwort}`)}`, ...kopf },
|
||||
body,
|
||||
|
||||
@@ -59,7 +59,11 @@ export const TABELLEN: Tabelle[] = [
|
||||
firma: optText,
|
||||
rolle: z.enum(["bauherr", "subunternehmer", "lieferant", "planer", "mitarbeiter", "sonstige"]).optional(),
|
||||
telefon: optText,
|
||||
mobil: optText,
|
||||
email: optText,
|
||||
strasse: optText,
|
||||
plz: optText,
|
||||
ort: optText,
|
||||
gewerk: optText,
|
||||
notiz: optText,
|
||||
}),
|
||||
|
||||
@@ -33,13 +33,16 @@ const ROLLEN: [string, string][] = [
|
||||
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" },
|
||||
{ name: "telefon", titel: "Telefon" }, { name: "mobil", titel: "Mobil" }, { name: "email", titel: "E-Mail" },
|
||||
{ name: "strasse", titel: "Straße" }, { name: "plz", titel: "PLZ" }, { name: "ort", titel: "Ort" },
|
||||
{ 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 [zeilen, imHandy] = await Promise.all([api<Zeile[]>("kontakte"), api<Zeile[]>("kontakte-abgleich/kontakte").catch(() => [])]);
|
||||
const handy = new Map(imHandy.map((h) => [h.kontakt_id, h.geloescht]));
|
||||
const rolle = Object.fromEntries(ROLLEN);
|
||||
inhalt.appendChild(liste({
|
||||
schluessel: "kontakte", einheit: ["Kontakt", "Kontakte"], vorgabe: { sort: [["name", "auf"]] },
|
||||
@@ -50,6 +53,9 @@ async function kontakte(): Promise<void> {
|
||||
{ id: "gewerk", titel: "Gewerk", wert: (z) => esc(z.gewerk), klasse: "optional" },
|
||||
{ id: "telefon", titel: "Telefon", wert: (z) => (z.telefon ? `<a href="tel:${esc(z.telefon)}">${esc(z.telefon)}</a>` : "") },
|
||||
{ id: "email", titel: "E-Mail", wert: (z) => esc(z.email), klasse: "optional" },
|
||||
{ id: "ort", titel: "Ort", wert: (z) => esc(z.ort), klasse: "optional" },
|
||||
...(handy.size ? [{ id: "handy", titel: "Handy", klasse: "optional", wert: (z: Zeile) => !handy.has(z.id) ? "" : handy.get(z.id) ? '<span class="mark-handy weg">im Handy gelöscht</span>' : '<span class="mark-handy">↔ Handy</span>',
|
||||
sortWert: (z: Zeile) => (!handy.has(z.id) ? "" : handy.get(z.id) ? "im Handy gelöscht" : "im Handy") }] : []),
|
||||
],
|
||||
zeilen, klick: async (z) => (await bearbeiten("kontakte", "Kontakt bearbeiten", KONTAKT_FELDER, z, {}, z.rolle !== "mitarbeiter")) && kontakte(),
|
||||
}));
|
||||
@@ -1065,7 +1071,7 @@ async function nextcloudZugang(meldung = ""): Promise<void> {
|
||||
const z = await api<Zeile>("nextcloud");
|
||||
const zeile = (titel: string, wert: string) => `<tr><th>${titel}</th><td>${wert}</td></tr>`;
|
||||
ziel.innerHTML = `<p class="hinweis">Damit legt das Programm zu jedem Projekt einen Ordner an und verschiebt ihn bei jeder Statusänderung in „01 Angebot“, „02 laufende Projekte“, „03 Gewährl.-Projekte“ oder „04 Archiv“. Die Ablage auf der Projektseite zeigt seinen Inhalt.</p>
|
||||
${z.fest ? '<p class="hinweis">Der Zugang ist auf dem Server fest eingetragen und gilt vor den Angaben hier.</p>' : ""}
|
||||
${z.fest ? `<p class="hinweis">${z.quelle === "server" ? "Zurzeit gilt der Zugang aus der Server-Datei .env" : "Auf dem Server steht außerdem ein Zugang in der .env"} (${esc(z.festAdresse ?? "")}). ${z.quelle === "server" ? "Sobald hier Adresse, Benutzer und App-Passwort eingetragen sind, gelten diese." : "Er gilt nicht, solange der Zugang hier eingetragen ist."}</p>` : ""}
|
||||
<table class="nc-zugang"><tbody>
|
||||
${zeile("Adresse", z.adresse ? esc(z.adresse) : '<span class="leise">noch nicht eingetragen</span>')}
|
||||
${zeile("Benutzer", z.benutzer ? esc(z.benutzer) : '<span class="leise">–</span>')}
|
||||
@@ -1114,6 +1120,61 @@ async function nextcloudZugang(meldung = ""): Promise<void> {
|
||||
};
|
||||
}
|
||||
|
||||
// Kontakte mit dem Handy abgleichen (Henning „Nextcloud-Abgleich“, 04.11.2026): Adressbuch in der Nextcloud, das auch
|
||||
// das iPhone als CardDAV-Account abgleicht. Dazu eine .vcf-Datei einlesen (geht auch in der Testversion).
|
||||
async function kontakteAbgleich(meldung = "", buecher: Zeile[] | null = null): Promise<void> {
|
||||
const ziel = document.getElementById("kontakte-abgleich");
|
||||
if (!ziel) return;
|
||||
const a = await api<Zeile>("kontakte-abgleich");
|
||||
const zeile = (titel: string, wert: string) => `<tr><th>${titel}</th><td>${wert}</td></tr>`;
|
||||
const buch = a.adressbuch ? decodeURIComponent(String(a.adressbuch).split("/").filter(Boolean).at(-1) ?? "") : "";
|
||||
const auswahl = buecher
|
||||
? `<select data-ka="buch"><option value="">– wählen –</option>${buecher.map((b) => `<option value="${esc(b.href)}"${b.href === a.adressbuch ? " selected" : ""}>${esc(b.name)}</option>`).join("")}</select>`
|
||||
: `${buch ? esc(buch) : '<span class="leise">noch nicht gewählt</span>'} ${a.moeglich ? '<button class="neben klein" data-ka="buecher">wählen …</button>' : ""}`;
|
||||
ziel.innerHTML = `<p class="hinweis">Über ein Adressbuch in deiner Nextcloud, das auch das iPhone abgleicht (Einstellungen → Kontakte → Accounts → Account hinzufügen → Andere → CardDAV-Account). Name, Firma, Telefon, Mobil, E-Mail und Adresse gehen in beide Richtungen; Rolle, Gewerk und Notiz bleiben nur im Programm. Geändert auf beiden Seiten: die neuere Änderung gilt. Im Handy gelöscht bleibt der Kontakt hier und wird markiert.</p>
|
||||
${a.moeglich ? `<table class="nc-zugang"><tbody>
|
||||
${zeile("Adressbuch", auswahl)}
|
||||
${zeile("Abgleich", `<label class="schalter"><input type="checkbox" data-ka="an"${a.an ? " checked" : ""}${a.adressbuch ? "" : " disabled"}> alle 5 Minuten, in beide Richtungen</label>`)}
|
||||
${zeile("Zuletzt", a.stand ? `${new Date(a.stand.zuletzt).toLocaleString("de-DE", { dateStyle: "short", timeStyle: "short" })} · ${a.stand.fehler ? `<span class="rot">${esc(a.stand.fehler)}</span>` : esc(a.stand.meldung ?? "")}` : '<span class="leise">noch nicht</span>')}
|
||||
${zeile("Im Handy", `${a.verknuepft} Kontakte${a.geloescht ? `, ${a.geloescht} dort gelöscht` : ""}`)}
|
||||
</tbody></table>` : '<p class="hinweis">Der Abgleich läuft auf dem Server, sobald dort der Nextcloud-Zugang eingetragen ist (wie für die Projektordner). Eine .vcf-Datei kannst du schon jetzt einlesen.</p>'}
|
||||
${meldung}
|
||||
<p class="knopfzeile">${a.moeglich ? `<button class="haupt" data-ka="jetzt"${a.adressbuch ? "" : " disabled"}>Jetzt abgleichen</button>` : ""}
|
||||
<label class="neben datei-knopf">.vcf-Datei einlesen … <input type="file" data-ka="vcf" accept=".vcf,text/vcard,text/x-vcard" hidden></label></p>`;
|
||||
const speichern = async (adressbuch: string, an: boolean) => {
|
||||
try { await api("kontakte-abgleich", "PUT", { adressbuch, an }); return kontakteAbgleich('<p class="erfolg">Gespeichert.</p>'); }
|
||||
catch (err) { return kontakteAbgleich(`<p class="fehler">${esc((err as Error).message)}</p>`); }
|
||||
};
|
||||
ziel.onclick = async (ev) => {
|
||||
const k = (ev.target as HTMLElement).closest<HTMLElement>("[data-ka]")?.dataset.ka;
|
||||
if (k === "buecher") {
|
||||
try { return kontakteAbgleich("", await api<Zeile[]>("kontakte-abgleich/adressbuecher")); }
|
||||
catch (err) { return kontakteAbgleich(`<p class="fehler">${esc((err as Error).message)}</p>`); }
|
||||
}
|
||||
if (k === "jetzt") {
|
||||
try { const r = await api<Zeile>("kontakte-abgleich/jetzt", "POST"); return kontakteAbgleich(`<p class="erfolg">Abgeglichen: ${esc(r.meldung)}.</p>`); }
|
||||
catch (err) { return kontakteAbgleich(`<p class="fehler">${esc((err as Error).message)}</p>`); }
|
||||
}
|
||||
};
|
||||
ziel.onchange = async (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
const k = el.dataset.ka;
|
||||
if (k === "buch") {
|
||||
if (a.adressbuch && el.value !== a.adressbuch && !(await bestaetigen("Anderes Adressbuch wählen?", { hinweis: "Die Zuordnung wird neu aufgebaut. Beim nächsten Abgleich führt das Programm gleiche Kontakte (E-Mail, Telefon oder Name) zusammen.", ja: "Wählen" }))) return kontakteAbgleich("", buecher);
|
||||
return speichern(el.value, a.an && !!el.value);
|
||||
}
|
||||
if (k === "an") return speichern(String(a.adressbuch), el.checked);
|
||||
if (k === "vcf") {
|
||||
const f = el.files?.[0];
|
||||
if (!f) return;
|
||||
try {
|
||||
const r = await api<Zeile>("kontakte/vcf", "POST", { text: await f.text() });
|
||||
return kontakteAbgleich(`<p class="erfolg">Eingelesen: ${r.neu} neu, ${r.ergaenzt} ergänzt, ${r.gleich} schon vorhanden. Neue Kontakte haben die Rolle „Sonstige“.</p>`);
|
||||
} catch (err) { return kontakteAbgleich(`<p class="fehler">${esc((err as Error).message)}</p>`); }
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function kalenderLinks(token: string | null): void {
|
||||
const ziel = document.getElementById("kalender")!;
|
||||
const neu = async () => {
|
||||
@@ -1193,6 +1254,8 @@ async function daten(): Promise<void> {
|
||||
<div id="module"></div>
|
||||
<h2>Nextcloud (Projektordner)</h2>
|
||||
<div id="nextcloud"></div>
|
||||
<h2>Kontakte mit dem Handy abgleichen</h2>
|
||||
<div id="kontakte-abgleich"></div>
|
||||
<h2>Kalender in Outlook</h2>
|
||||
<div id="kalender"></div>
|
||||
<h2>Einstellungen</h2>`);
|
||||
@@ -1205,6 +1268,7 @@ async function daten(): Promise<void> {
|
||||
} else kalenderLinks(e.kalenderToken);
|
||||
moduleSchalter(e);
|
||||
void nextcloudZugang();
|
||||
void kontakteAbgleich();
|
||||
const stand = document.getElementById("stand-datei") as HTMLInputElement;
|
||||
stand.onchange = async () => {
|
||||
const f = stand.files?.[0];
|
||||
|
||||
@@ -2040,3 +2040,8 @@ ul.aufgaben li.aufgabe-2 .a-datum.ueber { color: var(--warn); font-weight: 600;
|
||||
.fluss-legende i.fl-ein { background: var(--gut-text); } .fluss-legende i.fl-pk { background: var(--fl-pk); }
|
||||
.fluss-legende i.fl-lk { background: var(--warn); } .fluss-legende i.fl-ust { background: var(--fl-ust); }
|
||||
.liqui-fluss-kopf p.hinweis { margin: 0; }
|
||||
|
||||
/* Kontakte mit dem Handy abgleichen (Henning, 04.11.2026) */
|
||||
.mark-handy { font-size: 12px; border-radius: 999px; padding: 2px 8px; background: var(--gut-bg); color: var(--gut-text); white-space: nowrap; }
|
||||
.mark-handy.weg { background: var(--warnung-bg); color: var(--warnung-text); }
|
||||
label.datei-knopf { display: inline-block; background: var(--fl); color: var(--text); border: 1px solid var(--linie); border-radius: 8px; padding: 8px 14px; cursor: pointer; }
|
||||
|
||||
116
test/kontaktabgleich.test.ts
Normal file
116
test/kontaktabgleich.test.ts
Normal file
@@ -0,0 +1,116 @@
|
||||
// Kontakte mit dem Handy abgleichen: Programm ↔ Adressbuch in der Nextcloud (CardDAV-Nachbildung im Speicher)
|
||||
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";
|
||||
import { Nextcloud } from "../src/server/nextcloud.js";
|
||||
import { felderAus, karteMit } from "../src/domain/vcard.js";
|
||||
|
||||
const url = process.env.TEST_DATABASE_URL;
|
||||
const BUCH = "/remote.php/dav/addressbooks/users/henning/holzbau/";
|
||||
|
||||
function falschesAdressbuch() {
|
||||
const karten = new Map<string, { etag: string; karte: string }>();
|
||||
let n = 0;
|
||||
const etag = () => `"e${++n}"`;
|
||||
const x = (s: string) => s.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">");
|
||||
const abruf = (async (u: string | URL, init?: RequestInit) => {
|
||||
const p = decodeURIComponent(new URL(String(u)).pathname);
|
||||
const kopf = (init?.headers ?? {}) as Record<string, string>;
|
||||
switch (init?.method) {
|
||||
case "PROPFIND":
|
||||
return new Response(`<?xml version="1.0"?><d:multistatus xmlns:d="DAV:" xmlns:card="urn:ietf:params:xml:ns:carddav">
|
||||
<d:response><d:href>/remote.php/dav/addressbooks/users/henning/</d:href><d:propstat><d:prop><d:resourcetype><d:collection/></d:resourcetype></d:prop></d:propstat></d:response>
|
||||
<d:response><d:href>${BUCH}</d:href><d:propstat><d:prop><d:displayname>Holzbau</d:displayname><d:resourcetype><d:collection/><card:addressbook/></d:resourcetype></d:prop></d:propstat></d:response>
|
||||
</d:multistatus>`, { status: 207 });
|
||||
case "REPORT":
|
||||
return new Response(`<?xml version="1.0"?><d:multistatus xmlns:d="DAV:" xmlns:card="urn:ietf:params:xml:ns:carddav">${[...karten].map(([h, k]) =>
|
||||
`<d:response><d:href>${h}</d:href><d:propstat><d:prop><d:getetag>${x(k.etag)}</d:getetag><card:address-data>${x(k.karte)}</card:address-data></d:prop></d:propstat></d:response>`).join("")}</d:multistatus>`, { status: 207 });
|
||||
case "PUT": {
|
||||
const da = karten.get(p);
|
||||
if (kopf["if-none-match"] === "*" && da) return new Response(null, { status: 412 });
|
||||
if (kopf["if-match"] && kopf["if-match"] !== da?.etag) return new Response(null, { status: 412 });
|
||||
const e = etag();
|
||||
karten.set(p, { etag: e, karte: String(init!.body) });
|
||||
return new Response(null, { status: da ? 204 : 201, headers: { etag: e } });
|
||||
}
|
||||
case "DELETE":
|
||||
karten.delete(p);
|
||||
return new Response(null, { status: 204 });
|
||||
}
|
||||
return new Response(null, { status: 400 });
|
||||
}) as typeof fetch;
|
||||
/** Änderung am Handy */
|
||||
const handy = (href: string, karte: string) => karten.set(href, { etag: etag(), karte });
|
||||
return { abruf, karten, handy };
|
||||
}
|
||||
|
||||
describe.skipIf(!url)("Kontakte mit dem Handy abgleichen", () => {
|
||||
let pool: Pool;
|
||||
let app: FastifyInstance;
|
||||
const f = falschesAdressbuch();
|
||||
const nc = new Nextcloud({ url: "https://cloud.test/remote.php/dav/files/henning/01 Projekte", benutzer: "henning", passwort: "geheim" }, f.abruf);
|
||||
const jetzt = async () => { const r = await app.inject({ method: "POST", url: "/api/kontakte-abgleich/jetzt" }); expect(r.statusCode, r.body).toBe(200); return r.json().meldung as string; };
|
||||
const kontakt = async (name: string) => (await app.inject("/api/kontakte")).json().find((k: { name: string }) => k.name === name);
|
||||
|
||||
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", nextcloud: nc, anmeldung: "testversion" });
|
||||
});
|
||||
afterAll(async () => {
|
||||
await app?.close();
|
||||
await pool?.end();
|
||||
});
|
||||
|
||||
it("Adressbuch wählen, erster Abgleich führt zusammen und legt an", async () => {
|
||||
expect((await app.inject("/api/kontakte-abgleich/adressbuecher")).json()).toEqual([{ href: BUCH, name: "Holzbau" }]);
|
||||
await app.inject({ method: "POST", url: "/api/kontakte", payload: { name: "Petra Braun", rolle: "bauherr", email: "petra@example.de" } });
|
||||
await app.inject({ method: "POST", url: "/api/kontakte", payload: { name: "Holzhandel Nord", firma: "Holzhandel Nord", rolle: "lieferant" } });
|
||||
f.handy(`${BUCH}a1.vcf`, "BEGIN:VCARD\r\nVERSION:3.0\r\nFN:Petra Braun\r\nN:Braun;Petra;;;\r\nTEL;type=CELL:0171 1\r\nEMAIL:petra@example.de\r\nUID:a1\r\nBDAY:1970-05-04\r\nEND:VCARD\r\n");
|
||||
f.handy(`${BUCH}a2.vcf`, "BEGIN:VCARD\r\nVERSION:3.0\r\nFN:Jan Peters\r\nTEL;type=WORK:0451 2\r\nUID:a2\r\nEND:VCARD\r\n");
|
||||
expect((await app.inject({ method: "PUT", url: "/api/kontakte-abgleich", payload: { adressbuch: BUCH, an: true } })).statusCode).toBe(200);
|
||||
expect(await jetzt()).toBe("1 neu vom Handy, 1 neu ins Handy, 1 zusammengeführt");
|
||||
// Petra: Mobilnummer vom Handy ergänzt, Rolle bleibt
|
||||
expect(await kontakt("Petra Braun")).toMatchObject({ mobil: "0171 1", rolle: "bauherr" });
|
||||
expect(await kontakt("Jan Peters")).toMatchObject({ telefon: "0451 2", rolle: "sonstige" });
|
||||
expect(f.karten.size).toBe(3);
|
||||
expect(await jetzt()).toBe("alles gleich");
|
||||
const s = (await app.inject("/api/kontakte-abgleich")).json();
|
||||
expect(s).toMatchObject({ an: true, adressbuch: BUCH, moeglich: true, verknuepft: 3, geloescht: 0 });
|
||||
});
|
||||
|
||||
it("Änderungen gehen in beide Richtungen, Rest der Karte bleibt", async () => {
|
||||
const petra = await kontakt("Petra Braun");
|
||||
await app.inject({ method: "PATCH", url: `/api/kontakte/${petra.id}`, payload: { ort: "Ratzeburg" } });
|
||||
expect(await jetzt()).toBe("1 ins Handy geschrieben");
|
||||
const karte = f.karten.get(`${BUCH}a1.vcf`)!.karte;
|
||||
expect(felderAus(karte).ort).toBe("Ratzeburg");
|
||||
expect(karte).toContain("BDAY:1970-05-04");
|
||||
// am Handy geändert
|
||||
f.handy(`${BUCH}a2.vcf`, karteMit({ ...felderAus(f.karten.get(`${BUCH}a2.vcf`)!.karte), email: "jan@peters.de" }, "a2", f.karten.get(`${BUCH}a2.vcf`)!.karte));
|
||||
expect(await jetzt()).toBe("1 vom Handy übernommen");
|
||||
expect((await kontakt("Jan Peters")).email).toBe("jan@peters.de");
|
||||
});
|
||||
|
||||
it("im Handy gelöscht bleibt im Programm; im Programm gelöscht verschwindet die Karte", async () => {
|
||||
f.karten.delete(`${BUCH}a2.vcf`);
|
||||
expect(await jetzt()).toBe("1 im Handy gelöscht");
|
||||
expect(await kontakt("Jan Peters")).toBeTruthy();
|
||||
expect((await app.inject("/api/kontakte-abgleich/kontakte")).json().filter((k: { geloescht: boolean }) => k.geloescht)).toHaveLength(1);
|
||||
expect(await jetzt()).toBe("alles gleich");
|
||||
const holz = await kontakt("Holzhandel Nord");
|
||||
expect((await app.inject({ method: "DELETE", url: `/api/kontakte/${holz.id}` })).statusCode).toBeLessThan(300);
|
||||
expect(await jetzt()).toBe("1 aus dem Adressbuch entfernt");
|
||||
expect([...f.karten.values()].some((k) => k.karte.includes("Holzhandel"))).toBe(false);
|
||||
});
|
||||
|
||||
it(".vcf-Datei einlesen ergänzt und legt an", async () => {
|
||||
const r = await app.inject({ method: "POST", url: "/api/kontakte/vcf", payload: { text: "BEGIN:VCARD\nVERSION:3.0\nFN:Petra Braun\nTEL;type=HOME:04541 8899\nEND:VCARD\nBEGIN:VCARD\nVERSION:3.0\nFN:Stadt Ratzeburg\nORG:Stadt Ratzeburg;\nEND:VCARD\n" } });
|
||||
expect(r.json()).toEqual({ neu: 1, ergaenzt: 1, gleich: 0 });
|
||||
expect((await kontakt("Petra Braun")).telefon).toBe("04541 8899");
|
||||
expect((await app.inject({ method: "POST", url: "/api/kontakte/vcf", payload: { text: "kein vcard" } })).statusCode).toBe(400);
|
||||
});
|
||||
});
|
||||
78
test/vcard.test.ts
Normal file
78
test/vcard.test.ts
Normal file
@@ -0,0 +1,78 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { felderAus, fingerabdruck, karteMit, kartenAus, nummer, revVon, uidVon } from "../src/domain/vcard.js";
|
||||
|
||||
// so exportiert Apple Kontakte (gekürzt)
|
||||
const APPLE = `BEGIN:VCARD\r
|
||||
VERSION:3.0\r
|
||||
PRODID:-//Apple Inc.//iPhone OS 18.0//EN\r
|
||||
N:Braun;Petra;;;\r
|
||||
FN:Petra Braun\r
|
||||
ORG:Braun & Müller GbR;\r
|
||||
EMAIL;type=INTERNET;type=HOME;type=pref:petra@example.de\r
|
||||
TEL;type=CELL;type=VOICE;type=pref:0171 1234567\r
|
||||
TEL;type=HOME;type=VOICE:04541 8899\r
|
||||
item1.ADR;type=HOME;type=pref:;;Am Markt 3\\nHinterhaus;Ratzeburg;;23909;Deutschland\r
|
||||
item1.X-ABADR:de\r
|
||||
BDAY:1970-05-04\r
|
||||
NOTE:sehr lange Notiz, die über die Zeile hin\r
|
||||
aus geht\r
|
||||
UID:ABC-123\r
|
||||
REV:2026-11-04T18:12:03Z\r
|
||||
END:VCARD\r
|
||||
BEGIN:VCARD\r
|
||||
VERSION:3.0\r
|
||||
FN:Holzhandel Nord\r
|
||||
ORG:Holzhandel Nord;\r
|
||||
X-ABShowAs:COMPANY\r
|
||||
TEL;type=WORK;type=VOICE:+49 451 123\r
|
||||
END:VCARD\r
|
||||
`;
|
||||
|
||||
describe("vCard", () => {
|
||||
it("liest Apple-Karten", () => {
|
||||
const [a, b] = kartenAus(APPLE);
|
||||
expect(felderAus(a!)).toEqual({ name: "Petra Braun", firma: "Braun & Müller GbR", telefon: "04541 8899", mobil: "0171 1234567", email: "petra@example.de",
|
||||
strasse: "Am Markt 3\nHinterhaus", plz: "23909", ort: "Ratzeburg" });
|
||||
expect(uidVon(a!)).toBe("ABC-123");
|
||||
expect(revVon(a!)).toBe("2026-11-04T18:12:03Z");
|
||||
expect(felderAus(b!)).toMatchObject({ name: "Holzhandel Nord", firma: "Holzhandel Nord", telefon: "+49 451 123", mobil: null });
|
||||
});
|
||||
|
||||
it("schreibt nur die gepflegten Zeilen, der Rest bleibt", () => {
|
||||
const [a] = kartenAus(APPLE);
|
||||
const f = { ...felderAus(a!), mobil: "0171 7654321", email: null };
|
||||
const neu = karteMit(f, "ABC-123", a!, new Date("2026-11-05T10:00:00Z"));
|
||||
expect(felderAus(neu)).toEqual(f);
|
||||
expect(neu).toContain("BDAY:1970-05-04");
|
||||
expect(neu).toContain("item1.X-ABADR:de");
|
||||
expect(neu).toContain("Deutschland");
|
||||
expect(neu).toContain("N:Braun;Petra;;;");
|
||||
expect(neu).not.toContain("EMAIL");
|
||||
expect(revVon(neu)).toBe("2026-11-05T10:00:00Z");
|
||||
});
|
||||
|
||||
it("legt neue Karten an, mit Sonderzeichen", () => {
|
||||
const f = { name: "Jan Peters", firma: "Peters; Söhne", telefon: "0451 1", mobil: null, email: "jan@x.de", strasse: "Weg 1", plz: "23909", ort: "Ratzeburg" };
|
||||
const k = karteMit(f, "u1", null);
|
||||
expect(k).toMatch(/^BEGIN:VCARD\r\nVERSION:3.0\r\n/);
|
||||
expect(k).toContain("N:Peters;Jan;;;");
|
||||
expect(felderAus(k)).toEqual(f);
|
||||
expect(uidVon(k)).toBe("u1");
|
||||
});
|
||||
|
||||
it("vergleicht Nummern und Inhalte", () => {
|
||||
expect(nummer("+49 171 / 123")).toBe(nummer("0171-123"));
|
||||
expect(fingerabdruck({ name: "A B" })).toBe(fingerabdruck({ name: "A B", firma: null }));
|
||||
});
|
||||
});
|
||||
|
||||
describe("Netzfehler mit Ursache", () => {
|
||||
it("zeigt code und message aus err.cause", async () => {
|
||||
const { abrufMitUrsache, fehlerText } = await import("../src/server/nextcloud.js");
|
||||
const tls = Object.assign(new Error("unable to verify the first certificate"), { code: "UNABLE_TO_VERIFY_LEAF_SIGNATURE" });
|
||||
const fehler = new TypeError("fetch failed", { cause: tls });
|
||||
expect(fehlerText(fehler)).toBe("fetch failed – UNABLE_TO_VERIFY_LEAF_SIGNATURE: unable to verify the first certificate");
|
||||
const abruf = (async () => { throw fehler; }) as unknown as typeof fetch;
|
||||
await expect(abrufMitUrsache(abruf, "https://cloud.test/remote.php/dav", {})).rejects.toThrow("cloud.test nicht erreichbar: fetch failed – UNABLE_TO_VERIFY_LEAF_SIGNATURE");
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user