Compare commits
7 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
647e0905d9 | ||
|
|
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
|
||||
|
||||
34
CHANGELOG.md
34
CHANGELOG.md
@@ -2,6 +2,40 @@
|
||||
|
||||
Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen.
|
||||
|
||||
## 0.45.0 (08.11.2026)
|
||||
|
||||
- Adressen: Beim Tippen der Straße (Kontakte, Baustelle im Projekt) schlägt das Programm Adressen vor, zuerst aus deinen Kontakten und Projekten, dann neue aus OpenStreetMap. Ein Klick füllt Straße, PLZ und Ort. Für die Kartenvorschläge geht der getippte Text an den freien Dienst Photon (komoot); in der Testversion im Browser gibt es nur die eigenen Vorschläge.
|
||||
- Projekte: Die Projektliste und die Projektseite nutzen die ganze Bildschirmbreite.
|
||||
- Projekte: In der Projektmaske und in den Eckdaten stehen die Kosten der Baustelle als eine Zeile statt aufgeteilt in Material, Fremdleistung und Sonstiges.
|
||||
|
||||
## 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.45.0` 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.45.0
|
||||
# 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.45.0",
|
||||
"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";
|
||||
}
|
||||
92
src/server/adressen.ts
Normal file
92
src/server/adressen.ts
Normal file
@@ -0,0 +1,92 @@
|
||||
// Adressvorschläge beim Tippen (Henning, 08.11.2026): zuerst aus eigenen Kontakten und Projekten,
|
||||
// dann neue Adressen aus OpenStreetMap über Photon (komoot, frei, ohne Schlüssel). Der getippte Text geht dabei an Photon.
|
||||
import type { Pool } from "pg";
|
||||
|
||||
export interface Adresse {
|
||||
strasse: string;
|
||||
plz: string;
|
||||
ort: string;
|
||||
/** Name des Kontakts, Projekts oder Ortes in der Karte */
|
||||
titel: string;
|
||||
quelle: "kontakt" | "projekt" | "karte";
|
||||
}
|
||||
|
||||
export const PHOTON = "https://photon.komoot.io/api/";
|
||||
/** Vorschläge rund um Ratzeburg zuerst */
|
||||
const MITTE = { lat: "53.70", lon: "10.77" };
|
||||
|
||||
const worte = (q: string) => q.trim().split(/\s+/).filter(Boolean).slice(0, 6).map((w) => `%${w.replace(/[\\%_]/g, "\\$&")}%`);
|
||||
const schluessel = (a: Pick<Adresse, "strasse" | "plz">) =>
|
||||
`${a.strasse.toLowerCase().replace(/\s+/g, " ").replace(/str\.?(?=\s|\d|$)/, "straße")}|${a.plz}`;
|
||||
|
||||
/** Adressen, die schon in Kontakten oder als Baustelle in Projekten stehen */
|
||||
export async function eigeneAdressen(pool: Pool, q: string, anzahl = 6): Promise<Adresse[]> {
|
||||
const w = worte(q);
|
||||
if (!w.length) return [];
|
||||
const bedingung = w.map((_, i) => `(strasse || ' ' || plz || ' ' || ort || ' ' || titel) ilike $${i + 1}`).join(" and ");
|
||||
const r = await pool.query(
|
||||
`select strasse, plz, ort, titel, quelle from (
|
||||
select trim(strasse) strasse, coalesce(trim(plz), '') plz, coalesce(trim(ort), '') ort, name titel, 'kontakt' quelle, 1 rang
|
||||
from kontakt where coalesce(trim(strasse), '') <> ''
|
||||
union all
|
||||
select trim(baustelle_strasse), coalesce(trim(baustelle_plz), ''), coalesce(trim(baustelle_ort), ''), bezeichnung, 'projekt', 2
|
||||
from projekt where coalesce(trim(baustelle_strasse), '') <> ''
|
||||
) x where ${bedingung} order by rang, strasse limit 40`, w);
|
||||
const gesehen = new Set<string>();
|
||||
const aus: Adresse[] = [];
|
||||
for (const a of r.rows as Adresse[]) {
|
||||
const k = schluessel(a);
|
||||
if (gesehen.has(k)) continue;
|
||||
gesehen.add(k);
|
||||
aus.push(a);
|
||||
if (aus.length >= anzahl) break;
|
||||
}
|
||||
return aus;
|
||||
}
|
||||
|
||||
interface PhotonMerkmale {
|
||||
name?: string; street?: string; housenumber?: string; postcode?: string; city?: string; town?: string; village?: string;
|
||||
district?: string; locality?: string; osm_key?: string; type?: string;
|
||||
}
|
||||
|
||||
/** Neue Adressen aus OpenStreetMap; Fehler und Zeitüberschreitung ergeben einfach keine Vorschläge */
|
||||
export async function kartenAdressen(q: string, abruf: typeof fetch = fetch, anzahl = 6): Promise<Adresse[]> {
|
||||
if (q.trim().length < 4) return [];
|
||||
const u = new URL(PHOTON);
|
||||
u.searchParams.set("q", q.trim().slice(0, 120));
|
||||
u.searchParams.set("lang", "de");
|
||||
u.searchParams.set("limit", String(anzahl + 2));
|
||||
u.searchParams.set("lat", MITTE.lat);
|
||||
u.searchParams.set("lon", MITTE.lon);
|
||||
u.searchParams.append("layer", "house");
|
||||
u.searchParams.append("layer", "street");
|
||||
try {
|
||||
const r = await abruf(u, { headers: { accept: "application/json", "user-agent": "Betriebsprogramm-Holzbau/1" }, signal: AbortSignal.timeout(4000) });
|
||||
if (!r.ok) return [];
|
||||
const j = (await r.json()) as { features?: { properties?: PhotonMerkmale }[] };
|
||||
const aus: Adresse[] = [];
|
||||
for (const f of j.features ?? []) {
|
||||
const p = f.properties ?? {};
|
||||
const strasse = p.street ? `${p.street}${p.housenumber ? ` ${p.housenumber}` : ""}` : p.osm_key === "highway" || p.type === "street" ? p.name ?? "" : "";
|
||||
const ort = p.city ?? p.town ?? p.village ?? p.locality ?? p.district ?? "";
|
||||
if (!strasse || (!p.postcode && !ort)) continue;
|
||||
const titel = p.name && p.name !== strasse && p.name !== p.street ? p.name : "";
|
||||
aus.push({ strasse, plz: p.postcode ?? "", ort, titel, quelle: "karte" });
|
||||
}
|
||||
return aus.slice(0, anzahl);
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
/** Eigene zuerst, die Karte ergänzt nur, was noch nicht dabei ist */
|
||||
export function zusammen(eigene: Adresse[], karte: Adresse[], anzahl = 8): Adresse[] {
|
||||
const gesehen = new Set(eigene.map(schluessel));
|
||||
const neu = karte.filter((a) => {
|
||||
const k = schluessel(a);
|
||||
if (gesehen.has(k)) return false;
|
||||
gesehen.add(k);
|
||||
return true;
|
||||
});
|
||||
return [...eigene, ...neu].slice(0, anzahl);
|
||||
}
|
||||
@@ -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";
|
||||
@@ -34,6 +35,7 @@ import { finanzsitzungAnlegen, geltendePlaene, jahresplanStand, registriereJahre
|
||||
import { planPosten } from "../domain/jahresplan.js";
|
||||
import { type BezugArt, bezugsTage } from "../domain/bezug.js";
|
||||
import { formatDatum, plusTage } from "../domain/datum.js";
|
||||
import { eigeneAdressen, kartenAdressen, zusammen } from "./adressen.js";
|
||||
|
||||
export interface Optionen {
|
||||
pool: Pool;
|
||||
@@ -49,6 +51,10 @@ 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;
|
||||
/** Adressvorschläge aus OpenStreetMap; false schaltet sie ab, eine Funktion ersetzt den Abruf (Tests) */
|
||||
adressKarte?: false | typeof fetch;
|
||||
}
|
||||
|
||||
/** Wer angemeldet ist, steht im Änderungsprotokoll */
|
||||
@@ -91,15 +97,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 +143,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 +185,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 +202,87 @@ 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 */
|
||||
// Adressvorschläge beim Tippen: eigene Kontakte und Projekte, dazu OpenStreetMap (Henning, 08.11.2026)
|
||||
app.get("/api/adressen", async (req) => {
|
||||
const q = z.object({ q: z.string().max(200).default("") }).parse(req.query).q.trim();
|
||||
if (q.length < 2) return { treffer: [] };
|
||||
const [eigene, karte] = await Promise.all([eigeneAdressen(pool, q), o.adressKarte === false ? [] : kartenAdressen(q, o.adressKarte ?? fetch)]);
|
||||
return { treffer: zusammen(eigene, karte) };
|
||||
});
|
||||
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", adresse: { plz: "plz", ort: "ort" } }, { 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(),
|
||||
}));
|
||||
@@ -74,16 +80,24 @@ async function projektFelder(): Promise<Feld[]> {
|
||||
{ name: "bauherr_id", titel: "Kunde (Bauherr)", art: "auswahl", optionen: [["", "–"], ...sortiert.map((k): [string, string] => [k.id, k.name])],
|
||||
neu: { text: "+ Neuer Kunde …", titel: "Neuen Kunden anlegen", felder: [{ name: "name", titel: "Name", pflicht: true }, { name: "firma", titel: "Firma" }, { name: "telefon", titel: "Telefon" }, { name: "email", titel: "E-Mail" }],
|
||||
anlegen: async (d) => { const k = await api<Zeile>("kontakte", "POST", { ...d, rolle: "bauherr" }); return [k.id, k.name]; } } },
|
||||
{ name: "baustelle_strasse", titel: "Baustelle: Straße" }, { name: "baustelle_plz", titel: "Baustelle: PLZ" }, { name: "baustelle_ort", titel: "Baustelle: Ort" },
|
||||
{ name: "baustelle_strasse", titel: "Baustelle: Straße", adresse: { plz: "baustelle_plz", ort: "baustelle_ort" } }, { name: "baustelle_plz", titel: "Baustelle: PLZ" }, { name: "baustelle_ort", titel: "Baustelle: Ort" },
|
||||
{ name: "vertragsart", titel: "Vertragsart", art: "auswahl", optionen: VERTRAGSARTEN }, { name: "abnahme_am", titel: "Abnahme am", art: "datum" },
|
||||
{ name: "umsatz_netto", titel: "Auftragswert 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" },
|
||||
// Kosten der Baustelle als eine Zeile (Henning, 08.11.2026); intern bleibt die Aufteilung für Liquidität und Nachkalkulation
|
||||
{ name: "umsatz_netto", titel: "Auftragswert netto", art: "euro" }, { name: "kosten", titel: "Kosten der Baustelle", art: "euro" },
|
||||
{ name: "notiz", titel: "Beschreibung", art: "langtext" },
|
||||
];
|
||||
}
|
||||
const BETRAEGE = ["umsatz_netto", "material_kosten", "fremd_kosten", "sonstige_kosten"];
|
||||
const ohneNull = (d: Zeile) => ({ ...d, ...Object.fromEntries(BETRAEGE.map((k) => [k, d[k] ?? 0])) });
|
||||
const kostenSumme = (z: Zeile) => z.material_kosten + z.fremd_kosten + z.sonstige_kosten;
|
||||
/** Projekt für den Dialog: die drei Kostenarten als eine Summe */
|
||||
const mitKosten = (p: Zeile) => ({ ...p, kosten: kostenSumme(p) });
|
||||
/** Summe aus dem Dialog zurück auf die drei Kostenarten, im bisherigen Verhältnis (ohne bisherige Kosten: alles Material) */
|
||||
function kostenAufteilen(d: Zeile, alt?: Zeile): Zeile {
|
||||
const { kosten, ...rest } = d;
|
||||
const k = kostenSetzen(alt ? eckVon(alt) : { umsatz: 0, material: 0, fremd: 0, sonstige: 0, personen: null, tage: null, stunden: null }, Number(kosten ?? 0));
|
||||
return { ...rest, material_kosten: k.material, fremd_kosten: k.fremd, sonstige_kosten: k.sonstige };
|
||||
}
|
||||
const eckVon = (p: Zeile): Eckdaten => ({ umsatz: p.umsatz_netto, material: p.material_kosten, fremd: p.fremd_kosten, sonstige: p.sonstige_kosten,
|
||||
personen: p.personen === null || p.personen === undefined ? null : Number(p.personen), tage: p.soll_tage === null || p.soll_tage === undefined ? null : Number(p.soll_tage),
|
||||
stunden: p.soll_stunden === null || p.soll_stunden === undefined ? null : Number(p.soll_stunden) });
|
||||
@@ -122,7 +136,7 @@ async function projekte(): Promise<void> {
|
||||
});
|
||||
const e = await offen;
|
||||
if (e?.aktion !== "speichern") return;
|
||||
const p = await api<Zeile>("projekte", "POST", ohneNull(e.daten));
|
||||
const p = await api<Zeile>("projekte", "POST", ohneNull(kostenAufteilen(e.daten)));
|
||||
if (p.ordner_fehler) hinweis.text = p.ordner_fehler;
|
||||
location.hash = `projekt-${p.id}`;
|
||||
};
|
||||
@@ -286,8 +300,6 @@ async function projektSeite(id: string): Promise<void> {
|
||||
<div class="eck-zeile">${feld("umsatz", "Auftragswert netto", formatEuro(p.umsatz_netto, false), "euro", "€")}<span class="eck-op">−</span>
|
||||
${feld("kosten", "Kosten", formatEuro(kostenSumme(p), false), "euro", "€")}<span class="eck-op">=</span>
|
||||
${feld("ro-euro", "Rohertrag", formatEuro(ro.euro, false), "euro", "€", "rohertrag")}${feld("ro-prozent", "in %", ro.prozent === null ? "" : zahlText(Math.round(ro.prozent * 10) / 10), "zahl", "%", "rohertrag")}</div>
|
||||
<div class="eck-zeile eck-teile"><span class="eck-op">Kosten aus</span>${feld("material", "Material", formatEuro(p.material_kosten, false), "euro", "€")}<span class="eck-op">+</span>
|
||||
${feld("fremd", "Fremdleistung", formatEuro(p.fremd_kosten, false), "euro", "€")}<span class="eck-op">+</span>${feld("sonstige", "Sonstiges", formatEuro(p.sonstige_kosten, false), "euro", "€")}</div>
|
||||
<div class="eck-zeile">${feld("personen", "Personen", zahlText(p.personen), "zahl", "")}<span class="eck-op">×</span>${feld("tage", "Arbeitstage", zahlText(p.soll_tage), "zahl", "AT")}
|
||||
<span class="eck-op">× ${zahlText(einst?.stundenProTag ?? 8)} Std. =</span>${feld("stunden", "Soll-Stunden", zahlText(p.soll_stunden), "zahl", "Std.")}</div>
|
||||
<p class="hinweis">${eigeneZahlungen.length ? `${eigeneZahlungen.length} ${eigeneZahlungen.length === 1 ? "Rate" : "Raten"} im <button class="verweis" data-teil="zahlungen">Zahlungsplan</button>${p.zahlungsplan === "auto" ? ", passen sich an" : ""}` : "Mit dem Auftragswert und Terminen entsteht der Zahlungsplan."}</p></section>`;
|
||||
@@ -681,10 +693,10 @@ async function projektSeite(id: string): Promise<void> {
|
||||
if (a === "bearbeiten") {
|
||||
// am Handy lässt sich kein Projekt löschen (Henning, 22.10.2026)
|
||||
const [felder, alle] = await Promise.all([projektFelder(), api<Zeile[]>("projekte")]);
|
||||
const e = await dialog("Projekt bearbeiten", felder.map((f) => (f.name === "nummer" ? { ...f, hilfe: NUMMER_HILFE } : f)), p, !istHandy(), nummerPruefung(alle, p.id));
|
||||
const e = await dialog("Projekt bearbeiten", felder.map((f) => (f.name === "nummer" ? { ...f, hilfe: NUMMER_HILFE } : f)), mitKosten(p), !istHandy(), nummerPruefung(alle, p.id));
|
||||
if (!e) return;
|
||||
if (e.aktion === "loeschen") { await api(`projekte/${id}`, "DELETE"); location.hash = "projekte"; return; }
|
||||
const r = await api<Zeile>(`projekte/${id}`, "PATCH", ohneNull(e.daten));
|
||||
const r = await api<Zeile>(`projekte/${id}`, "PATCH", ohneNull(kostenAufteilen(e.daten, p)));
|
||||
if (r.ordner_fehler) hinweis.text = r.ordner_fehler;
|
||||
return neuLaden();
|
||||
}
|
||||
@@ -1065,7 +1077,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 +1126,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 +1260,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 +1274,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];
|
||||
@@ -1524,6 +1594,7 @@ async function zeige(): Promise<void> {
|
||||
if (treffer?.[2]) projektTeil = treffer[2];
|
||||
const reiter = REITER.find(([r]) => r === (zuProjekte ? "projekte" : zuPersonal ? "personal" : zuStamm ? "stammdaten" : id)) ?? REITER[0]!;
|
||||
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0]));
|
||||
inhalt.dataset.reiter = reiter[0];
|
||||
const imUnten = !!unten.querySelector(`[data-r="${reiter[0]}"]`);
|
||||
unten.querySelectorAll<HTMLElement>("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0] || (!imUnten && b.dataset.r === "mehr")));
|
||||
try {
|
||||
|
||||
@@ -109,6 +109,15 @@ td.zahl { white-space: nowrap; }
|
||||
.dialog input, .dialog select, .dialog textarea, .vorlage-tabelle input, .vorlage-tabelle select { width: 100%; padding: 9px 10px; border: 1px solid var(--linie); border-radius: 8px; background: var(--fl); color: var(--text); font: inherit; }
|
||||
.dialog input:focus, .dialog select:focus, .dialog textarea:focus { outline: 2px solid var(--akzent-hell); border-color: var(--akzent); }
|
||||
.dialog .knoepfe { display: flex; justify-content: flex-end; gap: 8px; margin-top: 18px; }
|
||||
/* Adressvorschläge unter dem Straßenfeld (0.45) */
|
||||
.adr-feld { position: relative; }
|
||||
.adr-liste { position: absolute; z-index: 5; left: 0; right: 0; top: calc(100% + 4px); background: var(--fl); border: 1px solid var(--linie); border-radius: 8px; box-shadow: 0 8px 24px rgb(0 0 0 / 0.16); padding: 4px; max-height: 300px; overflow: auto; }
|
||||
.adr-liste button { display: flex; justify-content: space-between; align-items: baseline; gap: 10px; width: 100%; text-align: left; background: none; border: 0; border-radius: 6px; padding: 7px 8px; font: inherit; color: var(--text); cursor: pointer; }
|
||||
.adr-liste button:hover, .adr-liste button.aktiv { background: var(--akzent-hell); }
|
||||
.adr-text { min-width: 0; }
|
||||
.adr-text small { display: block; color: var(--leise); font-size: 12px; }
|
||||
.adr-quelle { flex: none; max-width: 45%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 12px; color: var(--leise); }
|
||||
.adr-fuss { margin: 4px 8px 2px; font-size: 11px; color: var(--leise); }
|
||||
.dialog .knoepfe .links { margin-right: auto; }
|
||||
|
||||
/* Schmale Bildschirme: Leiste oben, waagerecht scrollbar */
|
||||
@@ -520,8 +529,6 @@ tr.ueber .tag-ueber { background: var(--fl); }
|
||||
.eck-eingabe input[data-e="stunden"] { width: 5em; }
|
||||
.eck-feld.gerechnet .eck-eingabe { background: var(--akzent-hell); border-style: dashed; }
|
||||
.eck-op { padding-bottom: 7px; color: var(--leise); }
|
||||
.eck-teile { padding-left: 12px; border-left: 2px solid var(--linie); }
|
||||
.eck-teile .eck-eingabe input { width: 6.5em; }
|
||||
.kachel.beschreibung .text { flex: 1; white-space: pre-wrap; overflow-wrap: anywhere; cursor: text; border-radius: 6px; padding: 4px; margin: -4px; min-height: 40px; max-height: 7.5em; overflow: auto; }
|
||||
.kachel.beschreibung .text:hover { background: var(--akzent-hell); }
|
||||
.kachel.beschreibung textarea { width: 100%; padding: 8px; border: 1px solid var(--akzent); border-radius: 6px; background: var(--fl); color: var(--text); font: inherit; }
|
||||
@@ -1382,6 +1389,8 @@ textarea.am-fliess::placeholder { color: var(--leise); font-style: italic; }
|
||||
.am-blatt .am-zeile.titel .gb { display: block; }
|
||||
.am-blatt .am-zeile.am-textzeile { grid-template-columns: 58px minmax(0, 1fr) 26px; }
|
||||
}
|
||||
/* Projekte nutzen die ganze Bildschirmbreite (Henning, 08.11.2026) */
|
||||
main[data-reiter="projekte"] { max-width: none; }
|
||||
main:has(.am-blatt) { max-width: 1560px; }
|
||||
main:has(.gantt) { max-width: none; }
|
||||
.am-blatt .am-zeile.kopfzeile { font-size: 11.5px; text-transform: uppercase; letter-spacing: .04em; background: var(--titel-bg); border-bottom: 2px solid var(--linie); }
|
||||
@@ -2040,3 +2049,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; }
|
||||
|
||||
@@ -104,6 +104,8 @@ export interface Feld {
|
||||
/** Umschaltknopf rechts neben einer Auswahl, z. B. vor | nach (Henning, 26.10.2026); Titel und Hinweis wechseln mit,
|
||||
* der Wert landet unter `name` in den Daten; ohne gewählten Eintrag ist der Knopf verborgen */
|
||||
umschalter?: { name: string; optionen: [string, string][]; titel?: Record<string, string>; hilfe?: Record<string, string> };
|
||||
/** Straßenfeld mit Adressvorschlägen beim Tippen; füllt die genannten Felder für PLZ und Ort mit (Henning, 08.11.2026) */
|
||||
adresse?: { plz: string; ort: string };
|
||||
}
|
||||
export const NEU = "__neu";
|
||||
|
||||
@@ -149,7 +151,8 @@ export function dialog(titel: string, felder: Feld[], werte: Zeile, mitLoeschen:
|
||||
} else {
|
||||
const typ = f.art === "datum" ? "date" : f.art === "passwort" ? "password" : "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"' : ""}${f.art === "passwort" ? ' autocomplete="new-password"' : ""}>`;
|
||||
eingabe = `<input id="${id}" type="${typ}" value="${esc(anzeige)}"${f.art === "euro" || f.art === "zahl" ? ' inputmode="decimal"' : ""}${f.art === "passwort" ? ' autocomplete="new-password"' : ""}${f.adresse ? ' autocomplete="off" role="combobox" aria-autocomplete="list" aria-expanded="false"' : ""}>`;
|
||||
if (f.adresse) eingabe = `<div class="adr-feld">${eingabe}<div class="adr-liste" role="listbox" hidden></div></div>`;
|
||||
}
|
||||
const an = f.umschalter ? werte[f.umschalter.name] ?? f.umschalter.optionen[0]![0] : "";
|
||||
const titelText = f.umschalter?.titel?.[an] ?? f.titel, hilfe = (v && f.umschalter?.hilfe?.[an]) || f.hilfe;
|
||||
@@ -171,6 +174,7 @@ export function dialog(titel: string, felder: Feld[], werte: Zeile, mitLoeschen:
|
||||
document.addEventListener("keydown", taste);
|
||||
(form.querySelector("input,select,textarea") as HTMLElement | null)?.focus();
|
||||
for (const f of felder) if (f.bearbeiten) bearbeitbareAuswahl(form.querySelector(`#f-${f.name}`)!, f.bearbeiten);
|
||||
for (const f of felder) if (f.adresse) adressVorschlaege(form, f.name, f.adresse);
|
||||
// Umschaltknopf: Wahl merken, Titel und Hinweis mitziehen; ohne Auswahl verborgen
|
||||
const umWert = new Map<string, string>();
|
||||
for (const f of felder) {
|
||||
@@ -329,3 +333,75 @@ export function seite(titel: string, knopf?: { text: string; aktion: () => void
|
||||
return leiste;
|
||||
}
|
||||
|
||||
|
||||
interface Adressvorschlag { strasse: string; plz: string; ort: string; titel: string; quelle: "kontakt" | "projekt" | "karte" }
|
||||
const QUELLE: Record<Adressvorschlag["quelle"], string> = { kontakt: "Kontakt", projekt: "Projekt", karte: "Karte" };
|
||||
|
||||
/**
|
||||
* Adressvorschläge unter dem Straßenfeld: erst eigene Kontakte und Projekte, dann OpenStreetMap.
|
||||
* Pfeiltasten wählen, Enter übernimmt, Esc schließt nur die Liste.
|
||||
*/
|
||||
export function adressVorschlaege(form: HTMLElement, name: string, ziel: { plz: string; ort: string }): void {
|
||||
const feld = form.querySelector<HTMLInputElement>(`#f-${name}`);
|
||||
const liste = feld?.parentElement?.querySelector<HTMLElement>(".adr-liste");
|
||||
if (!feld || !liste) return;
|
||||
let treffer: Adressvorschlag[] = [];
|
||||
let aktiv = -1, zaehler = 0, uhr: ReturnType<typeof setTimeout> | undefined;
|
||||
const zu = () => { liste.hidden = true; feld.setAttribute("aria-expanded", "false"); aktiv = -1; };
|
||||
const zeichnen = () => {
|
||||
if (!treffer.length) return zu();
|
||||
const karte = treffer.some((t) => t.quelle === "karte");
|
||||
liste.innerHTML = treffer.map((t, i) => `<button type="button" role="option" data-i="${i}" aria-selected="${i === aktiv}"${i === aktiv ? ' class="aktiv"' : ""}>
|
||||
<span class="adr-text">${esc(t.strasse)}<small>${esc([t.plz, t.ort].filter(Boolean).join(" "))}</small></span>
|
||||
<span class="adr-quelle">${esc(QUELLE[t.quelle])}${t.titel && t.quelle !== "karte" ? `: ${esc(t.titel)}` : ""}</span></button>`).join("")
|
||||
+ (karte ? '<p class="adr-fuss">Kartenvorschläge: © OpenStreetMap-Mitwirkende</p>' : "");
|
||||
liste.hidden = false;
|
||||
feld.setAttribute("aria-expanded", "true");
|
||||
};
|
||||
const setze = (id: string, wert: string) => {
|
||||
const el = form.querySelector<HTMLInputElement>(`#f-${id}`);
|
||||
if (!el || !wert) return;
|
||||
el.value = wert;
|
||||
el.dispatchEvent(new Event("input", { bubbles: true }));
|
||||
};
|
||||
const nehmen = (i: number) => {
|
||||
const t = treffer[i];
|
||||
if (!t) return;
|
||||
feld.value = t.strasse;
|
||||
feld.dispatchEvent(new Event("change", { bubbles: true }));
|
||||
setze(ziel.plz, t.plz);
|
||||
setze(ziel.ort, t.ort);
|
||||
treffer = [];
|
||||
zu();
|
||||
};
|
||||
feld.addEventListener("input", () => {
|
||||
clearTimeout(uhr);
|
||||
const q = feld.value.trim();
|
||||
if (q.length < 2) { treffer = []; return zu(); }
|
||||
uhr = setTimeout(async () => {
|
||||
const nr = ++zaehler;
|
||||
try {
|
||||
const r = await api<{ treffer: Adressvorschlag[] }>(`adressen?q=${encodeURIComponent(q)}`);
|
||||
if (nr !== zaehler || document.activeElement !== feld) return;
|
||||
treffer = r.treffer; aktiv = -1; zeichnen();
|
||||
} catch { /* ohne Vorschläge weiter tippen */ }
|
||||
}, 300);
|
||||
});
|
||||
feld.addEventListener("keydown", (ev) => {
|
||||
if (liste.hidden) return;
|
||||
if (ev.key === "ArrowDown" || ev.key === "ArrowUp") {
|
||||
ev.preventDefault();
|
||||
aktiv = (aktiv + (ev.key === "ArrowDown" ? 1 : -1) + treffer.length) % treffer.length;
|
||||
zeichnen();
|
||||
} else if (ev.key === "Enter" && aktiv >= 0) { ev.preventDefault(); nehmen(aktiv); }
|
||||
else if (ev.key === "Escape") { ev.stopPropagation(); zu(); }
|
||||
});
|
||||
feld.addEventListener("blur", () => setTimeout(zu, 150));
|
||||
// mousedown statt click, damit das Feld den Fokus nicht vorher verliert
|
||||
liste.addEventListener("mousedown", (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-i]");
|
||||
if (!b) return;
|
||||
ev.preventDefault();
|
||||
nehmen(Number(b.dataset.i));
|
||||
});
|
||||
}
|
||||
|
||||
@@ -139,6 +139,39 @@ describe.skipIf(!url)("API mit Datenbank", () => {
|
||||
expect(Object.keys(j.daten)).toContain("vorgaenge");
|
||||
expect(j.daten.kontakte.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("schlägt Adressen aus Kontakten, Projekten und der Karte vor", async () => {
|
||||
await anlegen("kontakte", { name: "Adr Kunde", rolle: "bauherr", strasse: "Lindenweg 4", plz: "23909", ort: "Ratzeburg" });
|
||||
await anlegen("projekte", { nummer: "P-26-901", bezeichnung: "Adr Carport", status: "auftrag", baustelle_strasse: "Lindenweg 12", baustelle_plz: "23909", baustelle_ort: "Ratzeburg" });
|
||||
const gefragt: string[] = [];
|
||||
const abruf = (async (u: URL) => {
|
||||
gefragt.push(String(u));
|
||||
return new Response(JSON.stringify({ features: [
|
||||
{ properties: { street: "Lindenweg", housenumber: "4", postcode: "23909", city: "Ratzeburg" } },
|
||||
{ properties: { street: "Lindenweg", housenumber: "20", postcode: "23911", city: "Mölln", name: "Bäckerei" } },
|
||||
{ properties: { name: "Ratzeburg", osm_key: "place" } },
|
||||
] }), { headers: { "content-type": "application/json" } });
|
||||
}) as unknown as typeof fetch;
|
||||
const t = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion", adressKarte: abruf });
|
||||
try {
|
||||
const r = await t.inject({ method: "GET", url: "/api/adressen?q=linden%20ratz", headers: { "x-benutzer": "henning" } });
|
||||
expect(r.statusCode, r.body).toBe(200);
|
||||
const tr = r.json().treffer as { strasse: string; quelle: string; titel: string; plz: string }[];
|
||||
// eigene zuerst, Lindenweg 4 aus der Karte nicht doppelt, Orte ohne Straße fallen weg
|
||||
expect(tr.map((x) => `${x.quelle}:${x.strasse}`)).toEqual(["kontakt:Lindenweg 4", "projekt:Lindenweg 12", "karte:Lindenweg 20"]);
|
||||
expect(tr[2]).toMatchObject({ plz: "23911", titel: "Bäckerei" });
|
||||
expect(gefragt[0]).toContain("q=linden+ratz");
|
||||
// zu kurz: nichts, auch keine Anfrage an die Karte
|
||||
expect((await t.inject({ method: "GET", url: "/api/adressen?q=l", headers: { "x-benutzer": "henning" } })).json()).toEqual({ treffer: [] });
|
||||
expect(gefragt).toHaveLength(1);
|
||||
} finally { await t.close(); }
|
||||
// Karte nicht erreichbar: eigene Vorschläge kommen trotzdem
|
||||
const kaputt = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion", adressKarte: (async () => { throw new Error("offline"); }) as unknown as typeof fetch });
|
||||
try {
|
||||
const r = await kaputt.inject({ method: "GET", url: "/api/adressen?q=lindenweg", headers: { "x-benutzer": "henning" } });
|
||||
expect(r.json().treffer.map((x: { quelle: string }) => x.quelle)).toEqual(["kontakt", "projekt"]);
|
||||
} finally { await kaputt.close(); }
|
||||
});
|
||||
});
|
||||
|
||||
describe.skipIf(!url)("Übernahme aus V70 über die API", () => {
|
||||
|
||||
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