Compare commits
8 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
cfa656e98f | ||
|
|
2c1d571c94 | ||
|
|
82da397c96 | ||
|
|
3e8abd0eeb | ||
|
|
647e0905d9 | ||
|
|
a384bc3409 | ||
|
|
c68fadbc60 | ||
|
|
7e18b7f4de |
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
|
||||
|
||||
47
CHANGELOG.md
47
CHANGELOG.md
@@ -2,6 +2,53 @@
|
||||
|
||||
Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen.
|
||||
|
||||
## 0.49.0 (08.11.2026)
|
||||
|
||||
- Angebote und weitere Dokumente: Der Empfänger steht als vollständige Anschrift. Ist der Kunde eine Firma, Behörde oder WEG, kommt darunter „z. Hd. Herrn/Frau Titel Name“: der Ansprechpartner mit „Haupt“ im Projekt, sonst der Hauptansprechpartner (★) des Kunden. Personen stehen als „Herrn Dipl.-Ing. Jan Petersen“.
|
||||
- Angebote: Über der Einleitung steht die Briefanrede. Bei Ehepaar und Familie heißt sie „Sehr geehrte Frau X, sehr geehrter Herr X“ aus den Ansprechpartnern mit Anrede, bei einer Person kommt sie aus Anrede und Titel. Bei Firma oder Behörde ist sie persönlich an den z. Hd.-Ansprechpartner gerichtet, sonst „Sehr geehrte Damen und Herren“. Nach dem Versand gilt der festgeschriebene Stand.
|
||||
- Projekte: „Rechnungsanschrift“ in der Kachel Kunde zeigt Anschrift und Anrede für die Rechnung zum Kopieren ins Rechnungsprogramm. Dafür gelten die Rechnungsadresse des Kunden und der Ansprechpartner „Rechnungen“, sonst „Haupt“.
|
||||
|
||||
## 0.48.0 (08.11.2026)
|
||||
|
||||
- Projekte: Priorität A (zuerst), B (normal), C (Lückenfüller). Das Programm schlägt sie aus drei Punkten je 0–2 vor: Ertrag (Rohertrag je Stunde im Vergleich zum Schnitt aller Projekte, aus Auftragswert, Kosten und Soll-Stunden oder aus dem kalkulierten Angebot), Kunde (neu, Stammkunde, empfiehlt weiter) und Dringlichkeit (Frist, Vertragsstrafe, Bindefrist eines versendeten Angebots, witterungsabhängig vor dem Winter). 5–6 Punkte A, 3–4 B, 0–2 C.
|
||||
- Projekte: Die Priorität steht farbig in der Projektliste (sortier- und filterbar), auf der Projektseite neben dem Status mit der Begründung darunter und im Terminplan vor dem Projektnamen, dort auch als Filter. Auf der Projektseite oder im Projekt-Dialog lässt sie sich selbst setzen; selbst gesetzt hat die Marke einen Rand.
|
||||
- Projekte: Neue Felder „Fertig bis (Frist)“ und „Termindruck“ (witterungsabhängig, fester Termin / Vertragsstrafe).
|
||||
- Kontakte: Haken „Empfiehlt uns weiter (Multiplikator)“, z. B. für Architekten oder Hausverwaltungen; zählt bei der Priorität.
|
||||
|
||||
## 0.47.0 (08.11.2026)
|
||||
|
||||
- Kontakte: Neue Kontaktmaske wie in der Nextcloud. Name, Anrede, Titel und Firma oben; Telefon, E-Mail und Adresse beliebig oft, je mit Typ (Mobil, Privat, Geschäftlich, Zentrale, Rechnungen, Fax, Sonstige) und einem Haupteintrag (★). Die Adresse hat Straße, Zusatz, PLZ, Ort, Bundesland, Land und ein ausklappbares Postfach. Rechts stehen „Gehört zu“, Rollen, Projekte und der Handy-Stand.
|
||||
- Kontakte: Übergeordnete Kontakte für Firmen, Behörden, Familien, Ehepaare und Eigentümergemeinschaften, mit eigenen Nummern und Adressen. Ansprechpartner sind Personen mit Funktion und Zuständigkeit (Haupt, Rechnungen, Baustelle, Planung); eine Person kann zu mehreren gehören. Neu über „Neue Firma / Familie“.
|
||||
- Kontakte: Rollen frei anlegen, umbenennen und löschen wie die Aufgaben-Kategorien, mehrere je Kontakt. Subunternehmer bleibt fest; Mitarbeiter wird nur auf der Mitarbeiterseite gesetzt.
|
||||
- Projekte: Kunde kann ein übergeordneter Kontakt oder eine Person sein. Mehrere Ansprechpartner je Projekt, die Leute des Kunden stehen beim Hinzufügen oben. Mitarbeiter sehen am Handy nur den Ansprechpartner für die Baustelle.
|
||||
- Handy: Kontakte öffnen sich als Ansicht mit Anrufen, SMS, E-Mail und Navi; „Bearbeiten“ öffnet die Maske.
|
||||
- Handy-Abgleich: Eine Karte je Person mit allen Nummern, E-Mails und Adressen samt Typ; Anrede, Titel, Funktion und Notizen gehen mit. Als Firma steht der erste übergeordnete Kontakt in der Karte. Eine Firma aus dem Handy, die es schon gibt, wird zugeordnet; sonst schlägt die Maske „Firma anlegen?“ vor. Übergeordnete Kontakte mit eigener Nummer oder E-Mail bekommen eine eigene Firmenkarte. Beim ersten Abgleich nach dem Update werden Programm und Handy einmal zusammengeführt, keine Nummer geht verloren.
|
||||
- Vorhandene Kontakte werden übernommen: Telefon, Mobil, E-Mail und Adresse werden zu Listeneinträgen, die Rolle zur ersten Rolle. Die Kontaktliste bleibt, wie sie war.
|
||||
|
||||
## 0.46.0 (08.11.2026)
|
||||
|
||||
- Personal: „Neuer Mitarbeiter“ wählt den Mitarbeiter aus den vorhandenen Kontakten, wie den Kunden im Projekt; „+ Neuer Kontakt …“ legt einen neuen an. Der gewählte Kontakt wird zum Mitarbeiter.
|
||||
- Personal: Die Mitarbeiterseite zeigt Telefon, Mobil, E-Mail und Adresse aus dem Kontakt und lässt sie dort bearbeiten.
|
||||
|
||||
## 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).
|
||||
|
||||
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; ein Reverse Proxy (HAProxy) mit TLS leitet Produktion und Test an die Ports aus `.env` weiter.
|
||||
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 (`docker compose up -d`). HTTPS macht der vorhandene HAProxy; er erreicht die Apps an `APP_ADRESSE:APP_PORT` und `APP_ADRESSE:TEST_PORT` und setzt `X-Forwarded-Proto: https`.
|
||||
3. `cd deploy && ./update.sh 0.49.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.
|
||||
|
||||
@@ -30,6 +30,8 @@ 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";
|
||||
import m029 from "../src/server/migrations/029_kontakte_neu.sql";
|
||||
import m030 from "../src/server/migrations/030_prioritaet.sql";
|
||||
|
||||
const MIGRATIONEN: [string, string][] = [
|
||||
["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004],
|
||||
@@ -55,6 +57,8 @@ const MIGRATIONEN: [string, string][] = [
|
||||
["026_zahlung_bezahlt.sql", m026],
|
||||
["027_zaehlt.sql", m027],
|
||||
["028_kontakte_abgleich.sql", m028],
|
||||
["029_kontakte_neu.sql", m029],
|
||||
["030_prioritaet.sql", m030],
|
||||
];
|
||||
|
||||
export async function starte(db: PGlite, v70?: unknown) {
|
||||
|
||||
@@ -1,21 +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
|
||||
# Hier lauschen die Apps für den HAProxy (Adresse des Docker-Rechners im VPN)
|
||||
APP_VERSION=0.49.0
|
||||
# Hier lauscht das Programm für den HAProxy (Adresse des Docker-Rechners im VPN)
|
||||
APP_ADRESSE=100.64.0.8
|
||||
APP_PORT=33181
|
||||
TEST_PORT=33182
|
||||
# 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,45 +1,12 @@
|
||||
# Betrieb auf dem Server: Produktion und Testumgebung nebeneinander,
|
||||
# jede mit eigener Datenbank und eigener Sicherung. TLS macht Hennings HAProxy (Henning, 04.11.2026):
|
||||
# er erreicht die Apps über das VPN an APP_ADRESSE:APP_PORT bzw. TEST_PORT.
|
||||
# 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:5432/betrieb
|
||||
@@ -50,48 +17,41 @@ services:
|
||||
NEXTCLOUD_PASSWORT: ${NEXTCLOUD_PASSWORT:-}
|
||||
depends_on:
|
||||
db: { condition: service_healthy }
|
||||
networks: [intern]
|
||||
|
||||
db:
|
||||
<<: *db
|
||||
volumes: [db:/var/lib/postgresql/data]
|
||||
backup:
|
||||
<<: *backup
|
||||
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:
|
||||
<<: *backup-env
|
||||
PGHOST: db
|
||||
PGUSER: betrieb
|
||||
PGPASSWORD: ${DB_PASSWORT}
|
||||
PGDATABASE: betrieb
|
||||
NAME: produktion
|
||||
volumes: [sicherungen:/sicherungen]
|
||||
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 }
|
||||
|
||||
app-test:
|
||||
<<: *app
|
||||
image: ${IMAGE}:${TEST_VERSION}
|
||||
ports: ["${APP_ADRESSE:-100.64.0.8}:${TEST_PORT:-33182}:3000"]
|
||||
environment:
|
||||
DATABASE_URL: postgres://betrieb@db-test:5432/betrieb
|
||||
PGPASSWORD: ${DB_PASSWORT}
|
||||
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 }
|
||||
|
||||
volumes:
|
||||
db:
|
||||
db-test:
|
||||
sicherungen:
|
||||
sicherungen-test:
|
||||
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 --remove-orphans "$app" "$backup"
|
||||
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.44.2",
|
||||
"version": "0.49.0",
|
||||
"private": true,
|
||||
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
|
||||
"type": "module",
|
||||
|
||||
105
src/domain/brief.ts
Normal file
105
src/domain/brief.ts
Normal file
@@ -0,0 +1,105 @@
|
||||
// Anschrift mit „z. Hd.“ und Briefanrede (Henning, 08.11.2026) für Angebote, Kostenvoranschläge und die
|
||||
// Rechnungsanschrift. Kunde ist eine Person oder ein übergeordneter Kontakt (Firma, Behörde, Familie, Ehepaar, WEG).
|
||||
import type { Anschrift } from "./kontaktdaten.js";
|
||||
|
||||
export interface BriefKontakt {
|
||||
name: string;
|
||||
anrede?: string | null;
|
||||
titel?: string | null;
|
||||
/** null: Person */
|
||||
art?: string | null;
|
||||
/** frei eingetragene Firma einer Person */
|
||||
firma?: string | null;
|
||||
adressen?: Anschrift[] | null;
|
||||
}
|
||||
/** Ein Mensch, der zum Kunden oder zum Projekt gehört, mit seinen Zuständigkeiten (haupt, rechnungen, baustelle, planung) */
|
||||
export interface BriefPerson {
|
||||
kontakt: BriefKontakt;
|
||||
/** Ansprechpartner im Projekt: Zuständigkeiten dort; null: nicht im Projekt eingetragen */
|
||||
imProjekt: string[] | null;
|
||||
/** Ansprechpartner des Kunden (übergeordneter Kontakt): Zuständigkeiten dort; null: gehört nicht dazu */
|
||||
imKunden: string[] | null;
|
||||
}
|
||||
export interface Empfaenger {
|
||||
/** Anschriftzeilen, die erste ist der Name */
|
||||
zeilen: string[];
|
||||
/** „z. Hd. Herrn Dipl.-Ing. Jan Petersen“ oder null */
|
||||
zHd: string | null;
|
||||
/** „Sehr geehrter Herr Petersen,“ */
|
||||
anrede: string;
|
||||
}
|
||||
|
||||
/** z. Hd. nur bei Firmen, Behörden und Eigentümergemeinschaften; Familie und Ehepaar stehen schon mit Namen in der Anschrift */
|
||||
const MIT_ZHD = new Set(["firma", "behoerde", "weg"]);
|
||||
const DAMEN_HERREN = "Sehr geehrte Damen und Herren,";
|
||||
|
||||
const t = (s: string | null | undefined) => (s ?? "").trim();
|
||||
/** Nachname: letztes Wort, „Petersen“ aus „Jan Petersen“ */
|
||||
export const nachname = (name: string) => t(name).split(/\s+/).at(-1) ?? "";
|
||||
|
||||
/** „Herrn Dr. Jan Petersen“, „Frau Anna Petersen“, „Familie Petersen“ */
|
||||
export function anschriftName(k: BriefKontakt): string {
|
||||
const a = t(k.anrede);
|
||||
const vor = a === "Herr" ? "Herrn" : a === "Frau" ? "Frau" : "";
|
||||
if (a === "Familie" || a === "Eheleute") return `${a} ${nachname(k.name)}`;
|
||||
return [vor, t(k.titel), t(k.name)].filter(Boolean).join(" ");
|
||||
}
|
||||
|
||||
/** „Sehr geehrter Herr Dr. Petersen,“ – ohne passende Anrede null */
|
||||
export function persoenlicheAnrede(k: BriefKontakt): string | null {
|
||||
const a = t(k.anrede), n = [t(k.titel), nachname(k.name)].filter(Boolean).join(" ");
|
||||
if (!nachname(k.name)) return null;
|
||||
if (a === "Herr") return `Sehr geehrter Herr ${n},`;
|
||||
if (a === "Frau") return `Sehr geehrte Frau ${n},`;
|
||||
if (a === "Familie") return `Sehr geehrte Familie ${nachname(k.name)},`;
|
||||
if (a === "Eheleute") return `Sehr geehrte Eheleute ${nachname(k.name)},`;
|
||||
return null;
|
||||
}
|
||||
|
||||
/** Adresse für den Zweck: zur Rechnung die Rechnungsadresse, sonst die Hauptadresse */
|
||||
function adresse(k: BriefKontakt, zweck: "angebot" | "rechnung"): string[] {
|
||||
const l = (k.adressen ?? []).filter((a) => t(a.strasse) || t(a.plz) || t(a.ort) || t(a.postfach));
|
||||
const a = (zweck === "rechnung" ? l.find((x) => x.typ === "rechnung") : undefined) ?? l.find((x) => x.haupt) ?? l[0];
|
||||
if (!a) return [];
|
||||
const land = t(a.land);
|
||||
return [
|
||||
t(a.postfach) && !t(a.strasse) ? t(a.postfach) : t(a.strasse), t(a.zusatz),
|
||||
[t(a.plz), t(a.ort)].filter(Boolean).join(" "),
|
||||
land && !/^(deutschland|germany|de|d)$/i.test(land) ? land.toUpperCase() : "",
|
||||
].filter(Boolean);
|
||||
}
|
||||
|
||||
/** Wer bekommt das Schreiben persönlich: zuerst im Projekt, dann beim Kunden; zur Rechnung zuerst „Rechnungen“, dann „Haupt“ */
|
||||
function zuHaenden(leute: BriefPerson[], zweck: "angebot" | "rechnung"): BriefPerson | undefined {
|
||||
for (const z of zweck === "rechnung" ? ["rechnungen", "haupt"] : ["haupt"]) {
|
||||
const p = leute.find((x) => x.imProjekt?.includes(z)) ?? leute.find((x) => x.imKunden?.includes(z));
|
||||
if (p) return p;
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
export function empfaenger(kunde: BriefKontakt | null, leute: BriefPerson[], zweck: "angebot" | "rechnung" = "angebot"): Empfaenger {
|
||||
if (!kunde) return { zeilen: [], zHd: null, anrede: DAMEN_HERREN };
|
||||
const art = kunde.art ?? null;
|
||||
if (!art) {
|
||||
// Person: „Herrn Dr. Jan Petersen“, Anrede aus Anrede und Titel
|
||||
return { zeilen: [anschriftName(kunde), ...(t(kunde.firma) ? [t(kunde.firma)] : []), ...adresse(kunde, zweck)], zHd: null, anrede: persoenlicheAnrede(kunde) ?? DAMEN_HERREN };
|
||||
}
|
||||
if (art === "familie" || art === "ehepaar") {
|
||||
// „Sehr geehrte Frau X, sehr geehrter Herr X“ aus den Ansprechpartnern mit Anrede, Frauen zuerst
|
||||
const mit = leute.filter((p) => p.imKunden !== null && ["Frau", "Herr"].includes(t(p.kontakt.anrede)))
|
||||
.sort((a, b) => (t(a.kontakt.anrede) === "Frau" ? 0 : 1) - (t(b.kontakt.anrede) === "Frau" ? 0 : 1));
|
||||
const teile = mit.map((p) => persoenlicheAnrede(p.kontakt)!.replace(/,$/, ""));
|
||||
const anrede = teile.length
|
||||
? `${teile.map((x, i) => (i === 0 ? x : x.replace(/^Sehr/, "sehr"))).join(", ")},`
|
||||
: /^familie\s+\S/i.test(t(kunde.name)) ? `Sehr geehrte ${t(kunde.name)},` : DAMEN_HERREN;
|
||||
return { zeilen: [t(kunde.name), ...adresse(kunde, zweck)], zHd: null, anrede };
|
||||
}
|
||||
// Firma, Behörde, WEG: z. Hd. des Ansprechpartners, Anrede persönlich an ihn
|
||||
const p = MIT_ZHD.has(art) ? zuHaenden(leute, zweck) : undefined;
|
||||
const zHd = p ? `z. Hd. ${anschriftName(p.kontakt)}` : null;
|
||||
return {
|
||||
zeilen: [t(kunde.name), ...(zHd ? [zHd] : []), ...adresse(kunde, zweck)], zHd,
|
||||
anrede: (p && persoenlicheAnrede(p.kontakt)) ?? DAMEN_HERREN,
|
||||
};
|
||||
}
|
||||
108
src/domain/kontaktdaten.ts
Normal file
108
src/domain/kontaktdaten.ts
Normal file
@@ -0,0 +1,108 @@
|
||||
// Kontaktdaten wie in der Nextcloud (Henning, 08.11.2026): Telefon, E-Mail und Adresse beliebig oft, je mit Typ,
|
||||
// ein Eintrag als Haupteintrag (★). Die alten Einzelfelder telefon, mobil, email, strasse, plz, ort bleiben als
|
||||
// Haupteinträge in der Tabelle, damit Listen, Suche, Projektseite und Handy-Einsatz weiter einfach lesen können.
|
||||
|
||||
export interface Nummer { typ: string; wert: string; haupt?: boolean }
|
||||
export interface Anschrift {
|
||||
typ: string; strasse: string; zusatz?: string; plz: string; ort: string; region?: string; land?: string; postfach?: string; haupt?: boolean;
|
||||
}
|
||||
export interface Listen { telefone: Nummer[]; emails: Nummer[]; adressen: Anschrift[] }
|
||||
export interface Einzelfelder {
|
||||
telefon: string | null; mobil: string | null; email: string | null; strasse: string | null; plz: string | null; ort: string | null;
|
||||
}
|
||||
|
||||
export const TYP_TEXT: Record<string, string> = {
|
||||
mobil: "Mobil", privat: "Privat", geschaeftlich: "Geschäftlich", zentrale: "Zentrale", rechnung: "Rechnungen", fax: "Fax", sonstige: "Sonstige",
|
||||
};
|
||||
export const TELEFON_TYPEN = ["mobil", "privat", "geschaeftlich", "zentrale", "fax", "sonstige"];
|
||||
export const EMAIL_TYPEN = ["privat", "geschaeftlich", "rechnung", "sonstige"];
|
||||
export const ADRESS_TYPEN = ["privat", "geschaeftlich", "rechnung", "sonstige"];
|
||||
|
||||
/** Übergeordnete Kontakte */
|
||||
export const ARTEN: [string, string][] = [["firma", "Firma / Institution"], ["behoerde", "Behörde / Gemeinde"], ["familie", "Familie"], ["ehepaar", "Ehepaar"], ["weg", "Eigentümergemeinschaft (WEG)"]];
|
||||
export const ART_KURZ: Record<string, string> = { firma: "Firma", behoerde: "Behörde", familie: "Familie", ehepaar: "Ehepaar", weg: "WEG" };
|
||||
/** Wofür ein Ansprechpartner zuständig ist */
|
||||
export const ZUSTAENDIG: [string, string][] = [["haupt", "Haupt"], ["rechnungen", "Rechnungen"], ["baustelle", "Baustelle"], ["planung", "Planung"]];
|
||||
|
||||
const t = (s: unknown) => (typeof s === "string" ? s.trim() : "");
|
||||
const leer = (s: string) => (s ? s : null);
|
||||
|
||||
/** Leere Einträge weg, genau ein Haupteintrag je Liste (der erste markierte, sonst der erste) */
|
||||
function aufraeumen<T extends { haupt?: boolean }>(liste: T[], voll: (x: T) => boolean): T[] {
|
||||
const l = liste.filter(voll).map((x) => ({ ...x, haupt: !!x.haupt }));
|
||||
const i = Math.max(0, l.findIndex((x) => x.haupt));
|
||||
return l.map((x, j) => ({ ...x, haupt: j === i }));
|
||||
}
|
||||
|
||||
export function listenBereinigt(l: Partial<Listen>): Listen {
|
||||
const nr = (x: Nummer): Nummer => ({ typ: t(x.typ) || "sonstige", wert: t(x.wert), haupt: !!x.haupt });
|
||||
const adr = (x: Anschrift): Anschrift => ({
|
||||
typ: t(x.typ) || "sonstige", strasse: t(x.strasse), zusatz: t(x.zusatz), plz: t(x.plz), ort: t(x.ort), region: t(x.region), land: t(x.land), postfach: t(x.postfach), haupt: !!x.haupt,
|
||||
});
|
||||
return {
|
||||
telefone: aufraeumen((l.telefone ?? []).map(nr), (x) => !!x.wert),
|
||||
emails: aufraeumen((l.emails ?? []).map(nr), (x) => !!x.wert),
|
||||
adressen: aufraeumen((l.adressen ?? []).map(adr), (x) => !!(x.strasse || x.plz || x.ort || x.postfach)),
|
||||
};
|
||||
}
|
||||
|
||||
const haupt = <T extends { haupt?: boolean }>(l: T[]) => l.find((x) => x.haupt) ?? l[0];
|
||||
|
||||
/** Einzelfelder aus den Listen: Mobil = erste Mobilnummer, Telefon = Hauptnummer, sonst die erste andere */
|
||||
export function einzelfelder(l: Listen): Einzelfelder {
|
||||
const mobil = l.telefone.find((x) => x.typ === "mobil" && x.haupt) ?? l.telefone.find((x) => x.typ === "mobil");
|
||||
const andere = l.telefone.filter((x) => x !== mobil && x.typ !== "fax");
|
||||
const telefon = andere.find((x) => x.haupt) ?? andere[0];
|
||||
const a = haupt(l.adressen);
|
||||
return {
|
||||
telefon: leer(telefon?.wert ?? ""), mobil: leer(mobil?.wert ?? ""), email: leer(haupt(l.emails)?.wert ?? ""),
|
||||
strasse: leer(a?.strasse ?? ""), plz: leer(a?.plz ?? ""), ort: leer(a?.ort ?? ""),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Einzelfelder in vorhandene Listen einarbeiten, für Teile, die nur Einzelfelder schreiben (Kunde im Projekt anlegen,
|
||||
* Datei-Import). Nur die übergebenen Felder ändern etwas; null entfernt den passenden Eintrag.
|
||||
*/
|
||||
export function einarbeiten(l: Listen, f: Partial<Einzelfelder>, firma = false): Listen {
|
||||
const neu: Listen = { telefone: [...l.telefone], emails: [...l.emails], adressen: [...l.adressen] };
|
||||
const typ = firma ? "geschaeftlich" : "privat";
|
||||
const setze = (liste: Nummer[], finde: (x: Nummer) => boolean, wert: string | null | undefined, neuTyp: string) => {
|
||||
if (wert === undefined) return;
|
||||
const i = liste.findIndex(finde);
|
||||
if (!t(wert)) { if (i >= 0) liste.splice(i, 1); return; }
|
||||
if (i >= 0) liste[i] = { ...liste[i]!, wert: t(wert) };
|
||||
else liste.push({ typ: neuTyp, wert: t(wert), haupt: !liste.length });
|
||||
};
|
||||
const mobil = neu.telefone.find((x) => x.typ === "mobil" && x.haupt) ?? neu.telefone.find((x) => x.typ === "mobil");
|
||||
const andere = neu.telefone.filter((x) => x !== mobil && x.typ !== "fax");
|
||||
const tel = andere.find((x) => x.haupt) ?? andere[0];
|
||||
setze(neu.telefone, (x) => x === mobil, f.mobil, "mobil");
|
||||
setze(neu.telefone, (x) => x === tel, f.telefon, typ);
|
||||
setze(neu.emails, (x) => x === haupt(neu.emails), f.email, typ);
|
||||
if (f.strasse !== undefined || f.plz !== undefined || f.ort !== undefined) {
|
||||
const a = haupt(neu.adressen);
|
||||
const x: Anschrift = a ? { ...a } : { typ, strasse: "", zusatz: "", plz: "", ort: "", region: "", land: "", postfach: "", haupt: true };
|
||||
if (f.strasse !== undefined) { x.strasse = t(f.strasse); x.zusatz = ""; }
|
||||
if (f.plz !== undefined) x.plz = t(f.plz);
|
||||
if (f.ort !== undefined) x.ort = t(f.ort);
|
||||
if (a) neu.adressen[neu.adressen.indexOf(a)] = x; else neu.adressen.push(x);
|
||||
}
|
||||
return listenBereinigt(neu);
|
||||
}
|
||||
|
||||
/** Adresse in einer Zeile */
|
||||
export const adressZeile = (a: Pick<Anschrift, "strasse" | "zusatz" | "plz" | "ort"> | undefined) =>
|
||||
a ? [[a.strasse, a.zusatz].filter(Boolean).join(", "), [a.plz, a.ort].filter(Boolean).join(" ")].filter(Boolean).join(", ") : "";
|
||||
|
||||
/** Kürzel für den runden Platzhalter: JP für Jan Petersen, WN für Wohnbau Nord eG */
|
||||
export function kuerzel(name: string): string {
|
||||
const w = name.replace(/[^\p{L}\p{N}\s-]/gu, " ").split(/\s+/).filter((x) => x && !/^(eG|GmbH|AG|KG|e\.?V|mbH|und|&)$/i.test(x));
|
||||
return ((w[0]?.[0] ?? "") + (w.length > 1 ? w[w.length - 1]![0] : w[0]?.[1] ?? "")).toUpperCase() || "?";
|
||||
}
|
||||
|
||||
/** Rollen-Kennung aus einem Namen: „Statiker“ → statiker */
|
||||
export function rollenId(name: string): string {
|
||||
return name.trim().toLowerCase().replace(/ä/g, "ae").replace(/ö/g, "oe").replace(/ü/g, "ue").replace(/ß/g, "ss")
|
||||
.replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "rolle";
|
||||
}
|
||||
90
src/domain/prioritaet.ts
Normal file
90
src/domain/prioritaet.ts
Normal file
@@ -0,0 +1,90 @@
|
||||
// Projekt-Priorität A/B/C (Henning, 08.11.2026): das Programm schlägt sie aus drei Punkten je 0–2 vor, Henning kann
|
||||
// sie im Projekt überschreiben. Ertrag = Rohertrag je Stunde im Vergleich zum Schnitt aller Projekte, Kunde = neu /
|
||||
// Stammkunde / Multiplikator (empfiehlt weiter), Dringlichkeit = Frist, Vertragsstrafe, Bindefrist, Witterung.
|
||||
// 5–6 Punkte A (zuerst), 3–4 B (normal), 0–2 C (Lückenfüller, z. B. für Freitage und Reservetage).
|
||||
|
||||
import { type Datum, tageZwischen } from "./datum.js";
|
||||
|
||||
export type Prio = "A" | "B" | "C";
|
||||
export const PRIOS: Prio[] = ["A", "B", "C"];
|
||||
export const PRIO_TEXT: Record<Prio, string> = { A: "A – zuerst", B: "B – normal", C: "C – Lückenfüller" };
|
||||
/** Termindruck im Projekt */
|
||||
export const TERMINDRUCK: [string, string][] = [["", "normal"], ["witterung", "witterungsabhängig"], ["vertragsstrafe", "fester Termin / Vertragsstrafe"]];
|
||||
/** nur laufende und kommende Projekte bekommen eine Priorität */
|
||||
export const MIT_PRIO = new Set(["anfrage", "angebot", "auftrag", "ausfuehrung"]);
|
||||
|
||||
export interface PrioEingang {
|
||||
id: string;
|
||||
status: string;
|
||||
/** Rohertrag je Stunde in Cent; null: keine Zahlen (weder Auftragswert und Stunden noch kalkuliertes Angebot) */
|
||||
ertrag: number | null;
|
||||
kunde: "neu" | "stamm" | "multiplikator" | null;
|
||||
frist: Datum | null;
|
||||
termindruck: string | null;
|
||||
/** Bindefrist eines versendeten Angebots */
|
||||
bindefrist: Datum | null;
|
||||
prioritaet: Prio | null;
|
||||
}
|
||||
|
||||
export interface Teil { punkte: number; text: string }
|
||||
export interface PrioErgebnis {
|
||||
id: string;
|
||||
ertrag: Teil & { wert: number | null };
|
||||
kunde: Teil;
|
||||
dringlichkeit: Teil;
|
||||
summe: number;
|
||||
vorschlag: Prio;
|
||||
/** gilt: selbst gesetzt, sonst der Vorschlag */
|
||||
prioritaet: Prio;
|
||||
selbst: boolean;
|
||||
}
|
||||
|
||||
export const prioAus = (summe: number): Prio => (summe >= 5 ? "A" : summe >= 3 ? "B" : "C");
|
||||
const euroStunde = (c: number) => `${Math.round(c / 100).toLocaleString("de-DE")} €/Std.`;
|
||||
|
||||
function dringlichkeit(e: PrioEingang, heute: Datum): Teil {
|
||||
const kandidaten: Teil[] = [{ punkte: 0, text: "kein Termindruck" }];
|
||||
if (e.termindruck === "vertragsstrafe") kandidaten.push({ punkte: 2, text: "fester Termin / Vertragsstrafe" });
|
||||
if (e.frist) {
|
||||
const t = tageZwischen(heute, e.frist);
|
||||
const text = t < 0 ? "Frist überschritten" : t === 0 ? "Frist heute" : `Frist in ${t} Tagen`;
|
||||
kandidaten.push({ punkte: t <= 28 ? 2 : t <= 56 ? 1 : 0, text });
|
||||
}
|
||||
if (e.bindefrist && (e.status === "anfrage" || e.status === "angebot")) {
|
||||
const t = tageZwischen(heute, e.bindefrist);
|
||||
if (t >= 0) kandidaten.push({ punkte: t <= 7 ? 2 : t <= 21 ? 1 : 0, text: `Bindefrist in ${t} Tagen` });
|
||||
}
|
||||
if (e.termindruck === "witterung") {
|
||||
const monat = Number(heute.slice(5, 7));
|
||||
kandidaten.push(monat >= 9 && monat <= 11 ? { punkte: 2, text: "witterungsabhängig, vor dem Winter" } : { punkte: 1, text: "witterungsabhängig" });
|
||||
}
|
||||
return kandidaten.reduce((a, b) => (b.punkte > a.punkte ? b : a));
|
||||
}
|
||||
|
||||
/** Priorität aller Projekte; der Ertrag wird mit dem Schnitt der Projekte verglichen, die Zahlen haben */
|
||||
export function prioritaeten(liste: PrioEingang[], heute: Datum): Map<string, PrioErgebnis> {
|
||||
const werte = liste.filter((e) => e.status !== "intern" && e.ertrag !== null).map((e) => e.ertrag!);
|
||||
const schnitt = werte.length >= 2 ? werte.reduce((a, b) => a + b, 0) / werte.length : null;
|
||||
const aus = new Map<string, PrioErgebnis>();
|
||||
for (const e of liste) {
|
||||
let ertrag: PrioErgebnis["ertrag"];
|
||||
if (e.ertrag === null) ertrag = { punkte: 1, text: "noch offen, es fehlen Auftragswert oder Stunden", wert: null };
|
||||
else if (schnitt === null) ertrag = { punkte: 1, text: `${euroStunde(e.ertrag)}, noch kein Vergleich`, wert: e.ertrag };
|
||||
else {
|
||||
const ueber = e.ertrag >= schnitt + Math.abs(schnitt) * 0.1, unter = e.ertrag < schnitt - Math.abs(schnitt) * 0.1;
|
||||
ertrag = { punkte: ueber ? 2 : unter ? 0 : 1, text: `${euroStunde(e.ertrag)}, ${ueber ? "über" : unter ? "unter" : "etwa"} Schnitt (${euroStunde(schnitt)})`, wert: e.ertrag };
|
||||
}
|
||||
const kunde: Teil = e.kunde === "multiplikator" ? { punkte: 2, text: "Kunde empfiehlt weiter" }
|
||||
: e.kunde === "stamm" ? { punkte: 1, text: "Stammkunde" } : { punkte: 0, text: e.kunde ? "neuer Kunde" : "kein Kunde eingetragen" };
|
||||
const d = dringlichkeit(e, heute);
|
||||
const summe = ertrag.punkte + kunde.punkte + d.punkte;
|
||||
const vorschlag = prioAus(summe);
|
||||
aus.set(e.id, { id: e.id, ertrag, kunde, dringlichkeit: d, summe, vorschlag, prioritaet: e.prioritaet ?? vorschlag, selbst: !!e.prioritaet });
|
||||
}
|
||||
return aus;
|
||||
}
|
||||
|
||||
/** Erklärung für Tooltip und Projektseite */
|
||||
export const prioErklaerung = (p: PrioErgebnis) =>
|
||||
`Vorschlag ${p.vorschlag} (${p.summe} von 6 Punkten): Ertrag ${p.ertrag.punkte} – ${p.ertrag.text}; Kunde ${p.kunde.punkte} – ${p.kunde.text}; Dringlichkeit ${p.dringlichkeit.punkte} – ${p.dringlichkeit.text}.`
|
||||
+ (p.selbst ? ` Selbst gesetzt: ${p.prioritaet}.` : "");
|
||||
@@ -1,24 +1,33 @@
|
||||
// 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.
|
||||
// Seit 0.47 (Henning, 08.11.2026) eine Karte je Person mit allen Telefonnummern, E-Mail-Adressen und Adressen samt Typ;
|
||||
// ORG ist der erste übergeordnete Kontakt. Alles andere in der Karte (Foto, Geburtstag, Webseiten) bleibt beim
|
||||
// Zurückschreiben unverändert stehen, ebenso Nummern- oder Adresszeilen, solange sich an ihnen nichts geändert hat.
|
||||
|
||||
import { type Anschrift, type Nummer, ADRESS_TYPEN, EMAIL_TYPEN, TELEFON_TYPEN, listenBereinigt } from "./kontaktdaten.js";
|
||||
|
||||
export interface KontaktFelder {
|
||||
name: string;
|
||||
anrede: string | null;
|
||||
titel: string | null;
|
||||
/** ORG: bei Personen der erste übergeordnete Kontakt (sonst die frei eingetragene Firma), bei Firmen der eigene Name */
|
||||
firma: string | null;
|
||||
telefon: string | null;
|
||||
mobil: string | null;
|
||||
email: string | null;
|
||||
strasse: string | null;
|
||||
plz: string | null;
|
||||
ort: string | null;
|
||||
/** TITLE; undefined: im Programm nicht gepflegt (Person ohne übergeordneten Kontakt), die Karte behält ihre Angabe */
|
||||
funktion?: string | null;
|
||||
/** Firmenkarte (X-ABShowAs:COMPANY) */
|
||||
gruppe: boolean;
|
||||
telefone: Nummer[];
|
||||
emails: Nummer[];
|
||||
adressen: Anschrift[];
|
||||
notiz: 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 in Großbuchstaben zum Vergleichen */
|
||||
name: string;
|
||||
/** Name wie in der Karte geschrieben (X-ABLabel bleibt X-ABLabel) */
|
||||
roh: string;
|
||||
params: string;
|
||||
wert: string;
|
||||
}
|
||||
@@ -32,7 +41,8 @@ function zeilen(text: string): Zeile[] {
|
||||
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 n = nameTeil!.slice(punkt + 1);
|
||||
return { gruppe: punkt < 0 ? "" : nameTeil!.slice(0, punkt), name: n.toUpperCase(), roh: n, params: params.join(";"), wert };
|
||||
});
|
||||
}
|
||||
|
||||
@@ -41,14 +51,15 @@ const esc = (s: string) => s.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replac
|
||||
/** 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]);
|
||||
}
|
||||
|
||||
/** Kontaktgruppe (Verteiler) der Nextcloud oder von Apple, kein Kontakt */
|
||||
export const istVerteiler = (karte: string) => /^(X-ADDRESSBOOKSERVER-KIND|KIND):\s*group\s*$/im.test(karte.replace(/\r/g, ""));
|
||||
|
||||
export function uidVon(karte: string): string | null {
|
||||
return leer(zeilen(karte).find((z) => z.name === "UID")?.wert);
|
||||
}
|
||||
@@ -61,33 +72,100 @@ export function revVon(karte: string): string | null {
|
||||
return m ? `${m[1]}-${m[2]}-${m[3]}T${m[4] ?? "00"}:${m[5] ?? "00"}:${m[6] ?? "00"}Z` : null;
|
||||
}
|
||||
|
||||
/** type=CELL;type=pref, TYPE="work,voice", PREF=1 oder TEL;CELL (vCard 2.1) */
|
||||
function typen(z: Zeile): string[] {
|
||||
const t: string[] = [];
|
||||
for (const p of z.params.split(";").filter(Boolean)) {
|
||||
const i = p.indexOf("=");
|
||||
const k = (i < 0 ? "type" : p.slice(0, i)).toLowerCase();
|
||||
const v = i < 0 ? p : p.slice(i + 1);
|
||||
if (k === "type") t.push(...v.replace(/"/g, "").split(",").map((s) => s.trim().toLowerCase()).filter(Boolean));
|
||||
if (k === "pref") t.push("pref");
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
/** Apple-Bezeichnung (_$!<Mobile>!$_) oder eigene Bezeichnung wie „Rechnungen“ */
|
||||
function ausBezeichnung(l: string): string | undefined {
|
||||
const m = /^_\$!<(.+)>!\$_$/.exec(l);
|
||||
const s = (m ? m[1]! : l).toLowerCase();
|
||||
if (/fax/.test(s)) return "fax";
|
||||
if (/mobil|handy|iphone|cell/.test(s)) return "mobil";
|
||||
if (/rechnung|buchhaltung|invoice|billing/.test(s)) return "rechnung";
|
||||
if (/zentrale|main/.test(s)) return "zentrale";
|
||||
if (/home|privat|zuhause/.test(s)) return "privat";
|
||||
if (/work|büro|buero|geschäft|geschaeft|arbeit|firma/.test(s)) return "geschaeftlich";
|
||||
if (/other|sonstig|andere/.test(s)) return "sonstige";
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function typVon(z: Zeile, alle: Zeile[]): string {
|
||||
const erlaubt = z.name === "TEL" ? TELEFON_TYPEN : z.name === "EMAIL" ? EMAIL_TYPEN : ADRESS_TYPEN;
|
||||
const label = z.gruppe ? alle.find((x) => x.gruppe === z.gruppe && x.name === "X-ABLABEL")?.wert : undefined;
|
||||
let typ = label ? ausBezeichnung(ent(label)) : undefined;
|
||||
if (!typ) {
|
||||
const t = typen(z);
|
||||
const tel = z.name === "TEL";
|
||||
typ = tel && t.includes("fax") ? "fax" : tel && t.some((x) => ["cell", "iphone", "mobile"].includes(x)) ? "mobil" : tel && t.includes("main") ? "zentrale"
|
||||
: t.includes("work") ? "geschaeftlich" : t.includes("home") ? "privat" : "sonstige";
|
||||
}
|
||||
return erlaubt.includes(typ) ? typ : "sonstige";
|
||||
}
|
||||
const bevorzugt = (z: Zeile) => typen(z).includes("pref");
|
||||
|
||||
const ANREDE_WORTE: Record<string, string> = { herr: "Herr", hr: "Herr", frau: "Frau", fr: "Frau", familie: "Familie", eheleute: "Eheleute" };
|
||||
|
||||
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 org = leer(teile(erstes("ORG")?.wert ?? "")[0]);
|
||||
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 namen = leer([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) : [];
|
||||
const gruppe = /^company$/i.test(erstes("X-ABSHOWAS")?.wert.trim() ?? "") || /^org$/i.test(erstes("KIND")?.wert.trim() ?? "") || (!namen && !!org && (fn ?? org) === org);
|
||||
// Namenspräfix: Anrede und Titel
|
||||
const praefix = (n[3] ?? "").split(/\s+/).filter(Boolean);
|
||||
const anredeWort = praefix[0] ? ANREDE_WORTE[praefix[0].replace(/\.$/, "").toLowerCase()] : undefined;
|
||||
const titel = leer((anredeWort ? praefix.slice(1) : praefix).join(" "));
|
||||
const listen = listenBereinigt({
|
||||
telefone: z.filter((x) => x.name === "TEL").map((x) => ({ typ: typVon(x, z), wert: ent(x.wert).replace(/^tel:/i, ""), haupt: bevorzugt(x) })),
|
||||
emails: z.filter((x) => x.name === "EMAIL").map((x) => ({ typ: typVon(x, z), wert: ent(x.wert).replace(/^mailto:/i, ""), haupt: bevorzugt(x) })),
|
||||
adressen: z.filter((x) => x.name === "ADR").map((x) => {
|
||||
const a = teile(x.wert);
|
||||
const [strasse = "", ...rest] = (a[2] ?? "").split("\n");
|
||||
return {
|
||||
typ: typVon(x, z), postfach: a[0] ?? "", strasse, zusatz: [...rest, a[1] ?? ""].map((s) => s.trim()).filter(Boolean).join(", "),
|
||||
ort: a[3] ?? "", region: a[4] ?? "", plz: a[5] ?? "", land: a[6] ?? "", haupt: bevorzugt(x),
|
||||
};
|
||||
}),
|
||||
});
|
||||
return {
|
||||
name: fn ?? ausN ?? org ?? "(ohne Namen)",
|
||||
name: (gruppe ? org ?? fn : namen ?? fn ?? org) ?? "(ohne Namen)",
|
||||
anrede: gruppe ? null : anredeWort ?? null,
|
||||
titel: gruppe ? null : titel,
|
||||
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]),
|
||||
funktion: gruppe ? undefined : leer(ent(erstes("TITLE")?.wert ?? "")),
|
||||
gruppe,
|
||||
...listen,
|
||||
notiz: leer(ent(erstes("NOTE")?.wert ?? "")),
|
||||
};
|
||||
}
|
||||
|
||||
/** Gleiche Inhalte erkennen, ohne auf Schreibweise von Leerzeichen zu achten */
|
||||
const s = (x: unknown) => (x ?? "").toString().replace(/\s+/g, " ").trim();
|
||||
const listenText = (f: Partial<KontaktFelder>) => {
|
||||
const l = listenBereinigt({ telefone: f.telefone ?? [], emails: f.emails ?? [], adressen: f.adressen ?? [] });
|
||||
return {
|
||||
telefone: l.telefone.map((x) => [x.typ, s(x.wert), !!x.haupt]),
|
||||
emails: l.emails.map((x) => [x.typ, s(x.wert).toLowerCase(), !!x.haupt]),
|
||||
adressen: l.adressen.map((a) => [a.typ, s(a.strasse), s(a.zusatz), s(a.plz), s(a.ort), s(a.region), s(a.land), s(a.postfach), !!a.haupt]),
|
||||
};
|
||||
};
|
||||
|
||||
/** Gleiche Inhalte erkennen, ohne auf Schreibweise von Leerzeichen zu achten. „v2“: seit 0.47 mit Listen. */
|
||||
export function fingerabdruck(f: Partial<KontaktFelder>): string {
|
||||
return JSON.stringify(FELDER.map((k) => (f[k] ?? "").toString().replace(/\s+/g, " ").trim()));
|
||||
const l = listenText(f);
|
||||
return "v2" + JSON.stringify([s(f.name), f.gruppe ? "" : s(f.anrede), f.gruppe ? "" : s(f.titel), s(f.firma), f.funktion === undefined || f.gruppe ? "–" : s(f.funktion),
|
||||
!!f.gruppe, s(f.notiz), l.telefone, l.emails, l.adressen]);
|
||||
}
|
||||
|
||||
/** Telefonnummern vergleichbar machen: nur Ziffern, +49/0049 wie 0 */
|
||||
@@ -96,37 +174,97 @@ export function nummer(t: string | null | undefined): string {
|
||||
return d.replace(/^0049/, "0");
|
||||
}
|
||||
|
||||
const adrSchluessel = (a: Anschrift) => [a.strasse, a.plz, a.ort, a.postfach].map((x) => s(x).toLowerCase()).join("|");
|
||||
function dazu<T>(alt: T[], neu: T[], schluessel: (x: T) => string): T[] {
|
||||
const da = new Set(alt.map(schluessel));
|
||||
return [...alt, ...neu.filter((x) => !da.has(schluessel(x))).map((x) => ({ ...x, haupt: false }))];
|
||||
}
|
||||
|
||||
/** Programm um die Karte ergänzen: Leeres füllen, fehlende Nummern, E-Mails und Adressen anhängen; was im Programm steht, bleibt */
|
||||
export function ergaenzt(k: KontaktFelder, f: KontaktFelder): KontaktFelder {
|
||||
return {
|
||||
...k,
|
||||
anrede: k.anrede ?? f.anrede, titel: k.titel ?? f.titel, firma: k.firma ?? f.firma, notiz: k.notiz ?? f.notiz,
|
||||
funktion: k.funktion === undefined ? undefined : k.funktion ?? f.funktion ?? null,
|
||||
...listenBereinigt({
|
||||
telefone: dazu(k.telefone, f.telefone, (x) => nummer(x.wert)),
|
||||
emails: dazu(k.emails, f.emails, (x) => x.wert.trim().toLowerCase()),
|
||||
adressen: dazu(k.adressen, f.adressen, adrSchluessel),
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
||||
const TEL_PARAMS: Record<string, string> = { mobil: "type=CELL;type=VOICE", privat: "type=HOME;type=VOICE", geschaeftlich: "type=WORK;type=VOICE", zentrale: "type=MAIN", fax: "type=WORK;type=FAX" };
|
||||
const EMAIL_PARAMS: Record<string, string> = { privat: "type=INTERNET;type=HOME", geschaeftlich: "type=INTERNET;type=WORK" };
|
||||
const ADR_PARAMS: Record<string, string> = { privat: "type=HOME", geschaeftlich: "type=WORK" };
|
||||
/** Typen ohne eigenes vCard-Kennwort bekommen wie bei Apple eine Bezeichnung */
|
||||
const BEZEICHNUNG: Record<string, Record<string, string>> = {
|
||||
TEL: { sonstige: "_$!<Other>!$_" },
|
||||
EMAIL: { rechnung: "Rechnungen", sonstige: "_$!<Other>!$_" },
|
||||
ADR: { rechnung: "Rechnungsadresse", sonstige: "_$!<Other>!$_" },
|
||||
};
|
||||
|
||||
/**
|
||||
* 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; }
|
||||
let z: Zeile[] = alt ? zeilen(alt).filter((x) => !["BEGIN", "END"].includes(x.name)) : [{ gruppe: "", name: "VERSION", roh: "VERSION", params: "", wert: "3.0" }];
|
||||
const vorher = alt ? felderAus(alt) : null;
|
||||
const setze = (name: string, params: string, wert: string | null) => {
|
||||
const i = z.findIndex((x) => x.name === name.toUpperCase());
|
||||
if (!wert) { z = z.filter((x) => x.name !== name.toUpperCase()); return; }
|
||||
if (i >= 0) z[i] = { ...z[i]!, wert };
|
||||
else z.push({ gruppe: "", name, params, wert });
|
||||
else z.push({ gruppe: "", name: name.toUpperCase(), roh: 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}`;
|
||||
setze("FN", "", esc(f.name));
|
||||
// N: Nachname;Vorname;weitere;Präfix;Suffix – bei Firmen leer wie bei Apple. Apples Aufteilung bleibt, solange der Name gleich ist.
|
||||
const praefix = esc([f.gruppe ? "" : f.anrede, f.gruppe ? "" : f.titel].filter((x) => x && x.trim()).join(" "));
|
||||
const altN = z.find((x) => x.name === "N");
|
||||
if (f.gruppe) setze("N", "", ";;;;");
|
||||
else if (!altN || !vorher || vorher.gruppe || vorher.name !== f.name) {
|
||||
const worte = f.name.trim().split(/\s+/);
|
||||
setze("N", "", worte.length > 1 ? `${esc(worte.at(-1)!)};${esc(worte.slice(0, -1).join(" "))};;${praefix};` : `${esc(f.name)};;;${praefix};`);
|
||||
} else if ((vorher.anrede ?? null) !== (f.anrede ?? null) || (vorher.titel ?? null) !== (f.titel ?? null)) {
|
||||
const t = altN.wert.split(/(?<!\\);/);
|
||||
while (t.length < 5) t.push("");
|
||||
t[3] = praefix;
|
||||
setze("N", "", t.join(";"));
|
||||
}
|
||||
// ORG: Abteilung einer vorhandenen Karte bleibt, solange die Firma gleich ist
|
||||
if (!f.firma) setze("ORG", "", null);
|
||||
else if (vorher?.firma !== f.firma) setze("ORG", "", `${esc(f.firma)};`);
|
||||
if (f.gruppe) setze("TITLE", "", null);
|
||||
else if (f.funktion !== undefined) setze("TITLE", "", f.funktion ? esc(f.funktion) : null);
|
||||
if (f.gruppe) setze("X-ABShowAs", "", "COMPANY");
|
||||
else setze("X-ABShowAs", "", null);
|
||||
|
||||
// Nummern, E-Mails, Adressen: nur neu schreiben, was sich geändert hat
|
||||
const neu = listenText(f), alteListen = vorher ? listenText(vorher) : null;
|
||||
const l = listenBereinigt(f);
|
||||
let item = Math.max(0, ...z.map((x) => /^item(\d+)$/i.exec(x.gruppe)?.[1]).filter(Boolean).map(Number));
|
||||
const schreibe = (name: string, typ: string, params: Record<string, string>, haupt: boolean | undefined, wert: string) => {
|
||||
const pref = haupt ? ";type=pref" : "";
|
||||
const label = BEZEICHNUNG[name]?.[typ];
|
||||
if (params[typ]) { z.push({ gruppe: "", name, roh: name, params: params[typ] + pref, wert }); return; }
|
||||
const g = `item${++item}`;
|
||||
z.push({ gruppe: g, name, roh: name, params: (name === "EMAIL" ? "type=INTERNET" : "") + pref, wert });
|
||||
if (label) z.push({ gruppe: g, name: "X-ABLABEL", roh: "X-ABLabel", params: "", wert: esc(label) });
|
||||
};
|
||||
const ersetze = (name: string, gleich: boolean, neuSchreiben: () => void) => {
|
||||
if (gleich) return;
|
||||
const gruppen = new Set(z.filter((x) => x.name === name && x.gruppe).map((x) => x.gruppe));
|
||||
z = z.filter((x) => x.name !== name && !gruppen.has(x.gruppe));
|
||||
neuSchreiben();
|
||||
};
|
||||
const gleich = (k: "telefone" | "emails" | "adressen") => !!alteListen && JSON.stringify(alteListen[k]) === JSON.stringify(neu[k]);
|
||||
ersetze("TEL", gleich("telefone"), () => l.telefone.forEach((x) => schreibe("TEL", x.typ, TEL_PARAMS, x.haupt, esc(x.wert))));
|
||||
ersetze("EMAIL", gleich("emails"), () => l.emails.forEach((x) => schreibe("EMAIL", x.typ, EMAIL_PARAMS, x.haupt, esc(x.wert))));
|
||||
ersetze("ADR", gleich("adressen"), () => l.adressen.forEach((a) => schreibe("ADR", a.typ, ADR_PARAMS, a.haupt,
|
||||
[a.postfach ?? "", "", [a.strasse, a.zusatz].filter((x) => x && x.trim()).join("\n"), a.ort, a.region ?? "", a.plz, a.land ?? ""].map((x) => esc(x ?? "")).join(";"))));
|
||||
setze("NOTE", "", f.notiz ? esc(f.notiz) : null);
|
||||
setze("UID", "", uid);
|
||||
setze("REV", "", jetzt.toISOString().replace(/\.\d+Z$/, "Z"));
|
||||
const zeile = (x: Zeile) => `${x.gruppe ? `${x.gruppe}.` : ""}${x.roh}${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);
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
// Stufe 3a (Henning, 20.10.2026): Angebote mit Kalkulation. Anlegen mit festgeschriebenen Sätzen (A36),
|
||||
// Versandprüfung (A14), Kalkulationsstand beim Versand und bei Auftrag (A19), „Angebot annehmen“ macht aus dem
|
||||
// Projekt den Auftrag mit Abschnitten, Vorgängen und Zahlungsplan (A4, P9).
|
||||
import { empfaengerLaden } from "./empfaenger.js";
|
||||
import type { FastifyInstance, FastifyRequest } from "fastify";
|
||||
import { z } from "zod";
|
||||
import { type Client, type Pool, transaktion } from "./db.js";
|
||||
@@ -59,7 +60,9 @@ export async function ladeAngebot(c: Pick<Pool, "query">, id: string, e: Einstel
|
||||
const saetze = saetzeVon(angebot, e);
|
||||
const titel = t.rows as KTitel[], positionen = p.rows as (KPosition & { langtext?: string | null })[], kosten = k.rows as KKosten[];
|
||||
const ergebnis = berechneAngebot({ ust_satz: e.ust.satz }, titel, positionen, kosten, saetze);
|
||||
return { angebot, titel, positionen, kosten, saetze, ergebnis };
|
||||
// Anschrift mit z. Hd. und Briefanrede (0.49); festgeschrieben gilt der Stand vom Versand
|
||||
const empfaenger = await empfaengerLaden(c, angebot.projekt_id);
|
||||
return { angebot, titel, positionen, kosten, saetze, ergebnis, empfaenger };
|
||||
}
|
||||
|
||||
function pruefung(x: NonNullable<Awaited<ReturnType<typeof ladeAngebot>>>) {
|
||||
@@ -73,7 +76,7 @@ function stand(x: NonNullable<Awaited<ReturnType<typeof ladeAngebot>>>, anlass:
|
||||
anlass, am: new Date().toISOString(), von: wer, saetze: x.saetze,
|
||||
netto: x.ergebnis.netto, brutto: x.ergebnis.brutto, stunden: x.ergebnis.stunden, kosten: x.ergebnis.kosten,
|
||||
kostenarten: x.ergebnis.kostenarten, titel: x.titel, positionen: x.positionen.map((p) => ({ ...p, ergebnis: x.ergebnis.positionen[p.id] })),
|
||||
kosten_zeilen: x.kosten,
|
||||
kosten_zeilen: x.kosten, empfaenger: x.empfaenger,
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -11,7 +11,7 @@ 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";
|
||||
@@ -35,6 +35,10 @@ 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";
|
||||
import { prioritaetenLaden } from "./prioritaet.js";
|
||||
import { empfaengerLaden } from "./empfaenger.js";
|
||||
import { type Anschrift, type Listen, type Nummer, einarbeiten, einzelfelder, listenBereinigt, rollenId } from "../domain/kontaktdaten.js";
|
||||
|
||||
export interface Optionen {
|
||||
pool: Pool;
|
||||
@@ -52,6 +56,8 @@ export interface Optionen {
|
||||
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 */
|
||||
@@ -94,15 +100,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();
|
||||
@@ -135,7 +146,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({
|
||||
@@ -175,7 +188,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
|
||||
@@ -257,6 +270,44 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
return r.ok ? r : reply.status(409).send({ fehler: r.meldung });
|
||||
});
|
||||
/** welche Kontakte im Handy stehen, für die Markierung in der Kontaktliste */
|
||||
// Rollen der Kontakte, frei anlegbar wie die Aufgaben-Kategorien (Henning, 08.11.2026); Mitarbeiter und Subunternehmer fest
|
||||
const RollenId = z.object({ id: z.string().regex(/^[a-z0-9-]{1,40}$/) });
|
||||
const RollenName = z.object({ name: z.string().trim().min(1, "Name fehlt").max(60) });
|
||||
app.get("/api/kontakt-rollen", async () => (await pool.query("select * from kontakt_rolle order by reihenfolge, name")).rows);
|
||||
app.post("/api/kontakt-rollen", async (req, reply) => {
|
||||
const { name } = RollenName.parse(req.body);
|
||||
const vorhanden = (await pool.query("select * from kontakt_rolle where lower(name) = lower($1)", [name])).rows[0];
|
||||
if (vorhanden) return reply.status(200).send(vorhanden);
|
||||
const ids = new Set((await pool.query("select id from kontakt_rolle")).rows.map((r) => r.id as string));
|
||||
const basis = rollenId(name);
|
||||
let id = basis;
|
||||
for (let i = 2; ids.has(id); i++) id = `${basis.slice(0, 36)}-${i}`;
|
||||
const r = await pool.query("insert into kontakt_rolle (id, name, reihenfolge) values ($1, $2, (select coalesce(max(reihenfolge), 0) + 1 from kontakt_rolle)) returning *", [id, name]);
|
||||
return reply.status(201).send(r.rows[0]);
|
||||
});
|
||||
app.patch("/api/kontakt-rollen/:id", async (req, reply) => {
|
||||
const { id } = RollenId.parse(req.params);
|
||||
const { name } = RollenName.parse(req.body);
|
||||
const r = await pool.query("update kontakt_rolle set name = $2 where id = $1 and not fest returning *", [id, name]);
|
||||
return r.rows[0] ?? reply.status(409).send({ fehler: "Diese Rolle ist fest und lässt sich nicht umbenennen." });
|
||||
});
|
||||
app.delete("/api/kontakt-rollen/:id", async (req, reply) => {
|
||||
const { id } = RollenId.parse(req.params);
|
||||
const n = await transaktion(pool, benutzer(req), async (c) => {
|
||||
const r = await c.query("delete from kontakt_rolle where id = $1 and not fest", [id]);
|
||||
if (r.rowCount) await c.query("update kontakt set rollen = array_remove(rollen, $1) where $1 = any(rollen)", [id]);
|
||||
return r.rowCount;
|
||||
});
|
||||
return n ? reply.status(204).send() : reply.status(409).send({ fehler: "Diese Rolle ist fest und lässt sich nicht löschen." });
|
||||
});
|
||||
|
||||
// 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
|
||||
@@ -343,6 +394,31 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
// Wer das Datum einer verknüpften Zahlung, Kosten oder Aufgabe ändert (z. B. die Raute im Terminplan zieht),
|
||||
// ändert den Versatz zum Vorgang: sie bleibt verknüpft und wandert weiter mit
|
||||
const DATUM_FELD: Record<string, string> = { zahlung: "termin", kosten: "termin", aufgabe: "faellig_am" };
|
||||
// Kontakt (0.47): Listen aufräumen, Einzelfelder als Haupteinträge daraus setzen; wer nur Einzelfelder schreibt
|
||||
// (Kunde im Projekt anlegen, Datei-Import), ändert die passenden Einträge der Listen. Mitarbeiter bleibt Mitarbeiter.
|
||||
async function kontaktVorbereiten(c: Client, tabelle: string, daten: Record<string, unknown>, id?: string): Promise<void> {
|
||||
if (tabelle !== "kontakt") return;
|
||||
const alt = id ? (await c.query("select telefone, emails, adressen, rollen, firma from kontakt where id = $1", [id])).rows[0] : undefined;
|
||||
const listen = ["telefone", "emails", "adressen"] as const;
|
||||
const flach = ["telefon", "mobil", "email", "strasse", "plz", "ort"] as const;
|
||||
let l: Listen | undefined;
|
||||
if (listen.some((k) => daten[k] !== undefined)) {
|
||||
l = listenBereinigt({ telefone: (daten.telefone ?? alt?.telefone ?? []) as Nummer[], emails: (daten.emails ?? alt?.emails ?? []) as Nummer[], adressen: (daten.adressen ?? alt?.adressen ?? []) as Anschrift[] });
|
||||
} else if (flach.some((k) => daten[k] !== undefined)) {
|
||||
const f = Object.fromEntries(flach.filter((k) => daten[k] !== undefined).map((k) => [k, daten[k] as string | null]));
|
||||
l = einarbeiten(listenBereinigt(alt ?? {}), f, !!(daten.firma ?? alt?.firma));
|
||||
}
|
||||
if (l) {
|
||||
Object.assign(daten, einzelfelder(l));
|
||||
for (const k of listen) daten[k] = JSON.stringify(l[k]);
|
||||
}
|
||||
if (daten.rollen !== undefined) {
|
||||
const r = [...new Set(daten.rollen as string[])];
|
||||
if ((alt?.rollen ?? []).includes("mitarbeiter") && !r.includes("mitarbeiter")) r.push("mitarbeiter");
|
||||
daten.rollen = r;
|
||||
}
|
||||
}
|
||||
|
||||
async function versatzAusDatum(c: Client, tabelle: string, daten: Record<string, unknown>, id?: string): Promise<void> {
|
||||
const feld = DATUM_FELD[tabelle];
|
||||
if (!feld || typeof daten[feld] !== "string" || daten.bezug_tage !== undefined) return;
|
||||
@@ -389,6 +465,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
await pruefeBearbeitbar(c, t.name, undefined, daten);
|
||||
if (t.name === "projekt") await projektNummerVorbereiten(c, daten);
|
||||
await versatzAusDatum(c, t.name, daten);
|
||||
await kontaktVorbereiten(c, t.name, daten);
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
return geplant(c, t.name, async () =>
|
||||
(await c.query(
|
||||
@@ -415,6 +492,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
await pruefeBearbeitbar(c, t.name, id, daten);
|
||||
if (t.name === "projekt") await projektNummerVorbereiten(c, daten, id);
|
||||
await versatzAusDatum(c, t.name, daten, id);
|
||||
await kontaktVorbereiten(c, t.name, daten, id);
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
if (t.name === "vorgang_vorgaenger" && (daten.vorgang_id || daten.vorgaenger_id)) {
|
||||
const alt = (await c.query("select vorgang_id, vorgaenger_id from vorgang_vorgaenger where id = $1", [id])).rows[0];
|
||||
@@ -644,7 +722,17 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
|
||||
app.get("/api/terminplan", async () => {
|
||||
const e = await ladeEinstellungen();
|
||||
return terminplan(pool, { tage: e.arbeitstage }, e.stundenProTag);
|
||||
const [plan, prio] = await Promise.all([terminplan(pool, { tage: e.arbeitstage }, e.stundenProTag), prioritaetenLaden(pool, e)]);
|
||||
const je = new Map(prio.map((x) => [x.id, x]));
|
||||
return { ...plan, projekte: plan.projekte.map((p) => ({ ...p, prio: je.get(p.id) ?? null })) };
|
||||
});
|
||||
// Projekt-Priorität A/B/C (Henning, 08.11.2026): Vorschlag aus Ertrag, Kunde und Dringlichkeit, selbst gesetzt gilt
|
||||
app.get("/api/prioritaeten", async () => prioritaetenLaden(pool, await ladeEinstellungen()));
|
||||
// Anschrift mit z. Hd. und Briefanrede (Henning, 08.11.2026); zweck=rechnung nimmt Rechnungsadresse und „Rechnungen“-Ansprechpartner
|
||||
app.get("/api/projekte/:id/empfaenger", async (req) => {
|
||||
const { id } = z.object({ id: z.uuid() }).parse(req.params);
|
||||
const { zweck } = z.object({ zweck: z.enum(["angebot", "rechnung"]).default("angebot") }).parse(req.query);
|
||||
return empfaengerLaden(pool, id, zweck);
|
||||
});
|
||||
|
||||
// Übernahme aus dem Projektplaner V70 (JSON-Sicherung), nur in ein leeres Programm
|
||||
|
||||
17
src/server/empfaenger.ts
Normal file
17
src/server/empfaenger.ts
Normal file
@@ -0,0 +1,17 @@
|
||||
// Anschrift mit „z. Hd.“ und Briefanrede eines Projekts aus Kunde, Ansprechpartnern im Projekt und beim Kunden
|
||||
import type { Pool } from "./db.js";
|
||||
import { type BriefPerson, type Empfaenger, empfaenger } from "../domain/brief.js";
|
||||
|
||||
export async function empfaengerLaden(c: Pick<Pool, "query">, projektId: string, zweck: "angebot" | "rechnung" = "angebot"): Promise<Empfaenger> {
|
||||
const kunde = (await c.query(`select k.id, k.name, k.anrede, k.titel, k.art, k.firma, k.adressen from projekt p join kontakt k on k.id = p.bauherr_id where p.id = $1`, [projektId])).rows[0];
|
||||
if (!kunde) return empfaenger(null, [], zweck);
|
||||
const leute = (await c.query(`select k.id, k.name, k.anrede, k.titel, k.art, k.firma, k.adressen, ap.zustaendig as im_projekt, z.zustaendig as im_kunden,
|
||||
coalesce(ap.reihenfolge, 1000) as r1, coalesce(z.reihenfolge, 1000) as r2
|
||||
from kontakt k
|
||||
left join projekt_ansprechpartner ap on ap.kontakt_id = k.id and ap.projekt_id = $1
|
||||
left join kontakt_zugehoerigkeit z on z.person_id = k.id and z.gruppe_id = $2
|
||||
where ap.id is not null or z.id is not null
|
||||
order by r1, r2, k.name`, [projektId, kunde.id])).rows;
|
||||
const personen: BriefPerson[] = leute.map((r) => ({ kontakt: r, imProjekt: r.im_projekt ?? null, imKunden: r.im_kunden ?? null }));
|
||||
return empfaenger(kunde, personen, zweck);
|
||||
}
|
||||
@@ -27,8 +27,12 @@ export function registriereIch(app: FastifyInstance, pool: Pool, einstellungen:
|
||||
if (!kontakt) return { heute, bis, einsaetze: [] };
|
||||
const woche = { tage: (await einstellungen()).arbeitstage };
|
||||
const r = await pool.query(
|
||||
`select v.id, v.name, v.start, v.start_teil, v.dauer, v.freitage, p.id as projekt_id, p.nummer, p.bezeichnung, p.baustelle_strasse, p.baustelle_plz, p.baustelle_ort
|
||||
`select v.id, v.name, v.start, v.start_teil, v.dauer, v.freitage, p.id as projekt_id, p.nummer, p.bezeichnung, p.baustelle_strasse, p.baustelle_plz, p.baustelle_ort,
|
||||
ap.name as ap_name, ap.telefon as ap_telefon
|
||||
from besetzung_person b join vorgang v on v.id = b.vorgang_id join abschnitt a on a.id = v.abschnitt_id join projekt p on p.id = a.projekt_id
|
||||
-- nur der Ansprechpartner für die Baustelle, keine Kunden- oder Rechnungsdaten (Henning, 08.11.2026)
|
||||
left join lateral (select k.name, coalesce(k.mobil, k.telefon) as telefon from projekt_ansprechpartner pa join kontakt k on k.id = pa.kontakt_id
|
||||
where pa.projekt_id = p.id and 'baustelle' = any(pa.zustaendig) order by pa.reihenfolge, pa.angelegt_am limit 1) ap on true
|
||||
where b.kontakt_id = $1 and b.freigegeben order by v.start, p.nummer`, [kontakt]);
|
||||
const einsaetze = r.rows
|
||||
.map((v) => ({ ...v, dauer: Number(v.dauer), anfang: anfang({ ...v, dauer: Number(v.dauer) }, woche), ende: ende({ ...v, dauer: Number(v.dauer) }, woche) }))
|
||||
|
||||
@@ -28,7 +28,10 @@ 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) {
|
||||
|
||||
@@ -1,11 +1,14 @@
|
||||
// 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.
|
||||
// Seit 0.47: eine Karte je Person mit allen Nummern; ORG ist der erste übergeordnete Kontakt. Übergeordnete Kontakte
|
||||
// bekommen eine eigene Karte, sobald sie eine eigene Nummer oder E-Mail haben.
|
||||
|
||||
import type { Client, Pool } from "./db.js";
|
||||
import { transaktion } from "./db.js";
|
||||
import type { NextcloudZugang } from "./nextcloud.js";
|
||||
import { FELDER, type KontaktFelder, felderAus, fingerabdruck, karteMit, kartenAus, nummer, revVon, uidVon } from "../domain/vcard.js";
|
||||
import { type NextcloudZugang, abrufMitUrsache } from "./nextcloud.js";
|
||||
import { type KontaktFelder, ergaenzt, felderAus, fingerabdruck, istVerteiler, karteMit, kartenAus, nummer, revVon, uidVon } from "../domain/vcard.js";
|
||||
import { einzelfelder, listenBereinigt } from "../domain/kontaktdaten.js";
|
||||
|
||||
export interface Adressbuch { href: string; name: string }
|
||||
export interface Karte { href: string; etag: string | null; karte: string }
|
||||
@@ -27,7 +30,7 @@ export class CardDav {
|
||||
}
|
||||
|
||||
private anfrage(methode: string, href: string, kopf: Record<string, string> = {}, body?: string): Promise<Response> {
|
||||
return this.abruf(this.origin + href, {
|
||||
return abrufMitUrsache(this.abruf, this.origin + href, {
|
||||
method: methode,
|
||||
headers: { authorization: `Basic ${btoa(`${this.z.benutzer}:${this.z.passwort}`)}`, ...kopf },
|
||||
body,
|
||||
@@ -72,41 +75,98 @@ export class CardDav {
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
type Kontakt = KontaktFelder & { id: string; geaendert_am: Date | string; art: string | null; zug_id: string | null; gruppe_id: string | null; abgleich: boolean };
|
||||
|
||||
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])]);
|
||||
const SPALTEN = `select k.id, k.name, k.anrede, k.titel, k.art, k.firma, k.notiz, k.telefone, k.emails, k.adressen, k.geaendert_am,
|
||||
z.id as zug_id, z.gruppe_id, z.funktion, g.name as gruppe_name
|
||||
from kontakt k
|
||||
left join lateral (select id, gruppe_id, funktion from kontakt_zugehoerigkeit where person_id = k.id order by reihenfolge, angelegt_am limit 1) z on true
|
||||
left join kontakt g on g.id = z.gruppe_id`;
|
||||
const gleich = (a: string | null | undefined, b: string | null | undefined) => (a ?? "").trim().toLowerCase() === (b ?? "").trim().toLowerCase();
|
||||
const leer = (s: string | null | undefined) => (s && s.trim() ? s.trim() : null);
|
||||
|
||||
/** Kontakt aus der Datenbank so, wie er im Handy stehen soll */
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
function ausZeile(r: Record<string, any>): Kontakt {
|
||||
// übergeordneter Kontakt, oder ein älterer Firmenkontakt (Name = Firma): Firmenkarte
|
||||
const gruppe = !!r.art || (!!r.firma && gleich(r.firma, r.name));
|
||||
const telefone = r.telefone ?? [], emails = r.emails ?? [];
|
||||
return {
|
||||
id: r.id, geaendert_am: r.geaendert_am, art: r.art ?? null, zug_id: r.zug_id ?? null, gruppe_id: r.gruppe_id ?? null,
|
||||
name: r.name, anrede: gruppe ? null : r.anrede ?? null, titel: gruppe ? null : r.titel ?? null,
|
||||
firma: gruppe ? r.name : r.gruppe_name ?? r.firma ?? null,
|
||||
funktion: gruppe || !r.zug_id ? undefined : r.funktion ?? null,
|
||||
gruppe, telefone, emails, adressen: r.adressen ?? [], notiz: r.notiz ?? null,
|
||||
// übergeordnete Kontakte kommen nur mit eigener Nummer oder E-Mail neu ins Handy
|
||||
abgleich: !r.art || telefone.length > 0 || emails.length > 0,
|
||||
};
|
||||
}
|
||||
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;
|
||||
const alleKontakte = async (c: Client | Pool) => (await c.query(SPALTEN)).rows.map(ausZeile);
|
||||
const einKontakt = async (c: Client | Pool, id: string) => ausZeile((await c.query(`${SPALTEN} where k.id = $1`, [id])).rows[0]);
|
||||
|
||||
/** Die Karte so lesen, wie sie zu diesem Kontakt passt: die Funktion nur, wo das Programm sie pflegt */
|
||||
const fuer = (k: Pick<KontaktFelder, "funktion">, f: KontaktFelder): KontaktFelder => (k.funktion === undefined ? { ...f, funktion: undefined } : f);
|
||||
|
||||
/** ORG aus dem Handy: einem vorhandenen übergeordneten Kontakt zuordnen, sonst als Firma eintragen (Vorschlag „Firma anlegen?“) */
|
||||
async function firmaSetzen(c: Client, id: string, alt: Kontakt | null, f: KontaktFelder): Promise<void> {
|
||||
const org = leer(f.firma);
|
||||
if (alt && gleich(org, alt.firma)) {
|
||||
if (alt.zug_id && f.funktion !== undefined && (f.funktion ?? null) !== (alt.funktion ?? null))
|
||||
await c.query("update kontakt_zugehoerigkeit set funktion = $2 where id = $1", [alt.zug_id, f.funktion ?? null]);
|
||||
return;
|
||||
}
|
||||
// ORG im Handy gelöscht: Zuordnungen bleiben, nur die frei eingetragene Firma geht
|
||||
if (!org) { if (!alt?.gruppe_id) await c.query("update kontakt set firma = null where id = $1", [id]); return; }
|
||||
const g = (await c.query("select id from kontakt where art is not null and id <> $2 and lower(trim(name)) = lower($1) order by angelegt_am limit 1", [org, id])).rows[0];
|
||||
if (!g) { await c.query("update kontakt set firma = $2 where id = $1", [id, org]); return; }
|
||||
await c.query(`insert into kontakt_zugehoerigkeit (gruppe_id, person_id, funktion, reihenfolge)
|
||||
values ($1, $2, $3, coalesce((select min(reihenfolge) from kontakt_zugehoerigkeit where person_id = $2), 1) - 1)
|
||||
on conflict (gruppe_id, person_id) do update set funktion = coalesce(excluded.funktion, kontakt_zugehoerigkeit.funktion), reihenfolge = excluded.reihenfolge`,
|
||||
[g.id, id, f.funktion ?? null]);
|
||||
}
|
||||
|
||||
/** Derselbe Mensch: gleiche E-Mail, gleiche Nummer oder gleicher Name */
|
||||
/** Karte ins Programm schreiben (neu, wenn alt fehlt); die Einzelfelder kommen wie beim Speichern aus den Listen */
|
||||
async function kontaktSchreiben(c: Client, alt: Kontakt | null, f: KontaktFelder): Promise<string> {
|
||||
const l = listenBereinigt(f);
|
||||
const e = einzelfelder(l);
|
||||
const person = !(alt ? alt.gruppe : f.gruppe);
|
||||
const sp = ["name", "anrede", "titel", "notiz", "telefone", "emails", "adressen", "telefon", "mobil", "email", "strasse", "plz", "ort"];
|
||||
const werte = [f.name, person ? f.anrede : null, person ? f.titel : null, f.notiz, JSON.stringify(l.telefone), JSON.stringify(l.emails), JSON.stringify(l.adressen),
|
||||
e.telefon, e.mobil, e.email, e.strasse, e.plz, e.ort];
|
||||
let id: string;
|
||||
if (alt) {
|
||||
await c.query(`update kontakt set ${sp.map((x, i) => `${x} = $${i + 2}`).join(", ")}, geaendert_am = now() where id = $1`, [alt.id, ...werte]);
|
||||
id = alt.id;
|
||||
} else {
|
||||
id = (await c.query(`insert into kontakt (${sp.join(", ")}, art) values (${sp.map((_, i) => `$${i + 1}`).join(", ")}, $${sp.length + 1}) returning id`,
|
||||
[...werte, f.gruppe ? "firma" : null])).rows[0].id;
|
||||
}
|
||||
if (person) await firmaSetzen(c, id, alt, f);
|
||||
return id;
|
||||
}
|
||||
|
||||
/** Derselbe Kontakt: gleiche E-Mail oder Nummer (Person zu Person, Firma zu Firma), sonst 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());
|
||||
const mails = f.emails.map((x) => x.wert.trim().toLowerCase()).filter(Boolean);
|
||||
const nrn = f.telefone.map((x) => nummer(x.wert)).filter((n) => n.length >= 6);
|
||||
const art = kontakte.filter((k) => k.gruppe === f.gruppe);
|
||||
return (mails.length ? art.find((k) => k.emails.some((x) => mails.includes(x.wert.trim().toLowerCase()))) : undefined)
|
||||
?? (nrn.length ? art.find((k) => k.telefone.some((x) => nrn.includes(nummer(x.wert)))) : undefined)
|
||||
?? kontakte.find((k) => gleich(k.name, f.name));
|
||||
}
|
||||
|
||||
/** 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 kontakte = await alleKontakte(c);
|
||||
const e = { neu: 0, ergaenzt: 0, gleich: 0 };
|
||||
for (const karte of kartenAus(text)) {
|
||||
for (const karte of kartenAus(text).filter((k) => !istVerteiler(k))) {
|
||||
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 (!k) { kontakte.push(await einKontakt(c, await kontaktSchreiben(c, null, f))); e.neu++; continue; }
|
||||
const m = ergaenzt(k, fuer(k, f));
|
||||
if (fingerabdruck(m) === fingerabdruck(k)) { e.gleich++; continue; }
|
||||
await kontaktSetzen(c, k.id, m);
|
||||
Object.assign(k, m);
|
||||
await kontaktSchreiben(c, k, m);
|
||||
Object.assign(k, await einKontakt(c, k.id));
|
||||
e.ergaenzt++;
|
||||
}
|
||||
return e;
|
||||
@@ -129,25 +189,32 @@ export async function kontakteAbgleichen(pool: Pool, cd: CardDav, adressbuch: st
|
||||
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 fern = new Map((await cd.karten(basis)).filter((k) => !istVerteiler(k.karte)).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 kontakte = new Map((await alleKontakte(pool)).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 karte = karteMit(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));
|
||||
/** m ins Programm, falls anders; was das Programm danach anders hält als die Karte (z. B. die Firma), geht ins Handy */
|
||||
const zusammen = async (k: Kontakt, r: Karte, uid: string, m: KontaktFelder): Promise<boolean> => {
|
||||
let geaendert = false;
|
||||
if (fingerabdruck(m) !== fingerabdruck(k)) {
|
||||
await transaktion(pool, WER, (c) => kontaktSchreiben(c, k, m));
|
||||
Object.assign(k, await einKontakt(pool, k.id));
|
||||
geaendert = true;
|
||||
}
|
||||
if (fingerabdruck(fuer(k, felderAus(r.karte))) !== fingerabdruck(k)) { await insHandy(k, r.href, uid, r); return true; }
|
||||
await speichere(r.href, k.id, uid, r.etag, r.karte, fingerabdruck(k));
|
||||
return geaendert;
|
||||
};
|
||||
const vomHandy = (k: Kontakt, r: Karte, uid: string) => zusammen(k, r, uid, felderAus(r.karte));
|
||||
|
||||
for (const l of links) {
|
||||
const r = fern.get(l.href);
|
||||
@@ -161,6 +228,12 @@ export async function kontakteAbgleichen(pool: Pool, cd: CardDav, adressbuch: st
|
||||
continue;
|
||||
}
|
||||
verknuepft.add(k.id);
|
||||
// erster Lauf nach 0.47: Programm und Karte einmal zusammenführen, damit keine Nummer aus dem Handy verloren geht
|
||||
if (!l.stand.startsWith("v2")) {
|
||||
if (r) { if (await zusammen(k, r, l.uid, ergaenzt(k, fuer(k, felderAus(r.karte))))) e.zusammengefuehrt++; }
|
||||
else await pool.query("update kontakt_abgleich set stand = $2 where href = $1", [l.href, fingerabdruck(k)]);
|
||||
if (r || l.geloescht) continue;
|
||||
}
|
||||
const lokal = fingerabdruck(k) !== l.stand;
|
||||
if (!r) {
|
||||
if (!l.geloescht) {
|
||||
@@ -177,7 +250,7 @@ export async function kontakteAbgleichen(pool: Pool, cd: CardDav, adressbuch: st
|
||||
}
|
||||
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; }
|
||||
if (fernGeaendert && fingerabdruck(fuer(k, 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()));
|
||||
@@ -192,24 +265,21 @@ export async function kontakteAbgleichen(pool: Pool, cd: CardDav, adressbuch: st
|
||||
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() };
|
||||
const id = await transaktion(pool, WER, (c) => kontaktSchreiben(c, null, f));
|
||||
const neu = await einKontakt(pool, id);
|
||||
kontakte.set(id, neu);
|
||||
verknuepft.add(id);
|
||||
await speichere(r.href, id, uid, r.etag, r.karte, fingerabdruck(f));
|
||||
await zusammen(neu, r, uid, neu);
|
||||
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));
|
||||
await zusammen(k, r, uid, ergaenzt(k, fuer(k, f)));
|
||||
e.zusammengefuehrt++;
|
||||
}
|
||||
|
||||
// Kontakte, die es im Handy noch nicht gibt
|
||||
for (const k of frei()) {
|
||||
for (const k of frei().filter((x) => x.abgleich)) {
|
||||
await insHandy(k, `${basis}${k.id}.vcf`, k.id, null);
|
||||
e.neuInsHandy++;
|
||||
}
|
||||
|
||||
94
src/server/migrations/029_kontakte_neu.sql
Normal file
94
src/server/migrations/029_kontakte_neu.sql
Normal file
@@ -0,0 +1,94 @@
|
||||
-- Neue Kontaktmaske und übergeordnete Kontakte (Henning, 08.11.2026).
|
||||
-- Telefon, E-Mail und Adresse beliebig oft mit Typ und Haupteintrag; die alten Einzelfelder bleiben als
|
||||
-- Haupteinträge stehen (Listen, Suche, Projektseite) und werden beim Speichern aus den Listen gesetzt.
|
||||
alter table kontakt
|
||||
add column anrede text,
|
||||
add column titel text,
|
||||
-- null: Person; sonst übergeordneter Kontakt (Firma/Institution, Behörde, Familie, Ehepaar, WEG)
|
||||
add column art text check (art in ('firma', 'behoerde', 'familie', 'ehepaar', 'weg')),
|
||||
add column telefone jsonb not null default '[]',
|
||||
add column emails jsonb not null default '[]',
|
||||
add column adressen jsonb not null default '[]',
|
||||
-- mehrere Rollen je Kontakt, frei anlegbar; rolle bleibt als wichtigste Rolle für Terminplan, Personal und Stunden
|
||||
add column rollen text[] not null default '{}';
|
||||
|
||||
alter table kontakt drop constraint if exists kontakt_rolle_check;
|
||||
|
||||
-- vorhandene Einzelfelder in die Listen übernehmen; mit Firma geschäftlich, sonst privat.
|
||||
-- Als Funktion, weil auch eine ältere Sicherung beim Einspielen so umgestellt wird.
|
||||
create function kontakt_listen_aus_einzelfeldern() returns void language sql as $f$
|
||||
update kontakt set
|
||||
telefone = (
|
||||
case when coalesce(trim(mobil), '') <> '' then jsonb_build_array(jsonb_build_object('typ', 'mobil', 'wert', trim(mobil), 'haupt', true)) else '[]'::jsonb end
|
||||
|| case when coalesce(trim(telefon), '') <> '' then jsonb_build_array(jsonb_build_object('typ', case when coalesce(trim(firma), '') <> '' then 'geschaeftlich' else 'privat' end,
|
||||
'wert', trim(telefon), 'haupt', coalesce(trim(mobil), '') = '')) else '[]'::jsonb end),
|
||||
emails = case when coalesce(trim(email), '') <> '' then jsonb_build_array(jsonb_build_object('typ', case when coalesce(trim(firma), '') <> '' then 'geschaeftlich' else 'privat' end,
|
||||
'wert', trim(email), 'haupt', true)) else '[]'::jsonb end,
|
||||
adressen = case when coalesce(trim(strasse), '') <> '' or coalesce(trim(plz), '') <> '' or coalesce(trim(ort), '') <> ''
|
||||
then jsonb_build_array(jsonb_build_object('typ', case when coalesce(trim(firma), '') <> '' then 'geschaeftlich' else 'privat' end,
|
||||
'strasse', coalesce(trim(strasse), ''), 'zusatz', '', 'plz', coalesce(trim(plz), ''), 'ort', coalesce(trim(ort), ''), 'region', '', 'land', '', 'postfach', '', 'haupt', true))
|
||||
else '[]'::jsonb end,
|
||||
rollen = case when cardinality(rollen) > 0 then rollen when rolle = 'sonstige' then '{}'::text[] else array[rolle] end
|
||||
where telefone = '[]'::jsonb and emails = '[]'::jsonb and adressen = '[]'::jsonb;
|
||||
$f$;
|
||||
select kontakt_listen_aus_einzelfeldern();
|
||||
|
||||
-- Rollen zum Auswählen; Mitarbeiter und Subunternehmer sind fest (Personal und Terminplan hängen daran)
|
||||
create table kontakt_rolle (
|
||||
id text primary key check (id ~ '^[a-z0-9-]{1,40}$'),
|
||||
name text not null,
|
||||
fest boolean not null default false,
|
||||
reihenfolge integer not null default 100
|
||||
);
|
||||
insert into kontakt_rolle (id, name, fest, reihenfolge) values
|
||||
('bauherr', 'Bauherr', false, 1), ('planer', 'Planer', false, 2), ('lieferant', 'Lieferant', false, 3),
|
||||
('subunternehmer', 'Subunternehmer', true, 4), ('mitarbeiter', 'Mitarbeiter', true, 5);
|
||||
|
||||
-- rolle aus den Rollen: Mitarbeiter vor Subunternehmer vor der ersten Rolle. Wer nur rolle schreibt
|
||||
-- (Anmeldung, Stundenimport, ältere Teile), fügt diese Rolle hinzu.
|
||||
create function kontakt_rolle_setzen() returns trigger language plpgsql as $$
|
||||
begin
|
||||
if tg_op = 'INSERT' then
|
||||
if cardinality(new.rollen) = 0 and new.rolle is not null and new.rolle <> 'sonstige' then new.rollen := array[new.rolle]; end if;
|
||||
elsif new.rollen is not distinct from old.rollen and new.rolle is distinct from old.rolle and new.rolle <> 'sonstige' and not (new.rolle = any(new.rollen)) then
|
||||
new.rollen := new.rollen || new.rolle;
|
||||
end if;
|
||||
new.rolle := case when 'mitarbeiter' = any(new.rollen) then 'mitarbeiter'
|
||||
when 'subunternehmer' = any(new.rollen) then 'subunternehmer'
|
||||
else coalesce(new.rollen[1], 'sonstige') end;
|
||||
return new;
|
||||
end $$;
|
||||
create trigger kontakt_a_rolle before insert or update on kontakt for each row execute function kontakt_rolle_setzen();
|
||||
|
||||
-- Ansprechpartner eines übergeordneten Kontakts; eine Person kann zu mehreren gehören
|
||||
create table kontakt_zugehoerigkeit (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
gruppe_id uuid not null references kontakt (id) on delete cascade,
|
||||
person_id uuid not null references kontakt (id) on delete cascade,
|
||||
funktion text,
|
||||
-- haupt, rechnungen, baustelle, planung
|
||||
zustaendig text[] not null default '{}',
|
||||
reihenfolge integer not null default 0,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system',
|
||||
unique (gruppe_id, person_id),
|
||||
check (gruppe_id <> person_id)
|
||||
);
|
||||
create trigger kontakt_zugehoerigkeit_protokoll before insert or update or delete on kontakt_zugehoerigkeit
|
||||
for each row execute function stempel_und_protokoll();
|
||||
|
||||
-- Ansprechpartner im Projekt; Mitarbeiter sehen am Handy nur den für die Baustelle
|
||||
create table projekt_ansprechpartner (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
projekt_id uuid not null references projekt (id) on delete cascade,
|
||||
kontakt_id uuid not null references kontakt (id) on delete cascade,
|
||||
zustaendig text[] not null default '{}',
|
||||
reihenfolge integer not null default 0,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system',
|
||||
unique (projekt_id, kontakt_id)
|
||||
);
|
||||
create trigger projekt_ansprechpartner_protokoll before insert or update or delete on projekt_ansprechpartner
|
||||
for each row execute function stempel_und_protokoll();
|
||||
9
src/server/migrations/030_prioritaet.sql
Normal file
9
src/server/migrations/030_prioritaet.sql
Normal file
@@ -0,0 +1,9 @@
|
||||
-- Projekt-Priorität A/B/C (Henning, 08.11.2026): das Programm schlägt sie vor, selbst gesetzt gilt die eigene.
|
||||
alter table projekt
|
||||
-- null: Vorschlag des Programms gilt
|
||||
add column prioritaet text check (prioritaet in ('A', 'B', 'C')),
|
||||
-- fertig bis
|
||||
add column frist date,
|
||||
add column termindruck text check (termindruck in ('witterung', 'vertragsstrafe'));
|
||||
-- Kunde, der weiterempfiehlt (Architekt, Hausverwaltung, Multiplikator): zählt bei der Priorität doppelt
|
||||
alter table kontakt add column multiplikator boolean not null default false;
|
||||
@@ -49,6 +49,28 @@ 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 {
|
||||
@@ -59,7 +81,7 @@ export class Nextcloud {
|
||||
}
|
||||
|
||||
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,
|
||||
|
||||
52
src/server/prioritaet.ts
Normal file
52
src/server/prioritaet.ts
Normal file
@@ -0,0 +1,52 @@
|
||||
// Projekt-Priorität A/B/C: Zahlen aus der Datenbank sammeln, rechnen tut src/domain/prioritaet.ts.
|
||||
import type { Pool } from "./db.js";
|
||||
import type { Einstellungen } from "./einstellungen.js";
|
||||
import { ladeAngebot } from "./angebote.js";
|
||||
import { type Prio, type PrioEingang, type PrioErgebnis, MIT_PRIO, prioritaeten } from "../domain/prioritaet.js";
|
||||
import { vonDate } from "../domain/datum.js";
|
||||
|
||||
const BEAUFTRAGT = ["auftrag", "ausfuehrung", "abgerechnet", "gewaehrleistung", "abgeschlossen"];
|
||||
|
||||
/**
|
||||
* Rohertrag je Stunde: Auftragswert − Kosten der Baustelle durch die Soll-Stunden (sonst die Stunden der Vorgänge);
|
||||
* ohne Auftragswert aus dem neuesten nicht abgelehnten Angebot: Netto − Material, Fremdleistung, Fahrt, Sonstiges
|
||||
* durch die kalkulierten Stunden.
|
||||
*/
|
||||
export async function prioritaetenLaden(pool: Pool, e: Einstellungen, heute = vonDate(new Date())): Promise<PrioErgebnis[]> {
|
||||
const [projekte, stunden, angebote, kunden] = await Promise.all([
|
||||
pool.query(`select id, status, bauherr_id, umsatz_netto, material_kosten + fremd_kosten + sonstige_kosten as kosten, soll_stunden,
|
||||
prioritaet, frist::text as frist, termindruck from projekt`),
|
||||
pool.query(`select a.projekt_id, sum(v.stunden) as stunden from vorgang v join abschnitt a on a.id = v.abschnitt_id group by a.projekt_id`),
|
||||
pool.query(`select id, projekt_id, status, bindefrist::text as bindefrist from angebot
|
||||
where status <> 'abgelehnt' and belegart in ('angebot', 'kostenvoranschlag') order by datum desc, nummer desc`),
|
||||
pool.query("select id, multiplikator from kontakt where multiplikator"),
|
||||
]);
|
||||
const stdJe = new Map(stunden.rows.map((r) => [r.projekt_id as string, Number(r.stunden) || 0]));
|
||||
const multi = new Set(kunden.rows.map((r) => r.id as string));
|
||||
const eingang: PrioEingang[] = [];
|
||||
for (const p of projekte.rows) {
|
||||
const mitPrio = MIT_PRIO.has(p.status);
|
||||
const umsatz = Number(p.umsatz_netto) || 0;
|
||||
const std = Number(p.soll_stunden) || stdJe.get(p.id) || 0;
|
||||
let ertrag: number | null = umsatz > 0 && std > 0 ? (umsatz - Number(p.kosten)) / std : null;
|
||||
const eigene = angebote.rows.filter((a) => a.projekt_id === p.id);
|
||||
if (ertrag === null && mitPrio && eigene[0]) {
|
||||
const x = await ladeAngebot(pool, eigene[0].id, e);
|
||||
const k = x?.ergebnis.kostenarten;
|
||||
if (x && k && x.ergebnis.netto > 0 && x.ergebnis.stunden > 0) {
|
||||
ertrag = (x.ergebnis.netto - k.material.kosten - k.subunternehmer.kosten - k.fahrt.kosten - k.sonstiges.kosten) / x.ergebnis.stunden;
|
||||
}
|
||||
}
|
||||
const bindefristen = eigene.filter((a) => a.status === "versendet" && a.bindefrist).map((a) => a.bindefrist as string).sort();
|
||||
const andere = projekte.rows.some((q) => q.id !== p.id && p.bauherr_id && q.bauherr_id === p.bauherr_id && BEAUFTRAGT.includes(q.status));
|
||||
eingang.push({
|
||||
id: p.id, status: p.status, ertrag,
|
||||
kunde: !p.bauherr_id ? null : multi.has(p.bauherr_id) ? "multiplikator" : andere ? "stamm" : "neu",
|
||||
frist: p.frist ?? null, termindruck: p.termindruck ?? null, bindefrist: bindefristen[0] ?? null,
|
||||
prioritaet: (p.prioritaet as Prio | null) ?? null,
|
||||
});
|
||||
}
|
||||
const erg = prioritaeten(eingang, heute);
|
||||
// abgeschlossene, abgerechnete und interne Projekte zählen beim Ertragsschnitt mit, bekommen aber keine Priorität
|
||||
return eingang.filter((x) => MIT_PRIO.has(x.status) || x.prioritaet).map((x) => erg.get(x.id)!);
|
||||
}
|
||||
@@ -21,7 +21,8 @@ export function pruefeStand(x: unknown): Stand {
|
||||
|
||||
export async function speichereStand(c: Client, s: Stand): Promise<Record<string, number>> {
|
||||
const belegt = await c.query<{ n: number }>(
|
||||
`select ${[...TABELLEN, ...NUR_SICHERUNG].map((t) => `(select count(*) from ${t.name})`).join(" + ")} as n`,
|
||||
// die Rollen bringt schon die Migration mit
|
||||
`select ${[...TABELLEN, ...NUR_SICHERUNG].filter((t) => t.name !== "kontakt_rolle").map((t) => `(select count(*) from ${t.name})`).join(" + ")} as n`,
|
||||
);
|
||||
if (Number(belegt.rows[0]!.n) > 0) throw new NichtLeer("Eine Sicherung lässt sich nur in ein leeres Programm einspielen.");
|
||||
|
||||
@@ -31,6 +32,8 @@ export async function speichereStand(c: Client, s: Stand): Promise<Record<string
|
||||
// TABELLEN steht in der Reihenfolge der Fremdschlüssel, NUR_SICHERUNG hängt an ihnen
|
||||
for (const t of [...TABELLEN, ...NUR_SICHERUNG]) {
|
||||
const zeilen = s.daten[t.pfad] ?? [];
|
||||
// Rollen aus der Sicherung ersetzen die Vorgaben; eine ältere Sicherung ohne Rollen behält sie
|
||||
if (t.name === "kontakt_rolle" && zeilen.length) await c.query("delete from kontakt_rolle");
|
||||
// nur Spalten, die es gibt und die in der Sicherung stehen: neue Spalten behalten ihren Vorgabewert,
|
||||
// so passt eine ältere Sicherung auch nach einer Migration
|
||||
const vorhanden = new Set((await c.query<{ column_name: string }>(
|
||||
@@ -52,6 +55,8 @@ export async function speichereStand(c: Client, s: Stand): Promise<Record<string
|
||||
}
|
||||
anzahl[t.pfad] = zeilen.length;
|
||||
}
|
||||
// Sicherung von vor 0.47: Telefon, E-Mail und Adresse in die Listen der neuen Kontaktmaske
|
||||
if ((s.daten.kontakte ?? []).length && !(s.daten.kontakte ?? []).some((k) => "telefone" in k)) await c.query("select kontakt_listen_aus_einzelfeldern()");
|
||||
anzahl.benutzer = await speichereBenutzer(c, s.daten.benutzer ?? []);
|
||||
anzahl.ansichten = await speichereAnsichten(c, s.daten.ansichten ?? []);
|
||||
if (s.einstellungen !== undefined) {
|
||||
|
||||
@@ -40,6 +40,12 @@ const ansatz = z.object({
|
||||
artikel_id: z.uuid().nullable().optional(),
|
||||
});
|
||||
|
||||
// Kontaktdaten (0.47): beliebig viele Nummern und Adressen mit Typ
|
||||
const kurz = z.string().max(300).optional().default("");
|
||||
const nummerEintrag = z.object({ typ: z.string().max(40), wert: z.string().max(300), haupt: z.boolean().optional() });
|
||||
const anschrift = z.object({ typ: z.string().max(40), strasse: kurz, zusatz: kurz, plz: kurz, ort: kurz, region: kurz, land: kurz, postfach: kurz, haupt: z.boolean().optional() });
|
||||
const zustaendig = z.array(z.enum(["haupt", "rechnungen", "baustelle", "planung"])).max(4);
|
||||
|
||||
export interface Tabelle {
|
||||
name: string;
|
||||
pfad: string;
|
||||
@@ -57,7 +63,16 @@ export const TABELLEN: Tabelle[] = [
|
||||
schema: z.object({
|
||||
name: text,
|
||||
firma: optText,
|
||||
rolle: z.enum(["bauherr", "subunternehmer", "lieferant", "planer", "mitarbeiter", "sonstige"]).optional(),
|
||||
// rolle: nur noch zum Lesen und für ältere Teile; gepflegt werden die Rollen (0.47)
|
||||
rolle: z.string().regex(/^[a-z0-9-]{1,40}$/).optional(),
|
||||
rollen: z.array(z.string().regex(/^[a-z0-9-]{1,40}$/)).max(30).optional(),
|
||||
art: z.enum(["firma", "behoerde", "familie", "ehepaar", "weg"]).nullable().optional(),
|
||||
multiplikator: z.boolean().optional(),
|
||||
anrede: optText,
|
||||
titel: optText,
|
||||
telefone: z.array(nummerEintrag).max(30).optional(),
|
||||
emails: z.array(nummerEintrag).max(30).optional(),
|
||||
adressen: z.array(anschrift).max(20).optional(),
|
||||
telefon: optText,
|
||||
mobil: optText,
|
||||
email: optText,
|
||||
@@ -68,6 +83,13 @@ export const TABELLEN: Tabelle[] = [
|
||||
notiz: optText,
|
||||
}),
|
||||
},
|
||||
// Ansprechpartner übergeordneter Kontakte (0.47)
|
||||
{
|
||||
name: "kontakt_zugehoerigkeit",
|
||||
pfad: "kontakt-zugehoerigkeiten",
|
||||
sortierung: "gruppe_id, reihenfolge, angelegt_am",
|
||||
schema: z.object({ gruppe_id: id, person_id: id, funktion: optText, zustaendig: zustaendig.optional(), reihenfolge: z.number().int().optional() }),
|
||||
},
|
||||
// 0.15: Kolonnen und Subunternehmer (Henning, 20.10.2026)
|
||||
{
|
||||
name: "kolonne",
|
||||
@@ -133,8 +155,18 @@ export const TABELLEN: Tabelle[] = [
|
||||
baustelle_plz: optText,
|
||||
baustelle_ort: optText,
|
||||
notiz: optText,
|
||||
prioritaet: z.enum(["A", "B", "C"]).nullable().optional(),
|
||||
frist: datum.nullable().optional(),
|
||||
termindruck: z.enum(["witterung", "vertragsstrafe"]).nullable().optional(),
|
||||
}),
|
||||
},
|
||||
// Ansprechpartner im Projekt (0.47), Kunde bleibt bauherr_id
|
||||
{
|
||||
name: "projekt_ansprechpartner",
|
||||
pfad: "projekt-ansprechpartner",
|
||||
sortierung: "projekt_id, reihenfolge, angelegt_am",
|
||||
schema: z.object({ projekt_id: id, kontakt_id: id, zustaendig: zustaendig.optional(), reihenfolge: z.number().int().optional() }),
|
||||
},
|
||||
// Stufe 3a: Angebote mit Kalkulation (A2, A19, A28, A32, A37); Status und Stände nur über eigene Routen
|
||||
{
|
||||
name: "angebot",
|
||||
@@ -490,6 +522,7 @@ export const TABELLEN: Tabelle[] = [
|
||||
* Reihenfolge nach Fremdschlüsseln, nach TABELLEN einzuspielen. */
|
||||
export const NUR_SICHERUNG: { name: string; pfad: string; sortierung: string }[] = [
|
||||
{ name: "zeiteintrag", pfad: "zeiteintraege", sortierung: "datum, kontakt_id" },
|
||||
{ name: "kontakt_rolle", pfad: "kontakt_rollen", sortierung: "reihenfolge, name" },
|
||||
{ name: "zeitanteil", pfad: "zeitanteile", sortierung: "zeiteintrag_id, reihenfolge" },
|
||||
{ name: "projekt_vorlage", pfad: "projekt_vorlagen", sortierung: "projekt_id, vorlage" },
|
||||
// Stufe 5: Jahresplan-Versionen, BWA je Monat und die Zuordnung der BWA-Zeilen
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
// Position mit Reitern (Langtext, Aufmaß, Kalkulation, Zuschläge & Preis, Mehr). Rechts Reiter für Bausteine, Leistungen, KI, Vorgaben, Prüfung.
|
||||
// Jede Änderung wird sofort gespeichert und neu gerechnet; nach dem Versand ist das Angebot festgeschrieben (A19).
|
||||
|
||||
import type { Empfaenger } from "../domain/brief.js";
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { EINHEITEN, KOSTENARTEN, KOSTENART_NAME, POSITIONSARTEN, POSITIONSART_NAME, lohnartOptionen, lohnartenVon, standardLohnart, umgebungVon } from "../domain/kalkulation.js";
|
||||
import { benenneUm, zahlDeutsch } from "../domain/formel.js";
|
||||
@@ -1109,7 +1110,12 @@ function briefkopf(d: Zeile, z: Zustand): string {
|
||||
const frei = a.status === "entwurf";
|
||||
const feld = feldBau(frei);
|
||||
const ort = [a.baustelle_strasse, [a.baustelle_plz, a.baustelle_ort].filter(Boolean).join(" ")].filter(Boolean).join(", ");
|
||||
const empf = a.bauherr_name ? `<b>${esc(a.bauherr_name)}</b>${a.bauherr_firma ? `<br>${esc(a.bauherr_firma)}` : ""}` : '<span class="fehler">kein Bauherr eingetragen</span>';
|
||||
// Anschrift mit z. Hd. und Briefanrede (0.49); festgeschrieben gilt der Stand vom Versand
|
||||
const stand = ((a.staende ?? []) as Zeile[]).filter((x) => x.empfaenger).at(-1);
|
||||
const em = (frei ? d.empfaenger : stand?.empfaenger ?? d.empfaenger) as Empfaenger | undefined;
|
||||
const empf = a.bauherr_name && em?.zeilen.length
|
||||
? em.zeilen.map((x, i) => (i === 0 ? `<b>${esc(x)}</b>` : x === em.zHd ? `<span class="am-zhd">${esc(x)}</span>` : esc(x))).join("<br>")
|
||||
: a.bauherr_name ? `<b>${esc(a.bauherr_name)}</b>${a.bauherr_firma ? `<br>${esc(a.bauherr_firma)}` : ""}` : '<span class="fehler">kein Bauherr eingetragen</span>';
|
||||
const festText = frei ? "" : `<p class="hinweis am-fest">Festgeschrieben${a.versendet_am ? `, versendet am ${dat(a.versendet_am)}` : ""}${a.entschieden_am ? `, ${a.status === "angenommen" ? "angenommen" : "abgelehnt"} am ${dat(a.entschieden_am)}` : ""}.</p>`;
|
||||
// solange eine Position offen ist, nur eine Zeile
|
||||
if (z.aktiv && d.positionen.some((p: Zeile) => p.id === z.aktiv && !p.textzeile)) {
|
||||
@@ -1121,6 +1127,7 @@ function briefkopf(d: Zeile, z: Zustand): string {
|
||||
<label><span class="l">Gültig bis (Bindefrist)</span><input type="date" data-k="angebote:x:bindefrist" value="${esc(a.bindefrist ?? "")}"${frei ? "" : " disabled"}></label></div>
|
||||
<label class="am-f"><span class="l">Betreff</span>${feld("angebote:x:betreff", a.betreff ?? "", { platz: `z. B. ${a.projekt_name}`, titel: "Betreff" })}</label>
|
||||
<div class="am-f"><span class="l">Leistungsort</span><div class="am-box">${ort ? esc(ort) : '<span class="hinweis">Baustelle im Projekt eintragen</span>'}</div></div></div>
|
||||
${em ? `<p class="am-anrede" title="Aus Kunde und Ansprechpartnern; ändern im Kontakt (Anrede, Titel) oder im Projekt (Ansprechpartner „Haupt“)">${esc(em.anrede)}</p>` : ""}
|
||||
${fliesstext("angebote:x:kopftext", a.kopftext, "Einleitung, z. B. Sehr geehrte Damen und Herren, vielen Dank für Ihre Anfrage …", frei, "Einleitung")}`;
|
||||
}
|
||||
|
||||
|
||||
170
src/web/app.ts
170
src/web/app.ts
@@ -1,5 +1,6 @@
|
||||
// Oberfläche. Die Reiter folgen dem Lastenheft; Projektseite und Listen nach Vorbild Plancraft.
|
||||
|
||||
import type { Empfaenger } from "../domain/brief.js";
|
||||
import { kalenderwoche, terminplanSeite } from "./gantt.js";
|
||||
import { terminplanHandy, vorgangImTerminplan } from "./terminhandy.js";
|
||||
import { type DialogPruefung, type Feld, type Zeile, MONATSNAMEN, api, bearbeiten, bestaetigen, dat, dialog, esc, euro, heute, hinweis,
|
||||
@@ -11,6 +12,7 @@ import { AUGE, AUGE_ZU, ansichtMerken, ansichtenLaden, eigenenWertMerken, eigene
|
||||
import { gesamtFortschritt } from "../domain/fortschritt.js";
|
||||
import { plusTage } from "../domain/datum.js";
|
||||
import { naechsteProjektNummer, nummerKern, nummerSchluessel, projektNummer, zerlege } from "../domain/nummer.js";
|
||||
import { PRIOS, PRIO_TEXT, type PrioErgebnis, TERMINDRUCK, prioErklaerung } from "../domain/prioritaet.js";
|
||||
import { type Eckdaten, type Reihenfolge, STANDARD_REIHENFOLGE, eckdatenRechnen, kostenSetzen, kostenVon, rohertragVon, vorn } from "../domain/eckdaten.js";
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { kolonneSeite, mitarbeiterSeite, personalSeite, subunternehmerSeite } from "./personal.js";
|
||||
@@ -22,42 +24,41 @@ import { leistungSeite, stammdatenSeite } from "./stammdaten.js";
|
||||
import { flussKachelnHtml, flussSvg, lageKopfHtml, liquiditaetSeite, zaehltHaken, zaehltSetzen } from "./liquiditaet.js";
|
||||
import { laufendeKostenSeite } from "./laufendekosten.js";
|
||||
import { jahresplanSeite } from "./jahresplan.js";
|
||||
import { kontaktSeite } from "./kontakt.js";
|
||||
import { ART_KURZ, ZUSTAENDIG } from "../domain/kontaktdaten.js";
|
||||
|
||||
|
||||
// ---------- Reiter ----------
|
||||
|
||||
const ROLLEN: [string, string][] = [
|
||||
["bauherr", "Bauherr"], ["subunternehmer", "Subunternehmer"], ["lieferant", "Lieferant"],
|
||||
["planer", "Planer"], ["mitarbeiter", "Mitarbeiter"], ["sonstige", "Sonstige"],
|
||||
];
|
||||
const KONTAKT_FELDER: Feld[] = [
|
||||
{ name: "name", titel: "Name", pflicht: true }, { name: "firma", titel: "Firma" },
|
||||
{ name: "rolle", titel: "Rolle", art: "auswahl", optionen: ROLLEN }, { name: "gewerk", titel: "Gewerk" },
|
||||
{ name: "telefon", titel: "Telefon" }, { name: "mobil", titel: "Mobil" }, { name: "email", titel: "E-Mail" },
|
||||
{ name: "strasse", titel: "Straße" }, { name: "plz", titel: "PLZ" }, { name: "ort", titel: "Ort" },
|
||||
{ name: "notiz", titel: "Notiz", art: "langtext" },
|
||||
];
|
||||
|
||||
async function kontakte(): Promise<void> {
|
||||
const neu = async () => (await bearbeiten("kontakte", "Neuer Kontakt", KONTAKT_FELDER, null)) && kontakte();
|
||||
seite("Kontakte", { text: "Neuer Kontakt", aktion: neu });
|
||||
const [zeilen, imHandy] = await Promise.all([api<Zeile[]>("kontakte"), api<Zeile[]>("kontakte-abgleich/kontakte").catch(() => [])]);
|
||||
// die Liste bleibt wie bisher (Henning, 08.11.2026); ein Klick öffnet die neue Kontaktmaske
|
||||
seite("Kontakte", { text: "Neuer Kontakt", aktion: () => { location.hash = "kontakt-neu"; } });
|
||||
const gruppeKnopf = document.createElement("button");
|
||||
gruppeKnopf.className = "neben";
|
||||
gruppeKnopf.textContent = "Neue Firma / Familie";
|
||||
gruppeKnopf.onclick = () => { location.hash = "kontakt-neu-gruppe"; };
|
||||
inhalt.querySelector(".kopf .haupt")?.before(gruppeKnopf);
|
||||
const [zeilen, imHandy, rollen, zug] = await Promise.all([api<Zeile[]>("kontakte"), api<Zeile[]>("kontakte-abgleich/kontakte").catch(() => []), api<Zeile[]>("kontakt-rollen"), api<Zeile[]>("kontakt-zugehoerigkeiten")]);
|
||||
const namen = new Map(zeilen.map((k) => [k.id, k.name as string]));
|
||||
// Firma: eingetragene Firma, sonst der erste übergeordnete Kontakt
|
||||
const firma = (z: Zeile) => (z.art ? "" : z.firma || namen.get(zug.find((x) => x.person_id === z.id)?.gruppe_id) || "");
|
||||
const handy = new Map(imHandy.map((h) => [h.kontakt_id, h.geloescht]));
|
||||
const rolle = Object.fromEntries(ROLLEN);
|
||||
const rolle = Object.fromEntries(rollen.map((r) => [r.id, r.name]));
|
||||
const rollenText = (z: Zeile) => (z.rollen ?? []).map((r: string) => rolle[r] ?? r).join(", ");
|
||||
inhalt.appendChild(liste({
|
||||
schluessel: "kontakte", einheit: ["Kontakt", "Kontakte"], vorgabe: { sort: [["name", "auf"]] },
|
||||
spalten: [
|
||||
{ id: "name", titel: "Name", wert: (z) => esc(z.name) },
|
||||
{ id: "firma", titel: "Firma", wert: (z) => esc(z.firma), klasse: "optional" },
|
||||
{ id: "rolle", titel: "Rolle", wert: (z) => esc(rolle[z.rolle]) },
|
||||
{ id: "firma", titel: "Firma", wert: (z) => esc(firma(z)), text: firma, klasse: "optional" },
|
||||
{ id: "rolle", titel: "Rolle", wert: (z) => esc(rollenText(z)), text: rollenText },
|
||||
{ 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: "telefon", titel: "Telefon", wert: (z) => (z.telefon ?? z.mobil ? `<a href="tel:${esc(z.telefon ?? z.mobil)}">${esc(z.telefon ?? z.mobil)}</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(),
|
||||
zeilen, klick: (z) => { location.hash = `kontakt-${z.id}`; },
|
||||
}));
|
||||
}
|
||||
|
||||
@@ -73,23 +74,38 @@ const VERTRAGSARTEN: [string, string][] = [["", "–"], ["vob", "VOB/B"], ["bgb"
|
||||
|
||||
async function projektFelder(): Promise<Feld[]> {
|
||||
const kontaktListe = await api<Zeile[]>("kontakte");
|
||||
const sortiert = [...kontaktListe].sort((a, b) => Number(b.rolle === "bauherr") - Number(a.rolle === "bauherr") || a.name.localeCompare(b.name, "de"));
|
||||
// übergeordnete Kontakte (Firma, Familie, Ehepaar …) zuerst, dann Bauherren, dann alle anderen (0.47)
|
||||
const rang = (k: Zeile) => (k.art ? 0 : (k.rollen ?? []).includes("bauherr") ? 1 : 2);
|
||||
const sortiert = [...kontaktListe].sort((a, b) => rang(a) - rang(b) || a.name.localeCompare(b.name, "de"));
|
||||
return [
|
||||
{ name: "nummer", titel: "Nummer", pflicht: true }, { name: "bezeichnung", titel: "Bezeichnung", pflicht: true },
|
||||
{ name: "status", titel: "Status", art: "auswahl", optionen: STATUS },
|
||||
{ name: "bauherr_id", titel: "Kunde (Bauherr)", art: "auswahl", optionen: [["", "–"], ...sortiert.map((k): [string, string] => [k.id, k.name])],
|
||||
{ name: "bauherr_id", titel: "Kunde (Rechnung an)", art: "auswahl", optionen: [["", "–"], ...sortiert.map((k): [string, string] => [k.id, k.art ? `${k.name} (${ART_KURZ[k.art] ?? ""})` : 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" },
|
||||
// Priorität A/B/C (Henning, 08.11.2026): leer = Vorschlag aus Ertrag, Kunde und Dringlichkeit
|
||||
{ name: "prioritaet", titel: "Priorität", art: "auswahl", optionen: [["", "Vorschlag des Programms"], ...PRIOS.map((x): [string, string] => [x, PRIO_TEXT[x]])],
|
||||
hilfe: "Leer lassen: das Programm schlägt A, B oder C vor (Ertrag je Stunde, Kunde, Dringlichkeit)." },
|
||||
{ name: "frist", titel: "Fertig bis (Frist)", art: "datum" },
|
||||
{ name: "termindruck", titel: "Termindruck", art: "auswahl", optionen: TERMINDRUCK },
|
||||
// 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) });
|
||||
@@ -111,6 +127,10 @@ function nummerPruefung(alle: Zeile[], eigeneId: string | null): DialogPruefung
|
||||
};
|
||||
}
|
||||
|
||||
/** Priorität als farbige Marke; selbst gesetzt mit Punkt, der Vorschlag steht im Tooltip */
|
||||
export const prioMarke = (x: PrioErgebnis | null | undefined) =>
|
||||
x ? `<span class="prio prio-${x.prioritaet}${x.selbst ? " selbst" : ""}" title="${esc(prioErklaerung(x))}">${x.prioritaet}</span>` : "";
|
||||
|
||||
async function projekte(): Promise<void> {
|
||||
const neu = async () => {
|
||||
// Vorschlag: nächste freie Nummer im Jahr, A- für Anfrage und Angebot, P- ab Auftrag (Henning, 21.10.2026)
|
||||
@@ -128,13 +148,15 @@ 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}`;
|
||||
};
|
||||
seite("Projekte", { text: "Neues Projekt", aktion: neu });
|
||||
if (modulAn("angebote")) inhalt.querySelector(".kopf h1")!.insertAdjacentHTML("afterend", '<a class="neben" href="#angebote">Angebote</a>');
|
||||
const [zeilen, kontaktListe, zahlungen] = await Promise.all([api<Zeile[]>("projekte"), api<Zeile[]>("kontakte"), api<Zeile[]>("zahlungen")]);
|
||||
const [zeilen, kontaktListe, zahlungen, prios] = await Promise.all([api<Zeile[]>("projekte"), api<Zeile[]>("kontakte"), api<Zeile[]>("zahlungen"), api<PrioErgebnis[]>("prioritaeten")]);
|
||||
const prio = new Map(prios.map((x) => [x.id, x]));
|
||||
const prioRang = (z: Zeile) => { const x = prio.get(z.id); return x ? PRIOS.indexOf(x.prioritaet) + 1 : 9; };
|
||||
// bereits abgerechnet = Raten mit gestellter oder bezahlter Rechnung, netto; offen = Auftragswert minus abgerechnet (Henning, 27.10.2026)
|
||||
const abgerechnetJe = new Map<string, number>();
|
||||
for (const r of zahlungen) if (r.status === "gestellt" || r.status === "bezahlt") abgerechnetJe.set(r.projekt_id, (abgerechnetJe.get(r.projekt_id) ?? 0) + Number(r.netto));
|
||||
@@ -150,6 +172,8 @@ async function projekte(): Promise<void> {
|
||||
{ id: "kunde", titel: "Kunde", wert: (z) => esc(name[z.bauherr_id] ?? ""), klasse: "optional" },
|
||||
{ id: "ort", titel: "Ort", wert: (z) => esc(z.baustelle_ort ?? ""), klasse: "optional" },
|
||||
{ id: "status", titel: "Status", handy: "rechts", wert: (z) => etikett(z.status), sortWert: (z) => statusRang[z.status] ?? 99 },
|
||||
// Priorität A/B/C (Henning, 08.11.2026): Vorschlag des Programms, auf der Projektseite änderbar
|
||||
{ id: "prio", titel: "Priorität", handy: "links", wert: (z) => prioMarke(prio.get(z.id)), text: (z) => prio.get(z.id)?.prioritaet ?? "–", sortWert: prioRang },
|
||||
{ id: "umsatz", titel: "Auftragswert", art: "zahl", wert: (z) => euro(z.umsatz_netto), sortWert: (z) => z.umsatz_netto, klasse: "zahl optional" },
|
||||
{ id: "abgerechnet", titel: "Bereits abgerechnet", art: "zahl", wert: (z) => euro(abgerechnet(z)), sortWert: abgerechnet, klasse: "zahl optional" },
|
||||
{ id: "offen", titel: "Offener Auftragswert", art: "zahl", wert: (z) => euro(offen(z)), sortWert: offen, klasse: "zahl optional" },
|
||||
@@ -212,6 +236,9 @@ async function projektSeite(id: string): Promise<void> {
|
||||
api<Zeile[]>("zahlungen"), api<Zeile[]>("kosten"), aufgabenDaten(), api<Zeile[]>("aufgaben"), api<Record<string, number>>("zeiten/projekte"),
|
||||
api<Zeile[]>(`angebote-liste?projekt_id=${id}`), api<Zeile>("einstellungen").catch(() => null),
|
||||
]);
|
||||
const [alleAp, zug] = await Promise.all([api<Zeile[]>("projekt-ansprechpartner"), api<Zeile[]>("kontakt-zugehoerigkeiten")]);
|
||||
const eigeneAp = alleAp.filter((a) => a.projekt_id === id);
|
||||
const prio = ((plan.projekte as Zeile[]).find((x) => x.id === id)?.prio ?? null) as PrioErgebnis | null;
|
||||
const neuLaden = () => projektSeite(id);
|
||||
const kontakt = Object.fromEntries(kontaktListe.map((k) => [k.id, k]));
|
||||
const kunde = kontakt[p.bauherr_id];
|
||||
@@ -221,12 +248,25 @@ async function projektSeite(id: string): Promise<void> {
|
||||
const eigeneKosten = kosten.filter((k) => k.projekt_id === id);
|
||||
const eigeneAufgaben = alleAufgaben.filter((a) => a.projekt_id === id);
|
||||
const umsatz = p.umsatz_netto, kostenGesamt = kostenSumme(p);
|
||||
// Ansprechpartner im Projekt (0.47): Haupt, Rechnungen, Baustelle, Planung
|
||||
const ZUST = Object.fromEntries(ZUSTAENDIG);
|
||||
function ansprechpartnerHtml(): string {
|
||||
return `<div class="pj-ap"><p class="pj-ap-titel">Ansprechpartner</p>${eigeneAp.map((a) => { const k = kontakt[a.kontakt_id]; const z = zug.find((x) => x.person_id === a.kontakt_id && x.gruppe_id === p.bauherr_id);
|
||||
const nr = k?.mobil ?? k?.telefon;
|
||||
return `<div class="pj-ap-zeile"><a href="#kontakt-${esc(a.kontakt_id)}"><b>${esc(k?.name ?? "?")}${(a.zustaendig ?? []).includes("haupt") ? " ★" : ""}</b><small>${esc([z?.funktion, nr].filter(Boolean).join(" · "))}</small></a>
|
||||
${(a.zustaendig ?? []).map((x: string) => `<span class="kt-zust ${esc(x)}">${esc(ZUST[x] ?? x)}</span>`).join("")}<button class="kt-punkte" data-ap="${esc(a.id)}" aria-label="Ansprechpartner bearbeiten">⋯</button></div>`; }).join("")}
|
||||
<button class="verweis" data-a="ap-neu">+ Ansprechpartner</button>
|
||||
${p.bauherr_id ? '<button class="verweis" data-a="rechnung-an">Rechnungsanschrift</button><div class="pj-rechnung-an" hidden></div>' : ""}</div>`;
|
||||
}
|
||||
|
||||
inhalt.innerHTML = `${hinweisHtml()}
|
||||
<div class="kopf projekt-kopf"><a class="neben zurueck" href="#projekte" aria-label="Zurück zur Projektliste">←</a>
|
||||
<h1>${esc(p.bezeichnung)} <span class="nummer">(${esc(p.nummer)})</span></h1>
|
||||
<select id="p-status" class="etikett ${esc(p.status)}" aria-label="Status">${optionenHtml(STATUS, p.status)}</select>
|
||||
${prio ? `<select id="p-prio" class="prio-wahl prio-${prio.prioritaet}${prio.selbst ? " selbst" : ""}" aria-label="Priorität" title="${esc(prioErklaerung(prio))}">${optionenHtml(
|
||||
[["", `Priorität ${prio.vorschlag} (Vorschlag)`], ...PRIOS.map((x): [string, string] => [x, `Priorität ${PRIO_TEXT[x]}`])], prio.selbst ? prio.prioritaet : "")}</select>` : ""}
|
||||
<button class="neben" data-a="bearbeiten">Bearbeiten</button></div>
|
||||
${prio ? `<p class="prio-grund">${esc(prioErklaerung(prio))}</p>` : ""}
|
||||
${kunde?.telefon || ortZeile(p) ? `<div class="handy-aktionen nur-handy">${kunde?.telefon ? `<a class="neben" href="tel:${esc(kunde.telefon)}">Anrufen</a>` : ""}${ortZeile(p) ? `<a class="neben" href="https://www.google.com/maps/dir/?api=1&destination=${encodeURIComponent(ortZeile(p))}" target="_blank" rel="noopener">Navigation</a>` : ""}</div>` : ""}
|
||||
<nav class="handy-reiter nur-handy" aria-label="Bereiche">${([["ueberblick", "Überblick"], ["ablauf", "Ablauf"], ["geld", "Geld"], ["ablage", "Ablage"]] as const)
|
||||
.map(([r, titel]) => `<button data-hr="${r}">${titel}</button>`).join("")}</nav>
|
||||
@@ -292,8 +332,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>`;
|
||||
@@ -305,9 +343,9 @@ async function projektSeite(id: string): Promise<void> {
|
||||
${kachel("kunde", "Kunde", p.status === "intern" && !kunde
|
||||
? '<p class="gross">Intern</p><p class="hinweis">Eigener Betrieb, kein Kunde</p>'
|
||||
: kunde
|
||||
? `<p><a href="#kontakte" class="gross">${esc(kunde.name)}</a>${kunde.firma ? `<br>${esc(kunde.firma)}` : ""}</p>
|
||||
<p class="hinweis">${[kunde.telefon && `<a href="tel:${esc(kunde.telefon)}">${esc(kunde.telefon)}</a>`, kunde.email && esc(kunde.email)].filter(Boolean).join("<br>")}</p>`
|
||||
: '<p><button class="verweis" data-a="bearbeiten">Kunde zuordnen</button></p>')}
|
||||
? `<p><a href="#kontakt-${esc(kunde.id)}" class="gross">${esc(kunde.name)}</a>${kunde.art ? ` <span class="kt-art">${esc(ART_KURZ[kunde.art] ?? "")}</span>` : kunde.firma ? `<br>${esc(kunde.firma)}` : ""}</p>
|
||||
<p class="hinweis">${[kunde.telefon && `<a href="tel:${esc(kunde.telefon)}">${esc(kunde.telefon)}</a>`, kunde.email && esc(kunde.email)].filter(Boolean).join("<br>")}</p>${ansprechpartnerHtml()}`
|
||||
: `<p><button class="verweis" data-a="bearbeiten">Kunde zuordnen</button></p>${ansprechpartnerHtml()}`)}
|
||||
<section class="kachel beschreibung"><h3>${symbolKachel("beschreibung")}Beschreibung</h3>
|
||||
<div class="text zelle-text" data-a="beschreibung" title="Klicken zum Bearbeiten">${p.notiz ? esc(p.notiz) : '<span class="hinweis">Keine Beschreibung. Klicken zum Schreiben.</span>'}</div></section>
|
||||
${kachel("zeitraum", "Zeitraum", anfang
|
||||
@@ -357,7 +395,7 @@ async function projektSeite(id: string): Promise<void> {
|
||||
<dt>Vertrag</dt><dd>${p.vertragsart ? (p.vertragsart === "vob" ? "VOB/B" : "BGB") : "–"}${p.abnahme_am ? ` · Abnahme ${dat(p.abnahme_am)}` : ""}</dd></dl>
|
||||
<p class="hinweis">Der Vergleich Soll gegen Ist je Kostenart (Lohn, Material, Geräte, Fremdleistung) mit Zeiterfassung und Eingangsrechnungen kommt mit Stufe 3c. Bis dahin stehen hier die geplanten Einzelkosten; die Pauschalen änderst du unter „Bearbeiten“.</p>
|
||||
<div class="kosten-kopf"><h3>Einzelkosten</h3><button class="neben" data-a="kosten-neu">+ Kosten</button></div><div class="kosten-liste"></div></div>`;
|
||||
const lieferanten = kontaktListe.filter((k) => ["lieferant", "subunternehmer"].includes(k.rolle));
|
||||
const lieferanten = kontaktListe.filter((k) => (k.rollen ?? []).some((r: string) => r === "lieferant" || r === "subunternehmer"));
|
||||
const felder: Feld[] = [
|
||||
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "art", titel: "Art", art: "auswahl", optionen: KOSTENARTEN },
|
||||
{ name: "netto", titel: "Betrag netto", art: "euro", pflicht: true }, { name: "termin", titel: "Termin", art: "datum", pflicht: true },
|
||||
@@ -551,7 +589,7 @@ async function projektSeite(id: string): Promise<void> {
|
||||
const letzterVorgang = (aid: string) => vorgaenge.filter((v: Zeile) => v.abschnitt_id === aid).sort((a: Zeile, b: Zeile) => String(b.ende).localeCompare(String(a.ende)))[0];
|
||||
const abschnittVon = (k: Zeile) => (k.vorgang_id ? abschnitte.find((a: Zeile) => a.id === vorgaenge.find((v: Zeile) => v.id === k.vorgang_id)?.abschnitt_id) : undefined);
|
||||
const mitVorgang = abschnitte.filter((a: Zeile) => ersterVorgang(a.id));
|
||||
const lieferanten = kontaktListe.filter((k) => ["lieferant", "subunternehmer"].includes(k.rolle));
|
||||
const lieferanten = kontaktListe.filter((k) => (k.rollen ?? []).some((r: string) => r === "lieferant" || r === "subunternehmer"));
|
||||
const felder: Feld[] = [
|
||||
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "art", titel: "Art", art: "auswahl", optionen: KOSTENARTEN },
|
||||
{ name: "kontakt_id", titel: "Lieferant / Subunternehmer", art: "auswahl", optionen: [["", "–"], ...lieferanten.map((k): [string, string] => [k.id, k.name])] },
|
||||
@@ -683,14 +721,62 @@ async function projektSeite(id: string): Promise<void> {
|
||||
b.setAttribute("aria-expanded", String(offen)); b.title = offen ? "Eckdaten einklappen" : "Eckdaten aufklappen";
|
||||
return;
|
||||
}
|
||||
const apId = ziel.closest<HTMLElement>("[data-ap]")?.dataset.ap;
|
||||
const zustFeld: Feld = { name: "zustaendig", titel: "Zuständig für", art: "auswahl", optionen: [["", "–"], ...ZUSTAENDIG] };
|
||||
if (apId) {
|
||||
const ap = eigeneAp.find((x) => x.id === apId)!;
|
||||
const r = await dialog(`Ansprechpartner: ${kontakt[ap.kontakt_id]?.name ?? ""}`, [zustFeld], { zustaendig: (ap.zustaendig ?? [])[0] ?? "" }, true);
|
||||
if (!r) return;
|
||||
if (r.aktion === "loeschen") await api(`projekt-ansprechpartner/${apId}`, "DELETE");
|
||||
else await api(`projekt-ansprechpartner/${apId}`, "PATCH", { zustaendig: r.daten.zustaendig ? [r.daten.zustaendig] : [] });
|
||||
return neuLaden();
|
||||
}
|
||||
// Rechnungsanschrift mit z. Hd. und Anrede zum Übernehmen in das Rechnungsprogramm (0.49)
|
||||
if (a === "rechnung-an") {
|
||||
const box = inhalt.querySelector<HTMLElement>(".pj-rechnung-an")!;
|
||||
if (!box.hidden) { box.hidden = true; return; }
|
||||
const em = await api<Empfaenger>(`projekte/${id}/empfaenger?zweck=rechnung`);
|
||||
const text = `${em.zeilen.join("\n")}\n\n${em.anrede}`;
|
||||
box.innerHTML = `<pre>${esc(text)}</pre><button class="neben" data-a="rechnung-an-kopieren">Kopieren</button>`;
|
||||
box.hidden = false;
|
||||
box.dataset.text = text;
|
||||
return;
|
||||
}
|
||||
if (a === "rechnung-an-kopieren") {
|
||||
const box = inhalt.querySelector<HTMLElement>(".pj-rechnung-an")!;
|
||||
try { await navigator.clipboard.writeText(box.dataset.text ?? ""); box.querySelector("button")!.textContent = "Kopiert ✓"; }
|
||||
catch { const r = document.createRange(); r.selectNodeContents(box.querySelector("pre")!); getSelection()?.removeAllRanges(); getSelection()?.addRange(r); }
|
||||
return;
|
||||
}
|
||||
if (a === "ap-neu") {
|
||||
// die Leute vom Kunden zuerst (Henning, 08.11.2026)
|
||||
const vomKunden = zug.filter((z) => z.gruppe_id === p.bauherr_id).map((z) => z.person_id as string);
|
||||
const frei = kontaktListe.filter((k) => !eigeneAp.some((x) => x.kontakt_id === k.id) && k.id !== p.bauherr_id);
|
||||
const sortiert = [...frei].sort((x, y) => Number(vomKunden.includes(y.id)) - Number(vomKunden.includes(x.id)) || x.name.localeCompare(y.name, "de"));
|
||||
const r = await dialog("Ansprechpartner hinzufügen", [
|
||||
{ name: "kontakt_id", titel: "Kontakt", art: "auswahl", pflicht: true, optionen: [["", "– wählen –"], ...sortiert.map((k): [string, string] => {
|
||||
const z = zug.find((x) => x.person_id === k.id && x.gruppe_id === p.bauherr_id);
|
||||
return [k.id, z ? `${k.name}${z.funktion ? ` · ${z.funktion}` : ""} (beim Kunden)` : k.firma ? `${k.name} · ${k.firma}` : k.name]; })],
|
||||
neu: { text: "+ Neue Person …", titel: "Neue Person anlegen", felder: [{ name: "name", titel: "Name", pflicht: true }, { name: "telefon", titel: "Telefon" }, { name: "mobil", titel: "Mobil" }, { name: "email", titel: "E-Mail" }],
|
||||
anlegen: async (d) => {
|
||||
const k = await api<Zeile>("kontakte", "POST", d);
|
||||
if (kunde?.art) await api("kontakt-zugehoerigkeiten", "POST", { gruppe_id: kunde.id, person_id: k.id });
|
||||
return [k.id, k.name];
|
||||
} } },
|
||||
zustFeld,
|
||||
], { zustaendig: eigeneAp.length ? "" : "haupt" }, false);
|
||||
if (r?.aktion !== "speichern" || !r.daten.kontakt_id) return;
|
||||
await api("projekt-ansprechpartner", "POST", { projekt_id: id, kontakt_id: r.daten.kontakt_id, zustaendig: r.daten.zustaendig ? [r.daten.zustaendig] : [], reihenfolge: eigeneAp.length });
|
||||
return neuLaden();
|
||||
}
|
||||
if (a === "aufgabe-neu") return (await bearbeiten("aufgaben", "Neue Aufgabe", aufgabenDat.felder, null, { projekt_id: id, kontakt_id: p.bauherr_id ?? null })) && neuLaden();
|
||||
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();
|
||||
}
|
||||
@@ -725,6 +811,8 @@ async function projektSeite(id: string): Promise<void> {
|
||||
if (r.ordner_fehler) hinweis.text = r.ordner_fehler;
|
||||
neuLaden();
|
||||
};
|
||||
const prioWahl = inhalt.querySelector<HTMLSelectElement>("#p-prio");
|
||||
if (prioWahl) prioWahl.onchange = async () => { await api(`projekte/${id}`, "PATCH", { prioritaet: prioWahl.value || null }); neuLaden(); };
|
||||
}
|
||||
|
||||
async function terminplan(): Promise<void> {
|
||||
@@ -1071,7 +1159,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>')}
|
||||
@@ -1566,6 +1654,8 @@ async function zeige(): Promise<void> {
|
||||
location.hash = "uebersicht";
|
||||
return;
|
||||
}
|
||||
// Kontaktmaske (0.47): #kontakt-<id>, #kontakt-neu, #kontakt-neu-gruppe
|
||||
const kontaktWahl = /^kontakt-(neu|neu-gruppe|[0-9a-f-]{36})$/.exec(id)?.[1];
|
||||
// Projektseite: #projekt-<id>, gehört zum Reiter Projekte; Mitarbeiter: #ablage-<id>
|
||||
const treffer = /^projekt-([0-9a-f-]{36})(?:-(dokumente|berichte|ablage|zahlungen))?$/.exec(id);
|
||||
const ablage = /^ablage-([0-9a-f-]{36})$/.exec(id)?.[1];
|
||||
@@ -1586,12 +1676,14 @@ async function zeige(): Promise<void> {
|
||||
const zuStamm = vorlage || leistung || sdTeil;
|
||||
const projekt = treffer?.[1];
|
||||
if (treffer?.[2]) projektTeil = treffer[2];
|
||||
const reiter = REITER.find(([r]) => r === (zuProjekte ? "projekte" : zuPersonal ? "personal" : zuStamm ? "stammdaten" : id)) ?? REITER[0]!;
|
||||
const reiter = REITER.find(([r]) => r === (zuProjekte ? "projekte" : zuPersonal ? "personal" : zuStamm ? "stammdaten" : kontaktWahl ? "kontakte" : 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 {
|
||||
await (ablage ? ablageSeite(ablage)
|
||||
await (kontaktWahl && reiter[0] === "kontakte" ? kontaktSeite(kontaktWahl)
|
||||
: ablage ? ablageSeite(ablage)
|
||||
: mitarbeiter && reiter[0] === "personal" ? mitarbeiterSeite(mitarbeiter, sitzung?.benutzer?.rolle === "inhaber")
|
||||
: kolonne && reiter[0] === "personal" ? kolonneSeite(kolonne)
|
||||
: sub && reiter[0] === "personal" ? subunternehmerSeite(sub)
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
// anderen Vorgänge sichtbar bleiben; die Bearbeitungsspalten lassen sich ausblenden.
|
||||
// Die Neuplanung der Nachfolger macht der Server.
|
||||
|
||||
import { PRIOS, PRIO_TEXT, type Prio, prioErklaerung } from "../domain/prioritaet.js";
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { bezugText, leseBezug } from "../domain/bezug.js";
|
||||
import { type Datum, formatDatum, plusTage, tageZwischen, wochentag, montagDerWoche } from "../domain/datum.js";
|
||||
@@ -219,7 +220,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
const werAlle = (b: Zeile): (string | undefined)[] => [wer(b), ...((b.mitglieder as string[] | undefined) ?? [])];
|
||||
// Filtern und Ausblenden wie in den Tabellen; die Reihenfolge bleibt die gezogene (Henning, 20.10.2026)
|
||||
const ansicht = h.ansicht.lies("terminplan");
|
||||
const personAus = ansicht.filter.person ?? [], projektAus = ansicht.filter.projekt ?? [];
|
||||
const personAus = ansicht.filter.person ?? [], projektAus = ansicht.filter.projekt ?? [], prioAus = ansicht.filter.prio ?? [];
|
||||
const ausgeblendet = new Set(ansicht.aus);
|
||||
const filter = personAus.length > 0;
|
||||
const passt = (v: Zeile) => {
|
||||
@@ -234,7 +235,10 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
const personWerte: FilterWert[] = [...[...personen].sort((a, b) => a[1].localeCompare(b[1], "de")).map(([id, name]) => ({ wert: id, text: name, anzahl: new Set(plan.besetzungen.filter((b) => werAlle(b).includes(id)).map((b) => b.vorgang_id)).size })),
|
||||
{ wert: OHNE, text: OHNE, anzahl: plan.vorgaenge.filter((v) => !plan.besetzungen.some((b) => b.vorgang_id === v.id)).length }];
|
||||
const projektWerte: FilterWert[] = projekteAlle.map((p) => ({ wert: p.id, text: `${p.nummer} ${p.bezeichnung}`, anzahl: 0 }));
|
||||
const filterWerte: Record<string, FilterWert[]> = { person: personWerte, projekt: projektWerte };
|
||||
// Priorität A/B/C (Henning, 08.11.2026); Projekte ohne Priorität (abgeschlossen, intern) unter „ohne“
|
||||
const prioVon = (p: Zeile) => (p.prio?.prioritaet as string | undefined) ?? "ohne";
|
||||
const prioWerte: FilterWert[] = [...PRIOS, "ohne"].map((x) => ({ wert: x, text: x === "ohne" ? "ohne Priorität" : PRIO_TEXT[x as Prio], anzahl: projekteAlle.filter((p) => prioVon(p) === x).length }));
|
||||
const filterWerte: Record<string, FilterWert[]> = { person: personWerte, projekt: projektWerte, prio: prioWerte };
|
||||
const filterKnopf = (id: string, titel: string, aus: string[]) => aus.length
|
||||
? `<span class="chip"><button class="chip-text" data-filter="${id}" title="${titel} filtern">${esc(titel)}: ${esc(h.filterText(filterWerte[id]!, aus))}</button><button data-filter-weg="${id}" aria-label="Filter ${titel} entfernen">✕</button></span>`
|
||||
: `<button class="neben" data-filter="${id}" aria-haspopup="true">${titel} ▾</button>`;
|
||||
@@ -245,13 +249,13 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
leiste.innerHTML = `${Object.keys(ZOOM).map((z) => `<button class="neben${ZOOM[z] === W ? " an" : ""}" data-zoom="${z}">${z[0]!.toUpperCase() + z.slice(1)}</button>`).join("")}
|
||||
<button class="neben" data-a="heute">Heute</button>
|
||||
<button class="neben" data-a="zurueck" title="Letzte Änderung zurücknehmen (Strg+Z)"${verlauf.length ? "" : " disabled"}>↶ Rückgängig</button>
|
||||
${filterKnopf("projekt", "Projekte", projektAus)}${filterKnopf("person", "Personal", personAus)}
|
||||
${filterKnopf("projekt", "Projekte", projektAus)}${filterKnopf("prio", "Priorität", prioAus)}${filterKnopf("person", "Personal", personAus)}
|
||||
${anzahlAus ? `<span class="g-aus">${anzahlAus} ausgeblendet · <button class="verweis" data-a="aus-zeigen">${ausZeigen ? "wieder verbergen" : "einblenden"}</button>${ausZeigen ? ' · <button class="verweis" data-a="alle-ein">alle wieder einblenden</button>' : ""}</span>` : ""}
|
||||
<label class="schalter"><input type="checkbox" data-a="fertige"${mitFertigen ? " checked" : ""}> Abgeschlossene zeigen</label>
|
||||
<span class="hinweis">In eine Zelle klicken zum Bearbeiten: Enter speichert und geht eine Zeile tiefer, Tab eine Spalte weiter, Esc bricht ab. Zeile an der Nummer anfassen und verschieben. Spaltenbreite am Spaltenkopf ziehen, die Trennleiste blendet Spalten aus, an der Zeitskala ziehen zoomt. Balken ziehen verschiebt, rechter Rand ändert die Dauer. Freitag ist Reserve; ziehst du einen Balken auf einen Freitag oder trägst ihn als Anfang oder Ende ein, fragt das Programm, ob er für diesen Vorgang freigegeben wird; Meilensteine und Rauten (Raten, Ausgaben, Aufgaben) ebenso. Weitere Freitage: Klick in „% erl.“ oder Rechtsklick auf den Balken.</span>
|
||||
<span class="fehler g-meldung" role="status"></span>`;
|
||||
|
||||
const projekte = projekteAlle.filter((p) => !projektAus.includes(p.id));
|
||||
const projekte = projekteAlle.filter((p) => !projektAus.includes(p.id) && !prioAus.includes(prioVon(p)));
|
||||
// gleiche Farbe wie am Handy und in der Übersicht: nach der Stelle im ganzen Plan, nicht in der gefilterten Liste
|
||||
const farbe = (p: Zeile, _i: number) => projektFarbe(p as { id: string }, plan.projekte as { id: string; status?: string }[]);
|
||||
|
||||
@@ -448,7 +452,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
const raten = (plan.zahlungen ?? []).filter((z) => z.projekt_id === o.id);
|
||||
const ausgaben = postenVon(o.id).kosten;
|
||||
const ausText = ausgaben.length ? ` <button class="verweis g-raten aus" data-raten="${o.id}" title="Eingangsrechnungen im Zahlungsplan öffnen">${ausgaben.length} ${ausgaben.length === 1 ? "Ausgabe" : "Ausgaben"}</button>` : "";
|
||||
links = `${nr}<span class="name ebene0" style="box-shadow:inset 4px 0 0 ${r.farbe}">${klapp}<span class="text" title="${esc(o.bezeichnung)}">${esc(o.nummer)} ${esc(o.bezeichnung)}${o.bauherr ? ` <small>${esc(o.bauherr)}</small>` : ""}</span>
|
||||
links = `${nr}<span class="name ebene0" style="box-shadow:inset 4px 0 0 ${r.farbe}">${klapp}<span class="text" title="${esc(o.bezeichnung)}">${o.prio ? `<span class="prio prio-${esc(o.prio.prioritaet)}${o.prio.selbst ? " selbst" : ""}" title="${esc(prioErklaerung(o.prio))}">${esc(o.prio.prioritaet)}</span> ` : ""}${esc(o.nummer)} ${esc(o.bezeichnung)}${o.bauherr ? ` <small>${esc(o.bauherr)}</small>` : ""}</span>
|
||||
<span class="aktionen"><button class="plus" data-neu-abschnitt="${o.id}" title="Abschnitt hinzufügen">+</button><button class="auge-g" data-ausblenden="${o.id}" title="${ausgeblendet.has(o.id) ? "Wieder einblenden" : "Zeile ausblenden"}">${ausgeblendet.has(o.id) ? h.auge[0] : h.auge[1]}</button></span></span>
|
||||
${dauerZelle()}<span></span>${datumZelle(r.von)}${datumZelle(r.bis)}${standZelle(r)}
|
||||
<span>${raten.length ? `<button class="verweis g-raten" data-raten="${o.id}" title="Zahlungsplan öffnen">€ ${raten.length} ${raten.length === 1 ? "Rate" : "Raten"}</button>`
|
||||
|
||||
373
src/web/kontakt.ts
Normal file
373
src/web/kontakt.ts
Normal file
@@ -0,0 +1,373 @@
|
||||
// Kontaktmaske wie in der Nextcloud und übergeordnete Kontakte (Henning, 08.11.2026, Entwürfe in kontakte/maske/).
|
||||
// Am PC öffnet ein Kontakt direkt die Maske; am Handy erst die Ansicht zum Anrufen, „Bearbeiten“ zeigt dieselbe Maske.
|
||||
import {
|
||||
ADRESS_TYPEN, ARTEN, ART_KURZ, type Anschrift, EMAIL_TYPEN, type Nummer, TELEFON_TYPEN, TYP_TEXT, ZUSTAENDIG, adressZeile, kuerzel,
|
||||
} from "../domain/kontaktdaten.js";
|
||||
import { type Feld, type Zeile, api, bestaetigen, dialog, esc, hinweis, hinweisHtml, inhalt, istHandy, optionenHtml, vorschlaegeAn } from "./ui.js";
|
||||
|
||||
const ZUST_TEXT = Object.fromEntries(ZUSTAENDIG);
|
||||
const ART_TEXT = Object.fromEntries(ARTEN);
|
||||
const ANREDEN: [string, string][] = [["", "–"], ["Herr", "Herr"], ["Frau", "Frau"], ["Familie", "Familie"], ["Eheleute", "Eheleute"]];
|
||||
const leereAdresse = (typ = "privat"): Anschrift => ({ typ, strasse: "", zusatz: "", plz: "", ort: "", region: "", land: "", postfach: "", haupt: false });
|
||||
const zustText = (z: string[] | undefined) => (z ?? []).map((x) => ZUST_TEXT[x] ?? x).join(", ");
|
||||
const haupt = <T extends { haupt?: boolean }>(l: T[] | undefined) => (l ?? []).find((x) => x.haupt) ?? (l ?? [])[0];
|
||||
const telLink = (nr: string) => `tel:${nr.replace(/[^\d+]/g, "")}`;
|
||||
const karteLink = (a: Anschrift) => `https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(adressZeile(a))}`;
|
||||
const bild = (name: string, gruppe: boolean, klein = false) => `<span class="kt-bild${gruppe ? " gruppe" : ""}${klein ? " klein" : ""}" aria-hidden="true">${esc(kuerzel(name || "?"))}</span>`;
|
||||
|
||||
/** Seite eines Kontakts: #kontakt-<id>, #kontakt-neu (Person), #kontakt-neu-gruppe (übergeordnet) */
|
||||
export async function kontaktSeite(wahl: string, bearbeiten = !istHandy()): Promise<void> {
|
||||
const [alle, zug, rollen, projekte, ap, imHandy, abgleich] = await Promise.all([
|
||||
api<Zeile[]>("kontakte"), api<Zeile[]>("kontakt-zugehoerigkeiten"), api<Zeile[]>("kontakt-rollen"),
|
||||
api<Zeile[]>("projekte"), api<Zeile[]>("projekt-ansprechpartner"),
|
||||
api<Zeile[]>("kontakte-abgleich/kontakte").catch(() => [] as Zeile[]), api<Zeile>("kontakte-abgleich").catch(() => null),
|
||||
]);
|
||||
const id = /^[0-9a-f-]{36}$/.test(wahl) ? wahl : null;
|
||||
// ein neuer Kontakt beginnt auch am Handy in der Maske
|
||||
if (!id) bearbeiten = true;
|
||||
const vorhanden = id ? alle.find((x) => x.id === id) : undefined;
|
||||
if (id && !vorhanden) { inhalt.innerHTML = '<p class="fehler">Diesen Kontakt gibt es nicht mehr.</p>'; return; }
|
||||
const gruppe = vorhanden ? !!vorhanden.art : wahl === "neu-gruppe";
|
||||
// Arbeitskopie; gespeichert wird erst mit „Speichern“
|
||||
const k: Zeile = vorhanden ? structuredClone(vorhanden) : {
|
||||
name: "", anrede: null, titel: null, firma: null, art: gruppe ? "firma" : null, notiz: null, rollen: [],
|
||||
telefone: [{ typ: gruppe ? "zentrale" : "mobil", wert: "", haupt: true }], emails: [{ typ: gruppe ? "geschaeftlich" : "privat", wert: "", haupt: true }],
|
||||
adressen: [leereAdresse(gruppe ? "geschaeftlich" : "privat")],
|
||||
};
|
||||
for (const l of ["telefone", "emails", "adressen"]) k[l] = k[l] ?? [];
|
||||
const name = (kid: string) => alle.find((x) => x.id === kid)?.name ?? "?";
|
||||
const meineGruppen = id ? zug.filter((z) => z.person_id === id) : [];
|
||||
const meineLeute = id ? zug.filter((z) => z.gruppe_id === id) : [];
|
||||
const neuLaden = (weiter = bearbeiten) => kontaktSeite(wahl, weiter);
|
||||
|
||||
// ---------- Ansicht am Handy ----------
|
||||
if (!bearbeiten) {
|
||||
const tel = haupt<Nummer>(k.telefone), mail = haupt<Nummer>(k.emails), adr = haupt<Anschrift>(k.adressen);
|
||||
const mobil = (k.telefone as Nummer[]).find((x) => x.typ === "mobil");
|
||||
const unter = gruppe ? [ART_TEXT[k.art], ...(k.rollen ?? []).map((r: string) => rollen.find((x) => x.id === r)?.name).filter(Boolean)].join(" · ")
|
||||
: [meineGruppen[0]?.funktion, meineGruppen[0] ? name(meineGruppen[0].gruppe_id) : k.firma].filter(Boolean).join(" · ");
|
||||
const knopf = (href: string | null, sym: string, text: string) => href ? `<a class="kt-aktion" href="${esc(href)}"${href.startsWith("http") ? ' target="_blank" rel="noopener"' : ""}><span>${sym}</span>${esc(text)}</a>` : "";
|
||||
inhalt.innerHTML = `<div class="kopf kt-kopfzeile"><a class="neben zurueck" href="#kontakte" aria-label="Zurück">‹</a><h1>Kontakt</h1><button class="haupt" data-a="bearbeiten">✎ Bearbeiten</button></div>${hinweisHtml()}
|
||||
<div class="kt-ansicht">
|
||||
<section class="karte kt-ansicht-kopf"><div class="kt-zeile-kopf">${bild(k.name, gruppe)}<div><h2>${esc(k.name)}</h2><p class="hinweis">${esc(unter)}</p></div></div>
|
||||
<div class="kt-aktionen">${knopf(tel ? telLink(tel.wert) : null, "☎", gruppe ? TYP_TEXT[tel?.typ ?? ""] ?? "Anrufen" : "Anrufen")}${gruppe ? "" : knopf(mobil ? `sms:${mobil.wert.replace(/[^\d+]/g, "")}` : null, "✉︎", "SMS")}
|
||||
${knopf(mail ? `mailto:${mail.wert}` : null, "@", "E-Mail")}${knopf(adr ? karteLink(adr) : null, "⌖", "Navi")}</div></section>
|
||||
${(k.telefone as Nummer[]).length ? `<section class="karte"><h3 class="kt-titel">Telefon</h3>${(k.telefone as Nummer[]).map((t) => `<div class="kt-ansicht-zeile"><div><b>${esc(t.wert)}${t.haupt ? " ★" : ""}</b><small>${esc(TYP_TEXT[t.typ] ?? t.typ)}</small></div><a class="kt-rund gut" href="${esc(telLink(t.wert))}" aria-label="Anrufen">☎</a></div>`).join("")}</section>` : ""}
|
||||
${(k.emails as Nummer[]).length ? `<section class="karte"><h3 class="kt-titel">E-Mail</h3>${(k.emails as Nummer[]).map((t) => `<div class="kt-ansicht-zeile"><div><b>${esc(t.wert)}</b><small>${esc(TYP_TEXT[t.typ] ?? t.typ)}</small></div><a class="kt-rund" href="mailto:${esc(t.wert)}" aria-label="E-Mail schreiben">@</a></div>`).join("")}</section>` : ""}
|
||||
${(k.adressen as Anschrift[]).length ? `<section class="karte"><h3 class="kt-titel">Adresse</h3>${(k.adressen as Anschrift[]).map((a) => `<div class="kt-ansicht-zeile"><div><b>${esc(adressZeile(a))}</b><small>${esc(TYP_TEXT[a.typ] ?? a.typ)}</small></div><a class="kt-rund" href="${esc(karteLink(a))}" target="_blank" rel="noopener" aria-label="Navigation">⌖</a></div>`).join("")}</section>` : ""}
|
||||
${gruppe ? `<section class="karte"><h3 class="kt-titel">Ansprechpartner (${meineLeute.length})</h3>${meineLeute.map((z) => { const p = alle.find((x) => x.id === z.person_id); const nr = p ? p.mobil ?? p.telefon : null;
|
||||
return `<div class="kt-ansicht-zeile">${bild(p?.name ?? "?", false, true)}<a href="#kontakt-${esc(z.person_id)}"><b>${esc(p?.name)}${(z.zustaendig ?? []).includes("haupt") ? " ★" : ""}</b><small>${esc([z.funktion, zustText(z.zustaendig)].filter(Boolean).join(" · "))}</small></a>${nr ? `<a class="kt-rund gut" href="${esc(telLink(nr))}" aria-label="Anrufen">☎</a>` : ""}</div>`; }).join("") || '<p class="hinweis">Noch keine.</p>'}</section>`
|
||||
: meineGruppen.length ? `<section class="karte"><h3 class="kt-titel">Gehört zu</h3>${meineGruppen.map((z) => { const g = alle.find((x) => x.id === z.gruppe_id);
|
||||
return `<a class="kt-ansicht-zeile" href="#kontakt-${esc(z.gruppe_id)}">${bild(g?.name ?? "?", true, true)}<div><b>${esc(g?.name)}</b><small>${esc([z.funktion, zustText(z.zustaendig)].filter(Boolean).join(" · "))}</small></div><span class="kt-art">${esc(ART_KURZ[g?.art] ?? "")}</span></a>`; }).join("")}</section>` : ""}
|
||||
${projekteHtml()}
|
||||
${k.notiz ? `<section class="karte"><h3 class="kt-titel">Notizen</h3><p class="kt-notiz">${esc(k.notiz)}</p></section>` : ""}
|
||||
</div>`;
|
||||
hinweis.text = ""; hinweis.gut = false;
|
||||
inhalt.querySelector<HTMLElement>('[data-a="bearbeiten"]')!.onclick = () => neuLaden(true);
|
||||
return;
|
||||
}
|
||||
|
||||
function projekteHtml(): string {
|
||||
if (!id) return "";
|
||||
const eintraege = [
|
||||
...projekte.filter((p) => p.bauherr_id === id).map((p) => ({ p, was: "Kunde" })),
|
||||
...ap.filter((a) => a.kontakt_id === id).map((a) => ({ p: projekte.find((p) => p.id === a.projekt_id), was: zustText(a.zustaendig) || "Ansprechp." })),
|
||||
].filter((x) => x.p);
|
||||
if (!eintraege.length) return "";
|
||||
return `<section class="karte kt-projekte"><h3 class="kt-titel">Projekte (${eintraege.length})</h3>${eintraege.map(({ p, was }) =>
|
||||
`<a class="kt-projekt" href="#projekt-${esc(p!.id)}"><span>${esc(p!.nummer)} ${esc(p!.bezeichnung)}</span><span class="kt-marke">${esc(was)}</span></a>`).join("")}</section>`;
|
||||
}
|
||||
|
||||
// ---------- Maske ----------
|
||||
const zeileHtml = (liste: string, x: Nummer, i: number, typen: string[]) => `<div class="kt-zeile" data-liste="${liste}" data-i="${i}">
|
||||
<select data-f="typ" aria-label="Art">${optionenHtml(typen.map((t): [string, string] => [t, TYP_TEXT[t] ?? t]), x.typ)}</select>
|
||||
<input data-f="wert" value="${esc(x.wert)}" placeholder="${liste === "telefone" ? "Telefon" : "E-Mail"}"${liste === "emails" ? ' type="email" inputmode="email"' : ' inputmode="tel"'}>
|
||||
<button type="button" class="kt-stern${x.haupt ? " an" : ""}" data-a="haupt" aria-pressed="${!!x.haupt}" title="Haupteintrag">★</button>
|
||||
<button type="button" class="kt-weg" data-a="weg" title="Entfernen" aria-label="Entfernen">✕</button></div>`;
|
||||
const adresseHtml = (a: Anschrift, i: number) => `<div class="kt-zeile kt-adresse" data-liste="adressen" data-i="${i}">
|
||||
<select data-f="typ" aria-label="Art">${optionenHtml(ADRESS_TYPEN.map((t): [string, string] => [t, TYP_TEXT[t] ?? t]), a.typ)}</select>
|
||||
<div class="kt-adressfelder">
|
||||
<div class="adr-feld"><input data-f="strasse" value="${esc(a.strasse)}" placeholder="Straße und Hausnummer" autocomplete="off"><div class="adr-liste" role="listbox" hidden></div></div>
|
||||
<input data-f="zusatz" value="${esc(a.zusatz ?? "")}" placeholder="Adresszusatz (c/o, Hinterhaus …)">
|
||||
<div class="kt-plz-ort"><input data-f="plz" value="${esc(a.plz)}" placeholder="PLZ" inputmode="numeric"><input data-f="ort" value="${esc(a.ort)}" placeholder="Ort"></div>
|
||||
<div class="kt-plz-ort gleich"><input data-f="region" value="${esc(a.region ?? "")}" placeholder="Bundesland"><input data-f="land" value="${esc(a.land ?? "")}" placeholder="Land"></div>
|
||||
${a.postfach ? `<input data-f="postfach" value="${esc(a.postfach)}" placeholder="Postfach">` : '<button type="button" class="verweis" data-a="postfach">+ Postfach</button>'}
|
||||
</div>
|
||||
<button type="button" class="kt-stern${a.haupt ? " an" : ""}" data-a="haupt" aria-pressed="${!!a.haupt}" title="Hauptadresse">★</button>
|
||||
<button type="button" class="kt-weg" data-a="weg" title="Entfernen" aria-label="Entfernen">✕</button></div>`;
|
||||
const block = (liste: string, sym: string, titel: string, inhaltHtml: string) => `<div class="kt-block"><h3><span class="kt-sym" aria-hidden="true">${sym}</span>${titel}<button type="button" class="kt-plus" data-plus="${liste}" title="${titel} hinzufügen" aria-label="${titel} hinzufügen">+</button></h3>${inhaltHtml}</div>`;
|
||||
|
||||
/** Eingaben in die Arbeitskopie übernehmen, bevor neu gezeichnet oder gespeichert wird */
|
||||
function lesen(): void {
|
||||
const form = inhalt.querySelector<HTMLElement>(".kt-form");
|
||||
if (!form) return;
|
||||
for (const el of form.querySelectorAll<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>("[data-k]")) k[el.dataset.k!] = el.value.trim() || null;
|
||||
if (k.name === null) k.name = "";
|
||||
for (const z of form.querySelectorAll<HTMLElement>(".kt-zeile")) {
|
||||
const eintrag = k[z.dataset.liste!][Number(z.dataset.i)];
|
||||
for (const el of z.querySelectorAll<HTMLInputElement | HTMLSelectElement>("[data-f]")) eintrag[el.dataset.f!] = el.value.trim();
|
||||
}
|
||||
}
|
||||
|
||||
function zeichnen(): void {
|
||||
const tel = (k.telefone as Nummer[]).map((x, i) => zeileHtml("telefone", x, i, gruppe ? ["zentrale", ...TELEFON_TYPEN.filter((t) => t !== "zentrale")] : TELEFON_TYPEN)).join("");
|
||||
const mails = (k.emails as Nummer[]).map((x, i) => zeileHtml("emails", x, i, EMAIL_TYPEN)).join("");
|
||||
const adr = (k.adressen as Anschrift[]).map(adresseHtml).join("");
|
||||
const erste = meineGruppen[0] ? alle.find((x) => x.id === meineGruppen[0]!.gruppe_id) : undefined;
|
||||
// Firma am Handy eingetragen, die es als übergeordneten Kontakt (noch) nicht gibt: Vorschlag
|
||||
const firmaGruppe = !gruppe && k.firma ? alle.find((x) => x.art && x.name.trim().toLowerCase() === String(k.firma).trim().toLowerCase()) : undefined;
|
||||
const firmaHinweis = !gruppe && id && k.firma && !meineGruppen.some((z) => z.gruppe_id === firmaGruppe?.id)
|
||||
? `<p class="kt-vorschlag">${firmaGruppe ? `„${esc(k.firma)}“ gibt es als übergeordneten Kontakt. <button type="button" class="verweis" data-a="firma-zuordnen">Zuordnen</button>`
|
||||
: `„${esc(k.firma)}“ als übergeordneten Kontakt anlegen? <button type="button" class="verweis" data-a="firma-anlegen">Firma anlegen</button>`}</p>` : "";
|
||||
const titel = !id ? (gruppe ? "Neuer übergeordneter Kontakt" : "Neuer Kontakt") : gruppe ? "Übergeordneter Kontakt" : "Kontakt bearbeiten";
|
||||
const pfad = `<a href="#kontakte">Kontakte</a>${erste ? ` › <a href="#kontakt-${esc(erste.id)}">${esc(erste.name)}</a>` : ""}${id ? ` › <span>${esc(vorhanden!.name)}</span>` : ""}`;
|
||||
const istMitarbeiter = (k.rollen ?? []).includes("mitarbeiter");
|
||||
inhalt.innerHTML = `<div class="kopf kt-kopfzeile"><div><h1>${esc(titel)}</h1><nav class="kt-pfad" aria-label="Pfad">${pfad}</nav></div>
|
||||
<div class="kt-knoepfe"><button class="neben" data-a="abbrechen">Abbrechen</button><button class="haupt" data-a="speichern">✓ Speichern</button>
|
||||
${id ? `<div class="kt-mehr-huelle"><button class="neben" data-a="mehr" aria-label="Weitere Aktionen" aria-expanded="false">⋯</button><div class="kt-mehr" hidden><button data-a="loeschen">${istMitarbeiter ? "Mitarbeiter lassen sich nicht löschen" : "Kontakt löschen"}</button></div></div>` : ""}</div></div>
|
||||
${hinweisHtml()}<p class="fehler" id="kt-fehler"></p>
|
||||
<div class="kt-raster">
|
||||
<div class="kt-links">
|
||||
<section class="karte kt-form">
|
||||
<div class="kt-namen">${bild(k.name, gruppe)}<div class="kt-namen-felder">
|
||||
${gruppe ? `<div class="kt-reihe zwei"><label>Name<input data-k="name" value="${esc(k.name)}" class="gross" required></label>
|
||||
<label>Art<select data-k="art">${optionenHtml(ARTEN, k.art ?? "firma")}</select></label></div>`
|
||||
: `<label>Name<input data-k="name" value="${esc(k.name)}" class="gross" required></label>
|
||||
<div class="kt-reihe"><label>Anrede<select data-k="anrede">${optionenHtml(ANREDEN, k.anrede ?? "")}</select></label>
|
||||
<label>Titel<input data-k="titel" value="${esc(k.titel ?? "")}" placeholder="z. B. Dipl.-Ing."></label>
|
||||
<label>Firma / Funktion<input data-k="firma" value="${esc(k.firma ?? "")}" placeholder="Firma"></label></div>`}
|
||||
</div></div>
|
||||
${firmaHinweis}
|
||||
${block("telefone", "☎", gruppe ? "Telefon" : "Telefon", tel)}
|
||||
${block("emails", "✉", "E-Mail-Adresse", mails)}
|
||||
${block("adressen", "⌖", "Adresse", adr)}
|
||||
<div class="kt-block"><h3><span class="kt-sym" aria-hidden="true">≡</span>Notizen</h3><textarea data-k="notiz" rows="3" placeholder="z. B. erreichbar ab 17 Uhr">${esc(k.notiz ?? "")}</textarea></div>
|
||||
</section>
|
||||
${gruppe ? ansprechpartnerHtml() : ""}
|
||||
</div>
|
||||
<aside class="kt-seite">
|
||||
${gruppe ? "" : gehoertZuHtml()}
|
||||
${rollenHtml()}
|
||||
${projekteHtml()}
|
||||
${handyHtml()}
|
||||
</aside>
|
||||
</div>`;
|
||||
for (const f of inhalt.querySelectorAll<HTMLElement>(".kt-adresse")) {
|
||||
const feld = f.querySelector<HTMLInputElement>('[data-f="strasse"]')!;
|
||||
vorschlaegeAn(feld, (t) => {
|
||||
f.querySelector<HTMLInputElement>('[data-f="plz"]')!.value = t.plz;
|
||||
f.querySelector<HTMLInputElement>('[data-f="ort"]')!.value = t.ort;
|
||||
});
|
||||
}
|
||||
if (!id) inhalt.querySelector<HTMLInputElement>('[data-k="name"]')?.focus();
|
||||
hinweis.text = ""; hinweis.gut = false;
|
||||
}
|
||||
|
||||
function gehoertZuHtml(): string {
|
||||
return `<section class="karte"><h3 class="kt-titel">Gehört zu</h3>
|
||||
${meineGruppen.map((z) => { const g = alle.find((x) => x.id === z.gruppe_id);
|
||||
return `<div class="kt-gruppe">${bild(g?.name ?? "?", true, true)}<a href="#kontakt-${esc(z.gruppe_id)}"><b>${esc(g?.name)}</b><small>${esc([z.funktion, zustText(z.zustaendig)].filter(Boolean).join(" · "))}</small></a>
|
||||
<span class="kt-art">${esc(ART_KURZ[g?.art] ?? "")}</span><button type="button" class="kt-punkte" data-zug="${esc(z.id)}" aria-label="Zuordnung bearbeiten">⋯</button></div>`; }).join("")}
|
||||
${id ? '<button type="button" class="neben klein" data-a="zuordnen">+ Zuordnen</button>' : '<p class="hinweis">Nach dem Speichern kannst du den Kontakt einer Firma, Familie oder einem Ehepaar zuordnen.</p>'}</section>`;
|
||||
}
|
||||
|
||||
function ansprechpartnerHtml(): string {
|
||||
return `<section class="karte kt-leute"><div class="kt-leute-kopf"><h3 class="kt-titel">Ansprechpartner (${meineLeute.length})</h3>
|
||||
${id ? '<div class="kt-leute-knoepfe"><button type="button" class="neben" data-a="person-vorhanden">+ Vorhandenen Kontakt</button><button type="button" class="haupt" data-a="person-neu">+ Neue Person</button></div>' : ""}</div>
|
||||
${!id ? '<p class="hinweis">Nach dem Speichern kannst du Ansprechpartner hinzufügen.</p>' : meineLeute.length ? `<div class="tabelle-rolle"><table class="kt-leute-tabelle"><thead><tr><th></th><th>Name</th><th>Funktion</th><th>Telefon / E-Mail</th><th>Zuständig für</th><th></th></tr></thead><tbody>
|
||||
${meineLeute.map((z) => { const p = alle.find((x) => x.id === z.person_id);
|
||||
return `<tr><td>${bild(p?.name ?? "?", false, true)}</td><td><a href="#kontakt-${esc(z.person_id)}"><b>${esc(p?.name)}</b></a>${(z.zustaendig ?? []).includes("haupt") ? ' <span class="kt-stern an">★</span>' : ""}</td>
|
||||
<td><input class="kt-funktion" data-zug-funktion="${esc(z.id)}" value="${esc(z.funktion ?? "")}" placeholder="Funktion" aria-label="Funktion"></td>
|
||||
<td>${esc(p?.mobil ?? p?.telefon ?? p?.email ?? "")}</td>
|
||||
<td>${(z.zustaendig ?? []).map((x: string) => `<span class="kt-zust ${esc(x)}">${esc(ZUST_TEXT[x] ?? x)}</span>`).join(" ")}</td>
|
||||
<td><button type="button" class="kt-punkte" data-zug="${esc(z.id)}" aria-label="Ansprechpartner bearbeiten">⋯</button></td></tr>`; }).join("")}</tbody></table></div>
|
||||
<p class="hinweis">Jeder Ansprechpartner ist ein eigener Kontakt und kann zu mehreren übergeordneten Kontakten gehören.</p>` : '<p class="hinweis">Noch keine Ansprechpartner.</p>'}</section>`;
|
||||
}
|
||||
|
||||
let rollenOffen = false;
|
||||
function rollenHtml(): string {
|
||||
const gewaehlt = new Set<string>(k.rollen ?? []);
|
||||
const chips = rollen.filter((r) => r.id !== "mitarbeiter").map((r) =>
|
||||
`<button type="button" class="kt-rolle${gewaehlt.has(r.id) ? " an" : ""}" data-rolle="${esc(r.id)}" aria-pressed="${gewaehlt.has(r.id)}">${esc(r.name)}</button>`).join("");
|
||||
const editor = rollenOffen ? `<div class="kt-rollen-editor"><h4>Rollen bearbeiten</h4>
|
||||
${rollen.filter((r) => !r.fest).map((r) => `<div class="kt-rollen-zeile"><input data-rolle-name="${esc(r.id)}" value="${esc(r.name)}" aria-label="Rolle umbenennen"><button type="button" class="kt-weg" data-rolle-weg="${esc(r.id)}" aria-label="Rolle löschen">✕</button></div>`).join("")}
|
||||
<div class="kt-rollen-zeile"><input id="kt-rolle-neu" placeholder="Neue Rolle"><button type="button" class="kt-plus" data-a="rolle-neu" aria-label="Rolle anlegen">+</button></div>
|
||||
<p class="hinweis">🔒 Subunternehmer bleibt fest (Terminplan hängt daran).</p></div>` : "";
|
||||
return `<section class="karte"><h3 class="kt-titel">Rollen</h3><div class="kt-rollen">${chips}<button type="button" class="kt-rolle plus" data-a="rollen-bearbeiten">${rollenOffen ? "fertig" : "+ Rolle"}</button></div>
|
||||
<label class="kt-multi"><input type="checkbox" data-multi${k.multiplikator ? " checked" : ""}> Empfiehlt uns weiter (Multiplikator)<small>zählt bei der Projekt-Priorität, z. B. Architekt oder Hausverwaltung</small></label>
|
||||
${gewaehlt.has("mitarbeiter") ? `<p class="kt-mitarbeiter">Mitarbeiter › <a href="#mitarbeiter-${esc(id)}">zur Personalseite</a></p>` : '<p class="hinweis">Mitarbeiter legst du unter Personal fest.</p>'}${editor}</section>`;
|
||||
}
|
||||
|
||||
function handyHtml(): string {
|
||||
if (!abgleich || !id) return "";
|
||||
const h = imHandy.find((x) => x.kontakt_id === id);
|
||||
const zeit = abgleich.stand?.zuletzt ? new Date(abgleich.stand.zuletzt).toLocaleTimeString("de-DE", { hour: "2-digit", minute: "2-digit" }) : null;
|
||||
const ohneNummer = gruppe && !(k.telefone as Nummer[]).some((x) => x.wert) && !(k.emails as Nummer[]).some((x) => x.wert);
|
||||
const text = !abgleich.an ? "Der Abgleich mit dem Handy ist aus (Einstellungen › Daten)."
|
||||
: h ? (h.geloescht ? "Im Handy gelöscht; bleibt hier erhalten." : `✓ Im Handy-Adressbuch${zeit ? ` · zuletzt abgeglichen ${zeit}` : ""}`)
|
||||
: ohneNummer ? "Übergeordnete Kontakte kommen erst mit eigener Nummer oder E-Mail ins Handy."
|
||||
: "Kommt beim nächsten Abgleich ins Handy.";
|
||||
return `<section class="karte"><h3 class="kt-titel">Handy</h3><p class="hinweis">${esc(text)}</p></section>`;
|
||||
}
|
||||
|
||||
// ---------- Zuordnungen (sofort gespeichert) ----------
|
||||
const zustFeld: Feld = { name: "zustaendig", titel: "Zuständig für", art: "auswahl", optionen: [["", "–"], ...ZUSTAENDIG] };
|
||||
const zugDaten = (d: Zeile) => ({ funktion: d.funktion ?? null, zustaendig: d.zustaendig ? [d.zustaendig] : [] });
|
||||
async function zuordnungBearbeiten(zid: string): Promise<void> {
|
||||
const z = zug.find((x) => x.id === zid);
|
||||
if (!z) return;
|
||||
const r = await dialog(gruppe ? `Ansprechpartner: ${name(z.person_id)}` : `Gehört zu: ${name(z.gruppe_id)}`,
|
||||
[{ name: "funktion", titel: "Funktion", hilfe: "z. B. Technischer Leiter, Ehemann" }, zustFeld], { funktion: z.funktion, zustaendig: (z.zustaendig ?? [])[0] ?? "" }, true);
|
||||
if (!r) return;
|
||||
lesen();
|
||||
if (r.aktion === "loeschen") await api(`kontakt-zugehoerigkeiten/${zid}`, "DELETE");
|
||||
else await api(`kontakt-zugehoerigkeiten/${zid}`, "PATCH", zugDaten(r.daten));
|
||||
return neuLaden();
|
||||
}
|
||||
async function zuordnen(): Promise<void> {
|
||||
const gruppen = alle.filter((x) => x.art && !meineGruppen.some((z) => z.gruppe_id === x.id)).sort((a, b) => a.name.localeCompare(b.name, "de"));
|
||||
const r = await dialog("Zuordnen", [
|
||||
{ name: "gruppe_id", titel: "Übergeordneter Kontakt", art: "auswahl", pflicht: true,
|
||||
optionen: [["", "– wählen –"], ...gruppen.map((g): [string, string] => [g.id, `${g.name} (${ART_KURZ[g.art] ?? ""})`])],
|
||||
neu: { text: "+ Neue Firma, Familie …", titel: "Übergeordneten Kontakt anlegen", felder: [{ name: "name", titel: "Name", pflicht: true }],
|
||||
anlegen: async (d) => { const g = await api<Zeile>("kontakte", "POST", { name: d.name, art: k.anrede === "Familie" ? "familie" : "firma" }); return [g.id, g.name]; } } },
|
||||
{ name: "funktion", titel: "Funktion", hilfe: "z. B. Technischer Leiter, Ehemann" }, zustFeld,
|
||||
], {}, false);
|
||||
if (r?.aktion !== "speichern" || !r.daten.gruppe_id) return;
|
||||
lesen();
|
||||
await api("kontakt-zugehoerigkeiten", "POST", { gruppe_id: r.daten.gruppe_id, person_id: id, ...zugDaten(r.daten), reihenfolge: zug.filter((z) => z.gruppe_id === r.daten.gruppe_id).length });
|
||||
return neuLaden();
|
||||
}
|
||||
async function personHinzu(neuePerson: boolean): Promise<void> {
|
||||
const personen = alle.filter((x) => !x.art && !meineLeute.some((z) => z.person_id === x.id)).sort((a, b) => a.name.localeCompare(b.name, "de"));
|
||||
const felder: Feld[] = neuePerson
|
||||
? [{ name: "name", titel: "Name", pflicht: true }, { name: "funktion", titel: "Funktion" }, zustFeld, { name: "telefon", titel: "Telefon" }, { name: "mobil", titel: "Mobil" }, { name: "email", titel: "E-Mail" }]
|
||||
: [{ name: "person_id", titel: "Kontakt", art: "auswahl", pflicht: true, optionen: [["", "– wählen –"], ...personen.map((p): [string, string] => [p.id, p.firma ? `${p.name} · ${p.firma}` : p.name])] },
|
||||
{ name: "funktion", titel: "Funktion" }, zustFeld];
|
||||
const r = await dialog(neuePerson ? "Neue Person" : "Vorhandenen Kontakt hinzufügen", felder, {}, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
lesen();
|
||||
let pid = r.daten.person_id as string | undefined;
|
||||
if (neuePerson) pid = (await api<Zeile>("kontakte", "POST", { name: r.daten.name, telefon: r.daten.telefon ?? null, mobil: r.daten.mobil ?? null, email: r.daten.email ?? null })).id;
|
||||
if (!pid) return;
|
||||
await api("kontakt-zugehoerigkeiten", "POST", { gruppe_id: id, person_id: pid, ...zugDaten(r.daten), reihenfolge: meineLeute.length });
|
||||
return neuLaden();
|
||||
}
|
||||
|
||||
zeichnen();
|
||||
inhalt.onclick = async (ev) => {
|
||||
const el = ev.target as HTMLElement;
|
||||
const knopf = el.closest<HTMLElement>("[data-a],[data-plus],[data-rolle],[data-zug],[data-rolle-weg]");
|
||||
if (!knopf || !inhalt.querySelector(".kt-form")) return;
|
||||
const a = knopf.dataset.a;
|
||||
const zeile = knopf.closest<HTMLElement>(".kt-zeile");
|
||||
if (knopf.dataset.plus) {
|
||||
lesen();
|
||||
const l = knopf.dataset.plus;
|
||||
const leer = !k[l].length;
|
||||
k[l].push(l === "adressen" ? { ...leereAdresse(gruppe ? "rechnung" : "geschaeftlich"), haupt: leer } : { typ: l === "telefone" ? (k.telefone.length ? "privat" : "mobil") : "geschaeftlich", wert: "", haupt: leer });
|
||||
zeichnen();
|
||||
inhalt.querySelector<HTMLElement>(`.kt-zeile[data-liste="${l}"][data-i="${k[l].length - 1}"] input`)?.focus();
|
||||
return;
|
||||
}
|
||||
if (zeile && (a === "haupt" || a === "weg" || a === "postfach")) {
|
||||
lesen();
|
||||
const l = k[zeile.dataset.liste!] as { haupt?: boolean; postfach?: string }[], i = Number(zeile.dataset.i);
|
||||
if (a === "haupt") l.forEach((x, j) => (x.haupt = j === i));
|
||||
if (a === "weg") { const war = l[i]!.haupt; l.splice(i, 1); if (war && l[0]) l[0].haupt = true; }
|
||||
if (a === "postfach") {
|
||||
// Leerzeichen als Platzhalter, damit das Feld erscheint; beim Lesen wird es wieder leer
|
||||
l[i]!.postfach = " ";
|
||||
zeichnen();
|
||||
inhalt.querySelector<HTMLInputElement>(`.kt-zeile[data-liste="adressen"][data-i="${i}"] [data-f="postfach"]`)?.focus();
|
||||
return;
|
||||
}
|
||||
zeichnen();
|
||||
return;
|
||||
}
|
||||
if (knopf.dataset.rolle) {
|
||||
lesen();
|
||||
const r = knopf.dataset.rolle;
|
||||
k.rollen = (k.rollen ?? []).includes(r) ? k.rollen.filter((x: string) => x !== r) : [...(k.rollen ?? []), r];
|
||||
return zeichnen();
|
||||
}
|
||||
if (knopf.dataset.rolleWeg) {
|
||||
const r = rollen.find((x) => x.id === knopf.dataset.rolleWeg);
|
||||
if (!r || !(await bestaetigen(`Rolle „${r.name}“ löschen?`, { hinweis: "Sie verschwindet bei allen Kontakten.", ja: "Löschen" }))) return;
|
||||
lesen();
|
||||
await api(`kontakt-rollen/${r.id}`, "DELETE");
|
||||
rollen.splice(rollen.indexOf(r), 1);
|
||||
k.rollen = (k.rollen ?? []).filter((x: string) => x !== r.id);
|
||||
return zeichnen();
|
||||
}
|
||||
if (knopf.dataset.zug) return zuordnungBearbeiten(knopf.dataset.zug);
|
||||
if (a === "rollen-bearbeiten") { lesen(); rollenOffen = !rollenOffen; zeichnen(); if (rollenOffen) inhalt.querySelector<HTMLInputElement>("#kt-rolle-neu")?.focus(); return; }
|
||||
if (a === "rolle-neu") return rolleAnlegen();
|
||||
if (a === "zuordnen") return zuordnen();
|
||||
if (a === "person-neu" || a === "person-vorhanden") return personHinzu(a === "person-neu");
|
||||
if (a === "firma-anlegen" || a === "firma-zuordnen") {
|
||||
lesen();
|
||||
const vorh = alle.find((x) => x.art && x.name.trim().toLowerCase() === String(k.firma).trim().toLowerCase());
|
||||
const gid = vorh?.id ?? (await api<Zeile>("kontakte", "POST", { name: k.firma, art: "firma" })).id;
|
||||
await api("kontakt-zugehoerigkeiten", "POST", { gruppe_id: gid, person_id: id, zustaendig: [] });
|
||||
// die Firma steht jetzt unter „Gehört zu“
|
||||
await api(`kontakte/${id}`, "PATCH", { firma: null });
|
||||
return neuLaden();
|
||||
}
|
||||
if (a === "mehr") { const m = knopf.nextElementSibling as HTMLElement; m.hidden = !m.hidden; knopf.setAttribute("aria-expanded", String(!m.hidden)); return; }
|
||||
if (a === "loeschen") {
|
||||
if ((k.rollen ?? []).includes("mitarbeiter")) { inhalt.querySelector("#kt-fehler")!.textContent = "Mitarbeiter bleiben erhalten; unter Personal trägst du ein Austrittsdatum ein."; return; }
|
||||
if (!(await bestaetigen(`„${vorhanden!.name}“ löschen?`, { hinweis: "Im Handy verschwindet die Karte beim nächsten Abgleich.", ja: "Löschen" }))) return;
|
||||
try { await api(`kontakte/${id}`, "DELETE"); location.hash = "kontakte"; } catch (e) { inhalt.querySelector("#kt-fehler")!.textContent = (e as Error).message; }
|
||||
return;
|
||||
}
|
||||
if (a === "abbrechen") { if (istHandy() && id) return neuLaden(false); location.hash = "kontakte"; return; }
|
||||
if (a === "speichern") return speichern();
|
||||
};
|
||||
inhalt.onchange = async (ev) => {
|
||||
if ((ev.target as HTMLElement).dataset.multi !== undefined) { k.multiplikator = (ev.target as HTMLInputElement).checked; return; }
|
||||
const el = ev.target as HTMLInputElement;
|
||||
if (el.dataset.rolleName) {
|
||||
const name = el.value.trim();
|
||||
if (!name) return;
|
||||
const r = await api<Zeile>(`kontakt-rollen/${el.dataset.rolleName}`, "PATCH", { name });
|
||||
const x = rollen.find((y) => y.id === r.id);
|
||||
if (x) x.name = r.name;
|
||||
lesen();
|
||||
return zeichnen();
|
||||
}
|
||||
if (el.dataset.zugFunktion) await api(`kontakt-zugehoerigkeiten/${el.dataset.zugFunktion}`, "PATCH", { funktion: el.value.trim() || null });
|
||||
};
|
||||
inhalt.onkeydown = (ev) => {
|
||||
const el = ev.target as HTMLElement;
|
||||
if (ev.key === "Enter" && el.id === "kt-rolle-neu") { ev.preventDefault(); void rolleAnlegen(); }
|
||||
};
|
||||
|
||||
async function rolleAnlegen(): Promise<void> {
|
||||
const feld = inhalt.querySelector<HTMLInputElement>("#kt-rolle-neu");
|
||||
const name = feld?.value.trim();
|
||||
if (!name) return;
|
||||
lesen();
|
||||
const r = await api<Zeile>("kontakt-rollen", "POST", { name });
|
||||
if (!rollen.some((x) => x.id === r.id)) rollen.push(r);
|
||||
if (!(k.rollen ?? []).includes(r.id)) k.rollen = [...(k.rollen ?? []), r.id];
|
||||
zeichnen();
|
||||
inhalt.querySelector<HTMLInputElement>("#kt-rolle-neu")?.focus();
|
||||
}
|
||||
|
||||
async function speichern(): Promise<void> {
|
||||
lesen();
|
||||
const fehler = inhalt.querySelector<HTMLElement>("#kt-fehler")!;
|
||||
if (!String(k.name).trim()) { fehler.textContent = "Bitte einen Namen eintragen."; inhalt.querySelector<HTMLInputElement>('[data-k="name"]')?.focus(); return; }
|
||||
const daten: Zeile = {
|
||||
name: k.name, firma: gruppe ? null : k.firma, anrede: gruppe ? null : k.anrede, titel: gruppe ? null : k.titel, art: gruppe ? k.art ?? "firma" : null,
|
||||
notiz: k.notiz, rollen: k.rollen ?? [], telefone: k.telefone, emails: k.emails, adressen: k.adressen, multiplikator: !!k.multiplikator,
|
||||
};
|
||||
try {
|
||||
const r = id ? await api<Zeile>(`kontakte/${id}`, "PATCH", daten) : await api<Zeile>("kontakte", "POST", daten);
|
||||
hinweis.text = "Gespeichert."; hinweis.gut = true;
|
||||
if (!id) { location.hash = `kontakt-${r.id}`; return; }
|
||||
return neuLaden(!istHandy());
|
||||
} catch (e) { fehler.textContent = (e as Error).message; }
|
||||
}
|
||||
}
|
||||
@@ -5,6 +5,8 @@ import { type Zeile, api, dat, esc, heute, inhalt, modulAn, seite } from "./ui.j
|
||||
|
||||
const WOCHENTAG_LANG = ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"];
|
||||
const tagName = (d: string) => WOCHENTAG_LANG[new Date(`${d}T00:00:00Z`).getUTCDay()]!;
|
||||
/** Ansprechpartner für die Baustelle, zum Antippen */
|
||||
const ansprechpartner = (e: Zeile) => (e.ap_name ? `<p class="ap">Ansprechpartner: ${esc(e.ap_name)}${e.ap_telefon ? ` <a class="neben" href="tel:${esc(String(e.ap_telefon).replace(/[^\d+]/g, ""))}">☎ ${esc(e.ap_telefon)}</a>` : ""}</p>` : "");
|
||||
const adresse = (e: Zeile) => [e.baustelle_strasse, [e.baustelle_plz, e.baustelle_ort].filter(Boolean).join(" ")].filter(Boolean).join(", ");
|
||||
|
||||
export async function meineEinsaetze(): Promise<void> {
|
||||
@@ -30,7 +32,7 @@ export async function meineEinsaetze(): Promise<void> {
|
||||
const ort = adresse(e);
|
||||
return `<article class="einsatz-karte"><h3>${esc(e.nummer)} ${esc(e.bezeichnung)}</h3><p>${esc(e.name)}</p>
|
||||
${ort ? `<p class="ort">${esc(ort)} <a class="neben" href="https://www.google.com/maps/dir/?api=1&destination=${encodeURIComponent(ort)}" target="_blank" rel="noopener">Route</a></p>` : ""}
|
||||
<p><a class="neben" href="#ablage-${esc(e.projekt_id)}">Ablage</a></p></article>`;
|
||||
${ansprechpartner(e)}<p><a class="neben" href="#ablage-${esc(e.projekt_id)}">Ablage</a></p></article>`;
|
||||
}).join("")}</section>`;
|
||||
}).join("");
|
||||
inhalt.insertAdjacentHTML("beforeend", `<div class="meine-einsaetze">${html}</div>`);
|
||||
@@ -61,7 +63,7 @@ export async function heuteSeite(): Promise<void> {
|
||||
const karte = (e: Zeile) => {
|
||||
const ort = adresse(e);
|
||||
return `<article class="karte heute-karte"><div class="zeile"><h2>${esc(e.bezeichnung)}</h2><span class="marke">${esc(e.name)}</span></div>
|
||||
<p>${ort ? esc(ort) : '<span class="hinweis">Keine Adresse eingetragen.</span>'}</p><p class="hinweis">${esc(e.nummer)} · ${dat(e.anfang).slice(0, 6)} bis ${dat(e.ende).slice(0, 6)}</p>
|
||||
<p>${ort ? esc(ort) : '<span class="hinweis">Keine Adresse eingetragen.</span>'}</p><p class="hinweis">${esc(e.nummer)} · ${dat(e.anfang).slice(0, 6)} bis ${dat(e.ende).slice(0, 6)}</p>${ansprechpartner(e)}
|
||||
<div class="heute-knoepfe">${ort ? `<a class="knopf haupt" href="${route(ort)}" target="_blank" rel="noopener">Navigation</a>` : ""}<a class="neben" href="#ablage-${esc(e.projekt_id)}">Pläne</a></div></article>`;
|
||||
};
|
||||
// nächste Tage: zusammenhängende Tage desselben Einsatzes als ein Eintrag
|
||||
@@ -96,7 +98,7 @@ export async function baustelleSeite(): Promise<void> {
|
||||
const projekte = [...new Map(r.einsaetze.map((e) => [e.projekt_id, e])).values()];
|
||||
inhalt.insertAdjacentHTML("beforeend", `<div class="heute-seite">
|
||||
${projekte.map((e) => `<article class="karte heute-karte"><div class="zeile"><h2>${esc(e.bezeichnung)}</h2><span class="hinweis">${esc(e.nummer)}</span></div>
|
||||
<p>${esc(adresse(e))}</p><div class="heute-knoepfe"><a class="neben" href="#ablage-${esc(e.projekt_id)}">Pläne und Ablage</a></div></article>`).join("") || '<p class="karte hinweis">Diese Woche bist du auf keiner Baustelle eingeteilt.</p>'}
|
||||
<p>${esc(adresse(e))}</p>${ansprechpartner(e)}<div class="heute-knoepfe"><a class="neben" href="#ablage-${esc(e.projekt_id)}">Pläne und Ablage</a></div></article>`).join("") || '<p class="karte hinweis">Diese Woche bist du auf keiner Baustelle eingeteilt.</p>'}
|
||||
<section class="karte"><h2>Fotos, Notizen und Bautagebuch</h2><p class="hinweis">Kommt mit Stufe 4 (Baustelle am Handy): Fotos, Sprachnotiz, Behinderungen und Regieberichte, auch ohne Netz.</p></section>
|
||||
</div>`);
|
||||
}
|
||||
|
||||
@@ -491,11 +491,22 @@ async function zeitenTeil(): Promise<void> {
|
||||
}));
|
||||
}
|
||||
|
||||
const ROLLE_TEXT: Record<string, string> = { bauherr: "Bauherr", subunternehmer: "Subunternehmer", lieferant: "Lieferant", planer: "Planer", sonstige: "Sonstige" };
|
||||
|
||||
// Mitarbeiter aus den Kontakten wählen, wie den Kunden im Projekt (Henning, 08.11.2026); ein neuer Kontakt entsteht direkt als Mitarbeiter
|
||||
async function neuerMitarbeiter(): Promise<void> {
|
||||
const r = await dialog("Neuer Mitarbeiter", [{ name: "name", titel: "Name", pflicht: true }, { name: "telefon", titel: "Telefon" }], {}, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
const k = await api<Zeile>("kontakte", "POST", { ...r.daten, rolle: "mitarbeiter" });
|
||||
location.hash = `mitarbeiter-${k.id}`;
|
||||
const kontakte = (await api<Zeile[]>("kontakte")).filter((k) => k.rolle !== "mitarbeiter").sort((a, b) => a.name.localeCompare(b.name, "de"));
|
||||
const r = await dialog("Neuer Mitarbeiter", [{
|
||||
name: "kontakt_id", titel: "Kontakt", art: "auswahl", pflicht: true,
|
||||
optionen: [["", "– aus den Kontakten wählen –"], ...kontakte.map((k): [string, string] => [k.id, `${k.name}${k.firma && k.firma !== k.name ? ` · ${k.firma}` : ""}${ROLLE_TEXT[k.rolle] ? ` (${ROLLE_TEXT[k.rolle]})` : ""}`])],
|
||||
hilfe: "Ein vorhandener Kontakt wird zum Mitarbeiter; Telefon, E-Mail und Adresse bleiben an einer Stelle.",
|
||||
neu: { text: "+ Neuer Kontakt …", titel: "Neuen Kontakt anlegen", felder: [{ name: "name", titel: "Name", pflicht: true }, { name: "telefon", titel: "Telefon" }, { name: "mobil", titel: "Mobil" }, { name: "email", titel: "E-Mail" }],
|
||||
anlegen: async (d) => { const k = await api<Zeile>("kontakte", "POST", { ...d, rolle: "mitarbeiter" }); return [k.id, k.name]; } },
|
||||
}], {}, false);
|
||||
if (r?.aktion !== "speichern" || !r.daten.kontakt_id) return;
|
||||
const id = String(r.daten.kontakt_id);
|
||||
if (kontakte.some((k) => k.id === id)) await api(`kontakte/${id}`, "PATCH", { rolle: "mitarbeiter" });
|
||||
location.hash = `mitarbeiter-${id}`;
|
||||
}
|
||||
|
||||
export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Promise<void> {
|
||||
@@ -525,7 +536,15 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro
|
||||
const raster = document.createElement("div");
|
||||
raster.className = "personal-raster";
|
||||
const u = ich?.urlaub;
|
||||
const kAdresse = [kontakt.strasse, [kontakt.plz, kontakt.ort].filter(Boolean).join(" ")].filter(Boolean).join(", ");
|
||||
raster.innerHTML = `
|
||||
<section class="karte"><div class="karte-kopf"><h2>Kontakt</h2><a class="neben knopf" href="#kontakt-${esc(kontaktId)}">Bearbeiten</a></div>
|
||||
<dl class="werte">
|
||||
<dt>Telefon</dt><dd>${kontakt.telefon ? `<a href="tel:${esc(kontakt.telefon)}">${esc(kontakt.telefon)}</a>` : "–"}</dd>
|
||||
<dt>Mobil</dt><dd>${kontakt.mobil ? `<a href="tel:${esc(kontakt.mobil)}">${esc(kontakt.mobil)}</a>` : "–"}</dd>
|
||||
<dt>E-Mail</dt><dd>${kontakt.email ? `<a href="mailto:${esc(kontakt.email)}">${esc(kontakt.email)}</a>` : "–"}</dd>
|
||||
<dt>Adresse</dt><dd>${esc(kAdresse || "–")}</dd>
|
||||
</dl><p class="hinweis">Steht auch unter <a href="#kontakte">Kontakte</a>; Änderungen gelten an beiden Stellen.</p></section>
|
||||
<section class="karte"><div class="karte-kopf"><h2>Stammdaten</h2><button class="neben" data-a="stamm">Bearbeiten</button></div>
|
||||
<dl class="werte">
|
||||
<dt>Personalnummer</dt><dd>${esc(stamm?.personalnummer ?? "–")}</dd>
|
||||
|
||||
@@ -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); }
|
||||
@@ -2045,3 +2054,132 @@ ul.aufgaben li.aufgabe-2 .a-datum.ueber { color: var(--warn); font-weight: 600;
|
||||
.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; }
|
||||
|
||||
/* Kontaktmaske und übergeordnete Kontakte (0.47, Entwürfe kontakte/maske) */
|
||||
.kt-kopfzeile { align-items: flex-start; gap: 12px; flex-wrap: wrap; }
|
||||
.kt-pfad { font-size: 14px; color: var(--leise); margin-top: 4px; }
|
||||
.kt-pfad a { color: var(--akzent); text-decoration: none; }
|
||||
.kt-knoepfe { display: flex; gap: 8px; align-items: center; margin-left: auto; }
|
||||
.kt-mehr-huelle { position: relative; }
|
||||
.kt-mehr { position: absolute; right: 0; top: calc(100% + 4px); z-index: 20; background: var(--fl); border: 1px solid var(--linie); border-radius: 8px; box-shadow: 0 8px 24px rgb(0 0 0 / 0.16); padding: 4px; min-width: 220px; }
|
||||
.kt-mehr button { display: block; width: 100%; text-align: left; background: none; border: 0; padding: 8px 10px; border-radius: 6px; font: inherit; color: var(--warn); cursor: pointer; }
|
||||
.kt-mehr button:hover { background: var(--warnung-bg); }
|
||||
.kt-raster { display: grid; grid-template-columns: minmax(0, 1fr) minmax(260px, 340px); gap: 16px; align-items: start; }
|
||||
.kt-links, .kt-seite { display: flex; flex-direction: column; gap: 16px; min-width: 0; }
|
||||
.kt-form { padding: 20px 22px; }
|
||||
.kt-form label { display: flex; flex-direction: column; gap: 4px; font-size: 13px; color: var(--leise); min-width: 0; }
|
||||
.kt-form input, .kt-form select, .kt-form textarea, .kt-funktion, .kt-rollen-zeile input { width: 100%; padding: 9px 10px; border: 1px solid var(--linie); border-radius: 8px; background: var(--fl); color: var(--text); font: inherit; min-width: 0; }
|
||||
.kt-form input:focus, .kt-form select:focus, .kt-form textarea:focus { outline: 2px solid var(--akzent-hell); border-color: var(--akzent); }
|
||||
.kt-form label > input, .kt-form label > select { font-size: 15px; color: var(--text); }
|
||||
.kt-form input.gross { font-size: 18px; font-weight: 600; }
|
||||
.kt-namen { display: flex; gap: 18px; align-items: flex-start; padding-bottom: 16px; border-bottom: 1px solid var(--linie); }
|
||||
.kt-namen-felder { flex: 1; display: flex; flex-direction: column; gap: 10px; min-width: 0; }
|
||||
.kt-reihe { display: grid; grid-template-columns: 9em 1fr 1fr; gap: 10px; }
|
||||
.kt-reihe.zwei { grid-template-columns: 1fr 14em; }
|
||||
.kt-bild { flex: none; display: inline-grid; place-items: center; width: 72px; height: 72px; border-radius: 50%; background: var(--akzent-hell); color: var(--akzent); font-weight: 700; font-size: 24px; letter-spacing: 0.02em; }
|
||||
.kt-bild.gruppe { border-radius: 16px; background: var(--art-mat-bg); color: var(--marke); }
|
||||
.kt-bild.klein { width: 34px; height: 34px; font-size: 13px; }
|
||||
.kt-bild.gruppe.klein { border-radius: 8px; }
|
||||
.kt-block { padding: 14px 0; border-bottom: 1px solid var(--linie); display: flex; flex-direction: column; gap: 8px; }
|
||||
.kt-block:last-child { border-bottom: 0; padding-bottom: 0; }
|
||||
.kt-block h3 { display: flex; align-items: center; gap: 10px; margin: 0 0 2px; font-size: 16px; }
|
||||
.kt-sym { display: inline-grid; place-items: center; width: 28px; height: 28px; border-radius: 8px; background: var(--akzent-hell); color: var(--akzent); font-size: 14px; }
|
||||
.kt-plus { margin-left: auto; width: 32px; height: 32px; border-radius: 8px; border: 1px solid var(--linie); background: var(--fl); color: var(--akzent); font-size: 18px; line-height: 1; cursor: pointer; }
|
||||
.kt-zeile { display: grid; grid-template-columns: minmax(7em, 11em) minmax(0, 1fr) 32px 32px; gap: 8px; align-items: center; }
|
||||
.kt-zeile.kt-adresse { align-items: start; }
|
||||
.kt-adressfelder { display: flex; flex-direction: column; gap: 8px; min-width: 0; }
|
||||
.kt-adressfelder .verweis { align-self: flex-start; }
|
||||
.kt-plz-ort { display: grid; grid-template-columns: 7em minmax(0, 1fr); gap: 8px; }
|
||||
.kt-plz-ort.gleich { grid-template-columns: 1fr 1fr; }
|
||||
.kt-stern, .kt-weg, .kt-punkte { width: 32px; height: 32px; border: 0; background: none; border-radius: 8px; color: var(--leise); cursor: pointer; font-size: 16px; }
|
||||
.kt-stern { color: var(--linie); font-size: 20px; }
|
||||
.kt-stern.an { color: #c9900f; }
|
||||
.kt-stern:hover, .kt-weg:hover, .kt-punkte:hover { background: var(--titel-bg); }
|
||||
.kt-weg:hover { color: var(--warn); }
|
||||
.kt-vorschlag { margin: 12px 0 0; padding: 8px 12px; border-radius: 8px; background: var(--markiert); font-size: 14px; }
|
||||
.kt-titel { margin: 0 0 10px; font-size: 13px; letter-spacing: 0.06em; text-transform: uppercase; color: var(--leise); }
|
||||
.kt-gruppe { display: grid; grid-template-columns: auto minmax(0, 1fr) auto auto; gap: 10px; align-items: center; padding: 10px; border: 1px solid var(--linie); border-radius: 10px; margin-bottom: 8px; }
|
||||
.kt-gruppe a, .kt-ansicht-zeile a:not(.kt-rund) { color: inherit; text-decoration: none; min-width: 0; }
|
||||
.kt-gruppe small, .kt-ansicht-zeile small { display: block; color: var(--leise); font-size: 13px; }
|
||||
.kt-art { font-size: 12px; padding: 2px 8px; border-radius: 999px; background: var(--art-mat-bg); color: var(--art-mat); white-space: nowrap; }
|
||||
.kt-rollen { display: flex; flex-wrap: wrap; gap: 6px; }
|
||||
.kt-rolle { border: 1px solid var(--linie); background: var(--fl); color: var(--text); border-radius: 999px; padding: 5px 12px; font: inherit; font-size: 14px; cursor: pointer; }
|
||||
.kt-rolle.an { background: var(--akzent-hell); border-color: var(--akzent); color: var(--akzent); font-weight: 600; }
|
||||
.kt-rolle.plus { border-style: dashed; color: var(--akzent); }
|
||||
.kt-mitarbeiter { margin: 10px 0 0; font-size: 14px; }
|
||||
.kt-rollen-editor { margin-top: 12px; padding: 12px; border: 1px solid var(--linie); border-radius: 10px; background: var(--titel-bg); display: flex; flex-direction: column; gap: 6px; }
|
||||
.kt-rollen-editor h4 { margin: 0 0 4px; font-size: 14px; }
|
||||
.kt-rollen-zeile { display: grid; grid-template-columns: minmax(0, 1fr) 32px; gap: 6px; align-items: center; }
|
||||
.kt-projekt { display: flex; justify-content: space-between; gap: 10px; padding: 8px 0; border-bottom: 1px dashed var(--linie); color: inherit; text-decoration: none; font-size: 14px; }
|
||||
.kt-projekt:last-child { border-bottom: 0; }
|
||||
.kt-marke { flex: none; font-size: 12px; padding: 2px 8px; border-radius: 6px; background: var(--akzent-hell); color: var(--akzent); align-self: start; }
|
||||
.kt-leute-kopf { display: flex; flex-wrap: wrap; gap: 10px; align-items: center; justify-content: space-between; margin-bottom: 8px; }
|
||||
.kt-leute-kopf .kt-titel { margin: 0; }
|
||||
.kt-leute-knoepfe { display: flex; gap: 8px; flex-wrap: wrap; }
|
||||
.kt-leute-tabelle { width: 100%; border-collapse: collapse; font-size: 14px; }
|
||||
.kt-leute-tabelle th { text-align: left; font-weight: 500; color: var(--leise); font-size: 13px; padding: 6px; }
|
||||
.kt-leute-tabelle td { padding: 8px 6px; border-top: 1px solid var(--linie); vertical-align: middle; }
|
||||
.kt-leute-tabelle a { color: inherit; text-decoration: none; }
|
||||
.kt-funktion { padding: 6px 8px; min-width: 8em; }
|
||||
.kt-zust { display: inline-block; font-size: 12px; padding: 2px 8px; border-radius: 6px; background: var(--akzent-hell); color: var(--akzent); white-space: nowrap; }
|
||||
.kt-zust.rechnungen { background: var(--art-sub-bg); color: var(--art-sub); }
|
||||
.kt-zust.baustelle { background: var(--gut-bg); color: var(--gut-text); }
|
||||
.kt-zust.planung { background: var(--art-mat-bg); color: var(--art-mat); }
|
||||
button.klein, a.klein { padding: 5px 10px; font-size: 14px; }
|
||||
/* Ansicht am Handy */
|
||||
.kt-ansicht { display: flex; flex-direction: column; gap: 12px; }
|
||||
.kt-zeile-kopf { display: flex; gap: 14px; align-items: center; }
|
||||
.kt-zeile-kopf h2 { margin: 0; font-size: 20px; }
|
||||
.kt-zeile-kopf p { margin: 2px 0 0; }
|
||||
.kt-aktionen { display: grid; grid-template-columns: repeat(auto-fit, minmax(70px, 1fr)); gap: 8px; margin-top: 14px; }
|
||||
.kt-aktion { display: flex; flex-direction: column; align-items: center; gap: 2px; padding: 10px 4px; border-radius: 10px; background: var(--akzent-hell); color: var(--akzent); text-decoration: none; font-size: 13px; font-weight: 600; }
|
||||
.kt-aktion span { font-size: 18px; }
|
||||
.kt-ansicht-zeile { display: flex; align-items: center; gap: 12px; padding: 8px 0; border-bottom: 1px solid var(--linie); color: inherit; text-decoration: none; }
|
||||
.kt-ansicht-zeile:last-child { border-bottom: 0; }
|
||||
.kt-ansicht-zeile > div, .kt-ansicht-zeile > a:not(.kt-rund) { flex: 1; min-width: 0; }
|
||||
.kt-rund { flex: none; display: inline-grid; place-items: center; width: 40px; height: 40px; border-radius: 50%; background: var(--akzent-hell); color: var(--akzent); text-decoration: none; font-size: 16px; }
|
||||
.kt-rund.gut { background: var(--gut-bg); color: var(--gut-text); }
|
||||
.kt-notiz { margin: 0; white-space: pre-wrap; }
|
||||
/* Ansprechpartner im Projekt */
|
||||
.pj-ap { margin-top: 10px; padding-top: 8px; border-top: 1px solid var(--linie); display: flex; flex-direction: column; gap: 6px; }
|
||||
.pj-ap-titel { margin: 0; font-size: 12px; color: var(--leise); text-transform: uppercase; letter-spacing: 0.05em; }
|
||||
.pj-ap-zeile { display: flex; align-items: center; gap: 8px; }
|
||||
.pj-ap-zeile a { flex: 1; min-width: 0; color: inherit; text-decoration: none; }
|
||||
.pj-ap-zeile small { display: block; color: var(--leise); font-size: 12px; }
|
||||
.pj-ap .verweis { align-self: flex-start; }
|
||||
.einsatz-karte .ap, .heute-karte .ap { font-size: 14px; }
|
||||
@media (max-width: 900px) {
|
||||
.kt-raster { grid-template-columns: minmax(0, 1fr); }
|
||||
}
|
||||
@media (max-width: 640px) {
|
||||
#inhalt > .kt-kopfzeile .kt-pfad, #inhalt > .kt-kopfzeile .kt-pfad a { color: var(--leiste-text); }
|
||||
.kt-namen { flex-direction: column; align-items: stretch; }
|
||||
.kt-namen > .kt-bild { display: none; }
|
||||
.kt-reihe, .kt-reihe.zwei { grid-template-columns: 1fr 1fr; }
|
||||
.kt-reihe label:last-child { grid-column: 1 / -1; }
|
||||
.kt-zeile { grid-template-columns: minmax(6em, 8em) minmax(0, 1fr) 28px 28px; gap: 6px; }
|
||||
.kt-zeile.kt-adresse { grid-template-columns: minmax(0, 1fr) 28px 28px; }
|
||||
.kt-zeile.kt-adresse select { grid-column: 1 / -1; }
|
||||
.kt-zeile.kt-adresse .kt-adressfelder { grid-column: 1; }
|
||||
.kt-form { padding: 14px; }
|
||||
.kt-knoepfe { margin-left: 0; }
|
||||
.kt-leute-tabelle th:nth-child(4), .kt-leute-tabelle td:nth-child(4) { display: none; }
|
||||
}
|
||||
|
||||
/* Projekt-Priorität A/B/C (0.48) */
|
||||
.prio { display: inline-flex; align-items: center; justify-content: center; min-width: 22px; height: 22px; padding: 0 5px; border-radius: 6px; font-size: 12px; font-weight: 700; line-height: 1; vertical-align: middle; cursor: help; }
|
||||
.prio-A { background: var(--warnung-bg); color: var(--warn); }
|
||||
.prio-B { background: var(--akzent-hell); color: var(--akzent); }
|
||||
.prio-C { background: var(--abw-grau); color: var(--leise); }
|
||||
.prio.selbst { box-shadow: inset 0 0 0 1.5px currentColor; }
|
||||
.prio-wahl { border: 0; border-radius: 999px; padding: 4px 10px; font-size: 13px; font-weight: 600; cursor: pointer; }
|
||||
.prio-wahl.selbst { box-shadow: inset 0 0 0 1.5px currentColor; }
|
||||
.prio-grund { margin: -6px 0 12px; font-size: 13px; color: var(--leise); max-width: 70em; }
|
||||
.kt-multi { display: flex; flex-wrap: wrap; align-items: baseline; gap: 6px; margin: 12px 0 0; font-size: 14px; }
|
||||
.kt-multi small { flex-basis: 100%; color: var(--leise); font-size: 12px; padding-left: 22px; }
|
||||
|
||||
/* Anschrift mit z. Hd. und Briefanrede (0.49) */
|
||||
.am-zhd { color: var(--leise); }
|
||||
.am-anrede { margin: 14px 0 4px; font-size: 15px; }
|
||||
.pj-rechnung-an { margin-top: 8px; display: grid; gap: 6px; justify-items: start; }
|
||||
.pj-rechnung-an pre { margin: 0; padding: 8px 10px; border: 1px solid var(--linie); border-radius: 7px; background: var(--titel-bg); font: inherit; font-size: 14px; white-space: pre-wrap; max-width: 100%; }
|
||||
|
||||
@@ -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,80 @@ export function seite(titel: string, knopf?: { text: string; aktion: () => void
|
||||
return leiste;
|
||||
}
|
||||
|
||||
|
||||
export 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}`);
|
||||
if (!feld) return;
|
||||
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 }));
|
||||
};
|
||||
vorschlaegeAn(feld, (t) => { setze(ziel.plz, t.plz); setze(ziel.ort, t.ort); });
|
||||
}
|
||||
|
||||
/** Vorschlagsliste an einem Straßenfeld; das Feld steckt mit einer .adr-liste in einem .adr-feld */
|
||||
export function vorschlaegeAn(feld: HTMLInputElement, uebernehmen: (t: Adressvorschlag) => void): void {
|
||||
const liste = feld.parentElement?.querySelector<HTMLElement>(".adr-liste");
|
||||
if (!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 nehmen = (i: number) => {
|
||||
const t = treffer[i];
|
||||
if (!t) return;
|
||||
feld.value = t.strasse;
|
||||
feld.dispatchEvent(new Event("change", { bubbles: true }));
|
||||
uebernehmen(t);
|
||||
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", () => {
|
||||
|
||||
82
test/brief.test.ts
Normal file
82
test/brief.test.ts
Normal file
@@ -0,0 +1,82 @@
|
||||
// Anschrift mit „z. Hd.“ und Briefanrede
|
||||
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 { type BriefPerson, empfaenger } from "../src/domain/brief.js";
|
||||
|
||||
const url = process.env.TEST_DATABASE_URL;
|
||||
const adr = (typ: string, strasse: string, haupt = true) => ({ typ, strasse, zusatz: "", plz: "23909", ort: "Ratzeburg", region: "", land: "", postfach: "", haupt });
|
||||
const jan = { name: "Jan Petersen", anrede: "Herr", titel: "Dipl.-Ing." };
|
||||
const anna = { name: "Anna Petersen", anrede: "Frau" };
|
||||
const tim = { name: "Tim Möller", anrede: "Herr" };
|
||||
|
||||
describe("Anschrift und Anrede", () => {
|
||||
it("Person: Herrn mit Titel, Anrede aus Anrede und Titel", () => {
|
||||
expect(empfaenger({ ...jan, adressen: [adr("privat", "Seestraße 12")] }, [])).toEqual({
|
||||
zeilen: ["Herrn Dipl.-Ing. Jan Petersen", "Seestraße 12", "23909 Ratzeburg"], zHd: null, anrede: "Sehr geehrter Herr Dipl.-Ing. Petersen,",
|
||||
});
|
||||
expect(empfaenger({ name: "Uwe Lange" }, []).anrede).toBe("Sehr geehrte Damen und Herren,");
|
||||
expect(empfaenger({ name: "Petersen", anrede: "Familie" }, []).zeilen[0]).toBe("Familie Petersen");
|
||||
expect(empfaenger(null, []).anrede).toBe("Sehr geehrte Damen und Herren,");
|
||||
});
|
||||
|
||||
it("Firma: z. Hd. Haupt im Projekt, sonst ★ beim Kunden; zur Rechnung zuerst „Rechnungen“ und die Rechnungsadresse", () => {
|
||||
const firma = { name: "Wohnbau Nord eG", art: "firma", adressen: [adr("geschaeftlich", "Am Markt 3"), adr("rechnung", "Postweg 1", false)] };
|
||||
const leute: BriefPerson[] = [
|
||||
{ kontakt: jan, imProjekt: null, imKunden: ["haupt"] },
|
||||
{ kontakt: tim, imProjekt: ["haupt", "baustelle"], imKunden: [] },
|
||||
{ kontakt: anna, imProjekt: null, imKunden: ["rechnungen"] },
|
||||
];
|
||||
expect(empfaenger(firma, leute)).toEqual({
|
||||
zeilen: ["Wohnbau Nord eG", "z. Hd. Herrn Tim Möller", "Am Markt 3", "23909 Ratzeburg"], zHd: "z. Hd. Herrn Tim Möller", anrede: "Sehr geehrter Herr Möller,",
|
||||
});
|
||||
expect(empfaenger(firma, leute.slice(0, 1)).zHd).toBe("z. Hd. Herrn Dipl.-Ing. Jan Petersen");
|
||||
expect(empfaenger(firma, leute, "rechnung")).toMatchObject({ zeilen: ["Wohnbau Nord eG", "z. Hd. Frau Anna Petersen", "Postweg 1", "23909 Ratzeburg"], anrede: "Sehr geehrte Frau Petersen," });
|
||||
expect(empfaenger({ ...firma, art: "behoerde" }, [])).toMatchObject({ zHd: null, anrede: "Sehr geehrte Damen und Herren," });
|
||||
});
|
||||
|
||||
it("Ehepaar und Familie: Frau und Herr aus den Ansprechpartnern", () => {
|
||||
const paar = { name: "Eheleute Petersen", art: "ehepaar", adressen: [{ ...adr("privat", "Seestraße 12"), land: "Dänemark" }] };
|
||||
const e = empfaenger(paar, [{ kontakt: jan, imProjekt: null, imKunden: [] }, { kontakt: anna, imProjekt: null, imKunden: [] }]);
|
||||
expect(e).toEqual({ zeilen: ["Eheleute Petersen", "Seestraße 12", "23909 Ratzeburg", "DÄNEMARK"], zHd: null, anrede: "Sehr geehrte Frau Petersen, sehr geehrter Herr Dipl.-Ing. Petersen," });
|
||||
expect(empfaenger({ name: "Familie Krause", art: "familie" }, []).anrede).toBe("Sehr geehrte Familie Krause,");
|
||||
});
|
||||
});
|
||||
|
||||
describe.skipIf(!url)("Anschrift mit Datenbank", () => {
|
||||
let pool: Pool;
|
||||
let app: FastifyInstance;
|
||||
beforeAll(async () => {
|
||||
pool = erstellePool(url!);
|
||||
await pool.query("drop schema public cascade; create schema public;");
|
||||
await migriere(pool);
|
||||
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
|
||||
});
|
||||
afterAll(async () => {
|
||||
await app?.close();
|
||||
await pool?.end();
|
||||
});
|
||||
const post = async (pfad: string, payload: object) => {
|
||||
const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload });
|
||||
expect(r.statusCode, r.body).toBe(201);
|
||||
return r.json();
|
||||
};
|
||||
|
||||
it("Projekt, Angebot und Rechnungsanschrift", async () => {
|
||||
const g = await post("kontakte", { name: "Wohnbau Nord eG", art: "firma", adressen: [adr("geschaeftlich", "Am Markt 3")] });
|
||||
const j = await post("kontakte", { ...jan });
|
||||
const t2 = await post("kontakte", { ...tim });
|
||||
await post("kontakt-zugehoerigkeiten", { gruppe_id: g.id, person_id: j.id, zustaendig: ["haupt"] });
|
||||
await post("kontakt-zugehoerigkeiten", { gruppe_id: g.id, person_id: t2.id, zustaendig: ["rechnungen"] });
|
||||
const p = await post("projekte", { nummer: "A-26-150", bezeichnung: "Aufstockung", status: "angebot", bauherr_id: g.id });
|
||||
const e = (await app.inject(`/api/projekte/${p.id}/empfaenger`)).json();
|
||||
expect(e).toMatchObject({ zeilen: ["Wohnbau Nord eG", "z. Hd. Herrn Dipl.-Ing. Jan Petersen", "Am Markt 3", "23909 Ratzeburg"], anrede: "Sehr geehrter Herr Dipl.-Ing. Petersen," });
|
||||
expect((await app.inject(`/api/projekte/${p.id}/empfaenger?zweck=rechnung`)).json().zHd).toBe("z. Hd. Herrn Tim Möller");
|
||||
const a = await app.inject({ method: "POST", url: "/api/angebote/neu", payload: { projekt_id: p.id } });
|
||||
expect(a.statusCode, a.body).toBeLessThan(300);
|
||||
const voll = (await app.inject(`/api/angebote/${a.json().id}/voll`)).json();
|
||||
expect(voll.empfaenger.zHd).toBe("z. Hd. Herrn Dipl.-Ing. Jan Petersen");
|
||||
});
|
||||
});
|
||||
@@ -87,10 +87,10 @@ describe.skipIf(!url)("Kontakte mit dem Handy abgleichen", () => {
|
||||
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(felderAus(karte).adressen[0]?.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));
|
||||
f.handy(`${BUCH}a2.vcf`, karteMit({ ...felderAus(f.karten.get(`${BUCH}a2.vcf`)!.karte), emails: [{ typ: "privat", wert: "jan@peters.de", haupt: true }] }, "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");
|
||||
});
|
||||
@@ -107,6 +107,50 @@ describe.skipIf(!url)("Kontakte mit dem Handy abgleichen", () => {
|
||||
expect([...f.karten.values()].some((k) => k.karte.includes("Holzhandel"))).toBe(false);
|
||||
});
|
||||
|
||||
it("übergeordnete Kontakte: ORG ordnet zu, Firmenkarte nur mit eigener Nummer", async () => {
|
||||
const wn = (await app.inject({ method: "POST", url: "/api/kontakte", payload: { name: "Wohnbau Nord eG", art: "firma" } })).json();
|
||||
const ohne = (await app.inject({ method: "POST", url: "/api/kontakte", payload: { name: "Familie Ohnenummer", art: "familie" } })).json();
|
||||
expect(await jetzt()).toBe("alles gleich");
|
||||
// Person am Handy mit ORG = vorhandene Firma und zwei Nummern
|
||||
f.handy(`${BUCH}t1.vcf`, "BEGIN:VCARD\r\nVERSION:3.0\r\nN:Möller;Tim;;;\r\nFN:Tim Möller\r\nORG:Wohnbau Nord eG;\r\nTITLE:Hausmeister\r\n"
|
||||
+ "TEL;type=CELL;type=pref:0160 5550101\r\nTEL;type=WORK:04541 80801\r\nUID:t1\r\nEND:VCARD\r\n");
|
||||
// Person mit unbekannter Firma
|
||||
f.handy(`${BUCH}t2.vcf`, "BEGIN:VCARD\r\nVERSION:3.0\r\nN:Lange;Uwe;;;\r\nFN:Uwe Lange\r\nORG:Lange Bedachungen;\r\nUID:t2\r\nEND:VCARD\r\n");
|
||||
expect(await jetzt()).toBe("2 neu vom Handy");
|
||||
const tim = await kontakt("Tim Möller");
|
||||
expect(tim.telefone).toEqual([{ typ: "mobil", wert: "0160 5550101", haupt: true }, { typ: "geschaeftlich", wert: "04541 80801", haupt: false }]);
|
||||
expect(tim).toMatchObject({ mobil: "0160 5550101", telefon: "04541 80801", firma: null });
|
||||
const zug = (await app.inject("/api/kontakt-zugehoerigkeiten")).json();
|
||||
expect(zug).toEqual([expect.objectContaining({ gruppe_id: wn.id, person_id: tim.id, funktion: "Hausmeister" })]);
|
||||
expect((await kontakt("Uwe Lange")).firma).toBe("Lange Bedachungen");
|
||||
// Funktion im Programm geändert: geht ins Handy
|
||||
await app.inject({ method: "PATCH", url: `/api/kontakt-zugehoerigkeiten/${zug[0].id}`, payload: { funktion: "Hauswart" } });
|
||||
await app.inject({ method: "PATCH", url: `/api/kontakte/${tim.id}`, payload: { notiz: "Schlüssel" } });
|
||||
expect(await jetzt()).toBe("1 ins Handy geschrieben");
|
||||
expect(felderAus(f.karten.get(`${BUCH}t1.vcf`)!.karte)).toMatchObject({ funktion: "Hauswart", firma: "Wohnbau Nord eG", notiz: "Schlüssel" });
|
||||
// Firma bekommt eine eigene Nummer: eigene Firmenkarte; die Familie ohne Nummer nicht
|
||||
await app.inject({ method: "PATCH", url: `/api/kontakte/${wn.id}`, payload: { telefone: [{ typ: "zentrale", wert: "04541 80800", haupt: true }] } });
|
||||
expect(await jetzt()).toBe("1 neu ins Handy");
|
||||
const karte = f.karten.get(`${BUCH}${wn.id}.vcf`)!.karte;
|
||||
expect(felderAus(karte)).toMatchObject({ name: "Wohnbau Nord eG", gruppe: true, telefone: [{ typ: "zentrale", wert: "04541 80800", haupt: true }] });
|
||||
expect([...f.karten.values()].some((k) => k.karte.includes("Ohnenummer"))).toBe(false);
|
||||
expect(ohne.id).toBeTruthy();
|
||||
expect(await jetzt()).toBe("alles gleich");
|
||||
});
|
||||
|
||||
it("Umstellung von 0.46: Nummern aus dem Handy gehen nicht verloren", async () => {
|
||||
const tim = await kontakt("Tim Möller");
|
||||
// so stand es nach 0.46 da: alter Fingerabdruck, im Handy eine dritte Nummer
|
||||
const href = `${BUCH}t1.vcf`;
|
||||
const alt = f.karten.get(href)!.karte.replace("END:VCARD", "TEL;type=HOME:04541 7777\r\nEND:VCARD");
|
||||
f.handy(href, alt);
|
||||
await pool.query("update kontakt_abgleich set stand = '[\"alt\"]', etag = $2 where href = $1", [href, f.karten.get(href)!.etag]);
|
||||
expect(await jetzt()).toBe("1 zusammengeführt");
|
||||
expect((await kontakt("Tim Möller")).telefone.map((x: { wert: string }) => x.wert)).toEqual(["0160 5550101", "04541 80801", "04541 7777"]);
|
||||
expect(tim.id).toBeTruthy();
|
||||
expect(await jetzt()).toBe("alles gleich");
|
||||
});
|
||||
|
||||
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 });
|
||||
|
||||
110
test/kontakte.test.ts
Normal file
110
test/kontakte.test.ts
Normal file
@@ -0,0 +1,110 @@
|
||||
// Kontaktmaske 0.47: Listen mit Typ, freie Rollen, übergeordnete Kontakte, Ansprechpartner im Projekt
|
||||
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 { einarbeiten, einzelfelder, kuerzel, listenBereinigt, rollenId } from "../src/domain/kontaktdaten.js";
|
||||
|
||||
const url = process.env.TEST_DATABASE_URL;
|
||||
|
||||
describe("Kontaktdaten", () => {
|
||||
it("genau ein Haupteintrag, leere Einträge fallen weg", () => {
|
||||
const l = listenBereinigt({ telefone: [{ typ: "privat", wert: " " }, { typ: "mobil", wert: "0171 1", haupt: true }, { typ: "mobil", wert: "0171 2", haupt: true }] });
|
||||
expect(l.telefone).toEqual([{ typ: "mobil", wert: "0171 1", haupt: true }, { typ: "mobil", wert: "0171 2", haupt: false }]);
|
||||
});
|
||||
it("Einzelfelder aus den Listen und zurück", () => {
|
||||
const l = listenBereinigt({ telefone: [{ typ: "geschaeftlich", wert: "0451 1", haupt: true }, { typ: "mobil", wert: "0171 1" }, { typ: "fax", wert: "0451 9" }] });
|
||||
expect(einzelfelder(l)).toMatchObject({ telefon: "0451 1", mobil: "0171 1" });
|
||||
const n = einarbeiten(l, { mobil: "0171 2", ort: "Ratzeburg" });
|
||||
expect(n.telefone.map((x) => x.wert)).toEqual(["0451 1", "0171 2", "0451 9"]);
|
||||
expect(n.adressen).toEqual([expect.objectContaining({ ort: "Ratzeburg", haupt: true, typ: "privat" })]);
|
||||
expect(einarbeiten(n, { mobil: null }).telefone).toHaveLength(2);
|
||||
});
|
||||
it("Kürzel und Rollen-Kennung", () => {
|
||||
expect(kuerzel("Jan Petersen")).toBe("JP");
|
||||
expect(kuerzel("Wohnbau Nord eG")).toBe("WN");
|
||||
expect(rollenId("Bauüberwachung / Statik")).toBe("bauueberwachung-statik");
|
||||
});
|
||||
});
|
||||
|
||||
describe.skipIf(!url)("Kontakte mit Datenbank", () => {
|
||||
let pool: Pool;
|
||||
let app: FastifyInstance;
|
||||
beforeAll(async () => {
|
||||
pool = erstellePool(url!);
|
||||
await pool.query("drop schema public cascade; create schema public;");
|
||||
await migriere(pool);
|
||||
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
|
||||
});
|
||||
afterAll(async () => {
|
||||
await app?.close();
|
||||
await pool?.end();
|
||||
});
|
||||
const senden = async (method: "POST" | "PATCH" | "DELETE", pfad: string, payload?: object) => {
|
||||
const r = await app.inject({ method, url: `/api/${pfad}`, payload });
|
||||
return { status: r.statusCode, body: r.body ? r.json() : null };
|
||||
};
|
||||
|
||||
it("alte Einzelfelder werden zu Listen (auch beim Einspielen alter Sicherungen)", async () => {
|
||||
await pool.query("insert into kontakt (name, firma, telefon, mobil, email, ort, rolle) values ('Alt Kunde', 'Alt GmbH', '0451 1', '0171 1', 'a@alt.de', 'Mölln', 'bauherr')");
|
||||
await pool.query("select kontakt_listen_aus_einzelfeldern()");
|
||||
const k = (await pool.query("select * from kontakt where name = 'Alt Kunde'")).rows[0];
|
||||
expect(k.telefone).toEqual([{ typ: "mobil", wert: "0171 1", haupt: true }, { typ: "geschaeftlich", wert: "0451 1", haupt: false }]);
|
||||
expect(k.emails).toEqual([{ typ: "geschaeftlich", wert: "a@alt.de", haupt: true }]);
|
||||
expect(k.adressen[0]).toMatchObject({ ort: "Mölln", haupt: true });
|
||||
expect(k.rollen).toEqual(["bauherr"]);
|
||||
});
|
||||
|
||||
it("Listen setzen die Einzelfelder, Einzelfelder arbeiten sich in die Listen ein", async () => {
|
||||
const k = (await senden("POST", "kontakte", { name: "Jan Petersen", telefone: [{ typ: "privat", wert: "04541 1", haupt: false }, { typ: "mobil", wert: "0171 2", haupt: true }],
|
||||
adressen: [{ typ: "privat", strasse: "Seestraße 12", zusatz: "", plz: "23909", ort: "Ratzeburg" }] })).body;
|
||||
expect(k).toMatchObject({ mobil: "0171 2", telefon: "04541 1", strasse: "Seestraße 12", ort: "Ratzeburg", rolle: "sonstige" });
|
||||
// wer nur Einzelfelder schreibt (Kunde im Projekt anlegen), ändert den passenden Listeneintrag
|
||||
const n = (await senden("PATCH", `kontakte/${k.id}`, { mobil: "0171 3", email: "jan@x.de" })).body;
|
||||
expect(n.telefone).toEqual([{ typ: "privat", wert: "04541 1", haupt: false }, { typ: "mobil", wert: "0171 3", haupt: true }]);
|
||||
expect(n.emails).toEqual([{ typ: "privat", wert: "jan@x.de", haupt: true }]);
|
||||
expect(n.adressen).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("Rollen frei anlegen, umbenennen, löschen; feste Rollen bleiben", async () => {
|
||||
const a = await senden("POST", "kontakt-rollen", { name: "Architekt" });
|
||||
expect(a).toMatchObject({ status: 201, body: { id: "architekt", name: "Architekt", fest: false } });
|
||||
expect((await senden("POST", "kontakt-rollen", { name: "architekt" })).status).toBe(200);
|
||||
expect((await senden("PATCH", "kontakt-rollen/architekt", { name: "Architektin" })).body.name).toBe("Architektin");
|
||||
expect((await senden("PATCH", "kontakt-rollen/subunternehmer", { name: "Sub" })).status).toBe(409);
|
||||
expect((await senden("DELETE", "kontakt-rollen/mitarbeiter")).status).toBe(409);
|
||||
const k = (await senden("POST", "kontakte", { name: "Anna Plan", rollen: ["architekt", "bauherr", "architekt"] })).body;
|
||||
expect(k).toMatchObject({ rollen: ["architekt", "bauherr"], rolle: "architekt" });
|
||||
expect((await senden("DELETE", "kontakt-rollen/architekt")).status).toBe(204);
|
||||
expect((await pool.query("select rollen, rolle from kontakt where id = $1", [k.id])).rows[0]).toEqual({ rollen: ["bauherr"], rolle: "bauherr" });
|
||||
});
|
||||
|
||||
it("Mitarbeiter gibt es nur über die Mitarbeiterseite und bleibt beim Speichern der Maske", async () => {
|
||||
const k = (await senden("POST", "kontakte", { name: "Max Müller" })).body;
|
||||
// Personal setzt rolle; der Trigger nimmt sie in die Rollen auf
|
||||
await pool.query("update kontakt set rolle = 'mitarbeiter' where id = $1", [k.id]);
|
||||
expect((await pool.query("select rollen, rolle from kontakt where id = $1", [k.id])).rows[0]).toEqual({ rollen: ["mitarbeiter"], rolle: "mitarbeiter" });
|
||||
const n = (await senden("PATCH", `kontakte/${k.id}`, { rollen: ["planer"] })).body;
|
||||
expect(n.rollen).toEqual(["planer", "mitarbeiter"]);
|
||||
expect(n.rolle).toBe("mitarbeiter");
|
||||
});
|
||||
|
||||
it("übergeordnete Kontakte mit Ansprechpartnern, Ansprechpartner im Projekt", async () => {
|
||||
const g = (await senden("POST", "kontakte", { name: "Wohnbau Nord eG", art: "firma", rollen: ["bauherr"] })).body;
|
||||
expect(g.art).toBe("firma");
|
||||
expect((await senden("POST", "kontakte", { name: "Falsch", art: "verein" })).status).toBe(400);
|
||||
const jan = (await pool.query("select id from kontakt where name = 'Jan Petersen'")).rows[0].id;
|
||||
const z = await senden("POST", "kontakt-zugehoerigkeiten", { gruppe_id: g.id, person_id: jan, funktion: "Technischer Leiter", zustaendig: ["haupt"] });
|
||||
expect(z.status).toBe(201);
|
||||
expect((await senden("POST", "kontakt-zugehoerigkeiten", { gruppe_id: g.id, person_id: jan })).status).toBeGreaterThanOrEqual(400);
|
||||
const p = (await senden("POST", "projekte", { nummer: "P-26-090", bezeichnung: "Aufstockung Am Markt", status: "auftrag", bauherr_id: g.id })).body;
|
||||
const ap = await senden("POST", "projekt-ansprechpartner", { projekt_id: p.id, kontakt_id: jan, zustaendig: ["baustelle"] });
|
||||
expect(ap.status).toBe(201);
|
||||
expect((await app.inject(`/api/projekt-ansprechpartner`)).json()).toEqual([expect.objectContaining({ projekt_id: p.id, kontakt_id: jan, zustaendig: ["baustelle"] })]);
|
||||
// Person gelöscht: Zuordnungen gehen mit
|
||||
await senden("DELETE", `kontakte/${jan}`);
|
||||
expect((await pool.query("select count(*)::int as n from kontakt_zugehoerigkeit")).rows[0].n).toBe(0);
|
||||
expect((await pool.query("select count(*)::int as n from projekt_ansprechpartner")).rows[0].n).toBe(0);
|
||||
});
|
||||
});
|
||||
82
test/prioritaet.test.ts
Normal file
82
test/prioritaet.test.ts
Normal file
@@ -0,0 +1,82 @@
|
||||
// Projekt-Priorität A/B/C: Vorschlag aus Ertrag, Kunde und Dringlichkeit, selbst gesetzt gilt
|
||||
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 { type PrioEingang, prioAus, prioritaeten } from "../src/domain/prioritaet.js";
|
||||
|
||||
const url = process.env.TEST_DATABASE_URL;
|
||||
const leer: Omit<PrioEingang, "id"> = { status: "auftrag", ertrag: null, kunde: "neu", frist: null, termindruck: null, bindefrist: null, prioritaet: null };
|
||||
|
||||
describe("Priorität rechnen", () => {
|
||||
it("Punkte zu A, B, C", () => {
|
||||
expect([6, 5, 4, 3, 2, 0].map(prioAus)).toEqual(["A", "A", "B", "B", "C", "C"]);
|
||||
});
|
||||
|
||||
it("Ertrag im Vergleich zum Schnitt, Kunde, Dringlichkeit", () => {
|
||||
const e = prioritaeten([
|
||||
{ ...leer, id: "gut", ertrag: 9000, kunde: "multiplikator", termindruck: "vertragsstrafe" },
|
||||
{ ...leer, id: "mittel", ertrag: 6000, kunde: "stamm", frist: "2026-12-20" },
|
||||
{ ...leer, id: "schwach", ertrag: 3000 },
|
||||
{ ...leer, id: "ohne", kunde: null, status: "anfrage" },
|
||||
], "2026-11-08");
|
||||
// Schnitt 60 €/Std.
|
||||
expect(e.get("gut")).toMatchObject({ summe: 6, vorschlag: "A", prioritaet: "A", ertrag: { punkte: 2 }, kunde: { punkte: 2 }, dringlichkeit: { punkte: 2, text: "fester Termin / Vertragsstrafe" } });
|
||||
expect(e.get("mittel")).toMatchObject({ summe: 3, vorschlag: "B", ertrag: { punkte: 1 }, kunde: { punkte: 1 }, dringlichkeit: { punkte: 1, text: "Frist in 42 Tagen" } });
|
||||
expect(e.get("schwach")).toMatchObject({ summe: 0, vorschlag: "C" });
|
||||
// ohne Zahlen neutral
|
||||
expect(e.get("ohne")).toMatchObject({ ertrag: { punkte: 1, wert: null }, kunde: { punkte: 0, text: "kein Kunde eingetragen" }, vorschlag: "C" });
|
||||
});
|
||||
|
||||
it("Bindefrist, Witterung vor dem Winter, selbst gesetzt", () => {
|
||||
const e = prioritaeten([
|
||||
{ ...leer, id: "a", status: "angebot", bindefrist: "2026-11-12" },
|
||||
{ ...leer, id: "w", termindruck: "witterung" },
|
||||
{ ...leer, id: "s", prioritaet: "A" },
|
||||
], "2026-11-08");
|
||||
expect(e.get("a")!.dringlichkeit).toEqual({ punkte: 2, text: "Bindefrist in 4 Tagen" });
|
||||
expect(e.get("w")!.dringlichkeit).toEqual({ punkte: 2, text: "witterungsabhängig, vor dem Winter" });
|
||||
expect(prioritaeten([{ ...leer, id: "w", termindruck: "witterung" }], "2027-05-02").get("w")!.dringlichkeit.punkte).toBe(1);
|
||||
expect(e.get("s")).toMatchObject({ vorschlag: "C", prioritaet: "A", selbst: true });
|
||||
});
|
||||
});
|
||||
|
||||
describe.skipIf(!url)("Priorität mit Datenbank", () => {
|
||||
let pool: Pool;
|
||||
let app: FastifyInstance;
|
||||
beforeAll(async () => {
|
||||
pool = erstellePool(url!);
|
||||
await pool.query("drop schema public cascade; create schema public;");
|
||||
await migriere(pool);
|
||||
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
|
||||
});
|
||||
afterAll(async () => {
|
||||
await app?.close();
|
||||
await pool?.end();
|
||||
});
|
||||
const post = async (pfad: string, payload: object) => {
|
||||
const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload });
|
||||
expect(r.statusCode, r.body).toBe(201);
|
||||
return r.json();
|
||||
};
|
||||
|
||||
it("Stammkunde, Multiplikator, Ertrag je Stunde, selbst setzen; im Terminplan", async () => {
|
||||
const stamm = await post("kontakte", { name: "Stamm Kunde" });
|
||||
const archi = await post("kontakte", { name: "Anna Architektin", multiplikator: true });
|
||||
await post("projekte", { nummer: "P-26-101", bezeichnung: "Alt", status: "abgeschlossen", bauherr_id: stamm.id, umsatz_netto: 1000000, material_kosten: 400000, soll_stunden: 100 });
|
||||
const b = await post("projekte", { nummer: "P-26-102", bezeichnung: "Dach Stamm", status: "auftrag", bauherr_id: stamm.id, umsatz_netto: 2000000, material_kosten: 800000, soll_stunden: 100 });
|
||||
const c = await post("projekte", { nummer: "P-26-103", bezeichnung: "Carport Architektin", status: "auftrag", bauherr_id: archi.id, umsatz_netto: 300000, material_kosten: 150000, soll_stunden: 50,
|
||||
frist: "2026-01-01", termindruck: "witterung" });
|
||||
const prios = (await app.inject("/api/prioritaeten")).json() as { id: string; ertrag: { wert: number; punkte: number }; kunde: { text: string }; prioritaet: string }[];
|
||||
// das abgeschlossene Projekt zählt beim Schnitt mit, bekommt aber keine Priorität
|
||||
expect(prios.map((x) => x.id).sort()).toEqual([b.id, c.id].sort());
|
||||
const pb = prios.find((x) => x.id === b.id)!, pc = prios.find((x) => x.id === c.id)!;
|
||||
expect(pb).toMatchObject({ ertrag: { wert: 12000, punkte: 2 }, kunde: { text: "Stammkunde" } });
|
||||
expect(pc).toMatchObject({ ertrag: { wert: 3000, punkte: 0 }, kunde: { text: "Kunde empfiehlt weiter" } });
|
||||
await app.inject({ method: "PATCH", url: `/api/projekte/${c.id}`, payload: { prioritaet: "A" } });
|
||||
const plan = (await app.inject("/api/terminplan")).json();
|
||||
expect(plan.projekte.find((p: { id: string }) => p.id === c.id).prio).toMatchObject({ prioritaet: "A", selbst: true });
|
||||
expect((await app.inject({ method: "PATCH", url: `/api/projekte/${c.id}`, payload: { prioritaet: "D" } })).statusCode).toBe(400);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +1,5 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { felderAus, fingerabdruck, karteMit, kartenAus, nummer, revVon, uidVon } from "../src/domain/vcard.js";
|
||||
import { ergaenzt, felderAus, fingerabdruck, istVerteiler, karteMit, kartenAus, nummer, revVon, uidVon } from "../src/domain/vcard.js";
|
||||
|
||||
// so exportiert Apple Kontakte (gekürzt)
|
||||
const APPLE = `BEGIN:VCARD\r
|
||||
@@ -29,39 +29,98 @@ END:VCARD\r
|
||||
`;
|
||||
|
||||
describe("vCard", () => {
|
||||
it("liest Apple-Karten", () => {
|
||||
const PETRA = {
|
||||
name: "Petra Braun", anrede: null, titel: null, firma: "Braun & Müller GbR", funktion: null, gruppe: false,
|
||||
telefone: [{ typ: "mobil", wert: "0171 1234567", haupt: true }, { typ: "privat", wert: "04541 8899", haupt: false }],
|
||||
emails: [{ typ: "privat", wert: "petra@example.de", haupt: true }],
|
||||
adressen: [{ typ: "privat", strasse: "Am Markt 3", zusatz: "Hinterhaus", plz: "23909", ort: "Ratzeburg", region: "", land: "Deutschland", postfach: "", haupt: true }],
|
||||
notiz: "sehr lange Notiz, die über die Zeile hinaus geht",
|
||||
};
|
||||
|
||||
it("liest Apple-Karten mit allen Nummern samt Typ", () => {
|
||||
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(felderAus(a!)).toEqual(PETRA);
|
||||
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 });
|
||||
expect(felderAus(b!)).toMatchObject({ name: "Holzhandel Nord", firma: "Holzhandel Nord", gruppe: true, telefone: [{ typ: "geschaeftlich", wert: "+49 451 123", haupt: true }] });
|
||||
});
|
||||
|
||||
it("schreibt nur die gepflegten Zeilen, der Rest bleibt", () => {
|
||||
it("liest Bezeichnungen, Anrede und Titel", () => {
|
||||
const k = felderAus(`BEGIN:VCARD\r\nVERSION:3.0\r\nN:Petersen;Jan;;Herr Dipl.-Ing.;\r\nFN:Jan Petersen\r\nORG:Wohnbau Nord eG;Technik\r\nTITLE:Technischer Leiter\r\n`
|
||||
+ `item1.TEL:0451 1\r\nitem1.X-ABLabel:_$!<Main>!$_\r\nTEL;TYPE="work,fax":0451 2\r\nitem2.EMAIL;type=INTERNET:rechnung@wn.de\r\nitem2.X-ABLabel:Rechnungen\r\n`
|
||||
+ `EMAIL;TYPE=work;PREF=1:jan@wn.de\r\nTEL;VALUE=uri:tel:+49171555\r\nEND:VCARD\r\n`);
|
||||
expect(k).toMatchObject({ name: "Jan Petersen", anrede: "Herr", titel: "Dipl.-Ing.", firma: "Wohnbau Nord eG", funktion: "Technischer Leiter", gruppe: false });
|
||||
expect(k.telefone).toEqual([{ typ: "zentrale", wert: "0451 1", haupt: true }, { typ: "fax", wert: "0451 2", haupt: false }, { typ: "sonstige", wert: "+49171555", haupt: false }]);
|
||||
expect(k.emails).toEqual([{ typ: "rechnung", wert: "rechnung@wn.de", haupt: false }, { typ: "geschaeftlich", wert: "jan@wn.de", haupt: true }]);
|
||||
expect(istVerteiler("BEGIN:VCARD\r\nFN:Kunden\r\nX-ADDRESSBOOKSERVER-KIND:group\r\nEND:VCARD")).toBe(true);
|
||||
expect(istVerteiler(APPLE)).toBe(false);
|
||||
});
|
||||
|
||||
it("schreibt nur geänderte Zeilen, der Rest bleibt", () => {
|
||||
const [a] = kartenAus(APPLE);
|
||||
const f = { ...felderAus(a!), mobil: "0171 7654321", email: null };
|
||||
const f = { ...felderAus(a!), telefone: [{ typ: "mobil", wert: "0171 7654321", haupt: true }, { typ: "privat", wert: "04541 8899", haupt: false }], emails: [] };
|
||||
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");
|
||||
// Adresse unverändert: Apples Zeilen bleiben samt Ländercode
|
||||
expect(neu).toContain("item1.X-ABADR:de");
|
||||
expect(neu).toContain("Deutschland");
|
||||
expect(neu).toContain("item1.ADR;type=HOME;type=pref:;;Am Markt 3\\nHinterhaus;Ratzeburg;;23909;Deutschland");
|
||||
expect(neu).toContain("N:Braun;Petra;;;");
|
||||
expect(neu).toContain("TEL;type=CELL;type=VOICE;type=pref:0171 7654321");
|
||||
expect(neu).not.toContain("EMAIL");
|
||||
expect(revVon(neu)).toBe("2026-11-05T10:00:00Z");
|
||||
// nur die Anrede geändert: Apples Namensaufteilung bleibt
|
||||
expect(karteMit({ ...f, anrede: "Frau" }, "ABC-123", neu)).toContain("N:Braun;Petra;;Frau;");
|
||||
});
|
||||
|
||||
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" };
|
||||
it("legt neue Karten an, mit Sonderzeichen und eigenen Typen", () => {
|
||||
const f = {
|
||||
name: "Jan Peters", anrede: "Herr", titel: "Dr.", firma: "Peters; Söhne", funktion: "Inhaber", gruppe: false, notiz: "Zeile 1\nZeile 2",
|
||||
telefone: [{ typ: "geschaeftlich", wert: "0451 1", haupt: true }, { typ: "sonstige", wert: "0451 9", haupt: false }],
|
||||
emails: [{ typ: "rechnung", wert: "jan@x.de", haupt: true }],
|
||||
adressen: [{ typ: "rechnung", strasse: "Weg 1", zusatz: "", plz: "23909", ort: "Ratzeburg", region: "Schleswig-Holstein", land: "", postfach: "Postfach 12", haupt: true }],
|
||||
};
|
||||
const k = karteMit(f, "u1", null);
|
||||
expect(k).toMatch(/^BEGIN:VCARD\r\nVERSION:3.0\r\n/);
|
||||
expect(k).toContain("N:Peters;Jan;;;");
|
||||
expect(k).toContain("N:Peters;Jan;;Herr Dr.;");
|
||||
expect(k).toContain("item2.X-ABLabel:Rechnungen");
|
||||
expect(felderAus(k)).toEqual(f);
|
||||
expect(fingerabdruck(felderAus(k))).toBe(fingerabdruck(f));
|
||||
expect(uidVon(k)).toBe("u1");
|
||||
});
|
||||
|
||||
it("Firmenkarte", () => {
|
||||
const f = { name: "Wohnbau Nord eG", anrede: null, titel: null, firma: "Wohnbau Nord eG", funktion: undefined, gruppe: true, notiz: null,
|
||||
telefone: [{ typ: "zentrale", wert: "04541 80800", haupt: true }], emails: [], adressen: [] };
|
||||
const k = karteMit(f, "g1", null);
|
||||
expect(k).toContain("X-ABShowAs:COMPANY");
|
||||
expect(k).toContain("N:;;;;");
|
||||
expect(felderAus(k)).toEqual(f);
|
||||
});
|
||||
|
||||
it("ergänzt Programm um die Karte, ohne Programmwerte zu überschreiben", () => {
|
||||
const [a] = kartenAus(APPLE);
|
||||
const k = { ...PETRA, firma: null, notiz: "eigene", telefone: [{ typ: "mobil", wert: "+49 171 1234567", haupt: true }], emails: [], adressen: [] };
|
||||
const m = ergaenzt(k, felderAus(a!));
|
||||
expect(m.notiz).toBe("eigene");
|
||||
expect(m.firma).toBe("Braun & Müller GbR");
|
||||
expect(m.telefone).toEqual([{ typ: "mobil", wert: "+49 171 1234567", haupt: true }, { typ: "privat", wert: "04541 8899", haupt: false }]);
|
||||
expect(m.emails).toHaveLength(1);
|
||||
});
|
||||
|
||||
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