0.47.0: Kontaktmaske, übergeordnete Kontakte, freie Rollen, Ansprechpartner im Projekt

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
Claude
2026-11-08 07:29:16 +00:00
parent 3e8abd0eeb
commit a4f251d2b6
22 changed files with 1413 additions and 169 deletions

View File

@@ -2,6 +2,16 @@
Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen.
## 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.

View File

@@ -48,7 +48,7 @@ cd deploy
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 0.46.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`.
3. `cd deploy && ./update.sh 0.47.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.

View File

@@ -30,6 +30,7 @@ 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";
const MIGRATIONEN: [string, string][] = [
["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004],
@@ -55,6 +56,7 @@ const MIGRATIONEN: [string, string][] = [
["026_zahlung_bezahlt.sql", m026],
["027_zaehlt.sql", m027],
["028_kontakte_abgleich.sql", m028],
["029_kontakte_neu.sql", m029],
];
export async function starte(db: PGlite, v70?: unknown) {

View File

@@ -1,7 +1,7 @@
# 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.46.0
APP_VERSION=0.47.0
# Hier lauscht das Programm für den HAProxy (Adresse des Docker-Rechners im VPN)
APP_ADRESSE=100.64.0.8
APP_PORT=33181

View File

@@ -1,6 +1,6 @@
{
"name": "betrieb",
"version": "0.46.0",
"version": "0.47.0",
"private": true,
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
"type": "module",

108
src/domain/kontaktdaten.ts Normal file
View 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";
}

View File

@@ -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";
}

View File

@@ -36,6 +36,7 @@ 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 { type Anschrift, type Listen, type Nummer, einarbeiten, einzelfelder, listenBereinigt, rollenId } from "../domain/kontaktdaten.js";
export interface Optionen {
pool: Pool;
@@ -267,6 +268,37 @@ 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();
@@ -360,6 +392,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;
@@ -406,6 +463,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(
@@ -432,6 +490,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];

View File

@@ -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) }))

View File

@@ -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, abrufMitUrsache } from "./nextcloud.js";
import { FELDER, type KontaktFelder, felderAus, fingerabdruck, karteMit, kartenAus, nummer, revVon, uidVon } from "../domain/vcard.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 }
@@ -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++;
}

View 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();

View File

@@ -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) {

View File

@@ -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,15 @@ 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(),
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 +82,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",
@@ -135,6 +156,13 @@ export const TABELLEN: Tabelle[] = [
notiz: optText,
}),
},
// 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 +518,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

View File

@@ -22,42 +22,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", adresse: { plz: "plz", ort: "ort" } }, { name: "plz", titel: "PLZ" }, { name: "ort", titel: "Ort" },
{ name: "notiz", titel: "Notiz", art: "langtext" },
];
async function kontakte(): Promise<void> {
const neu = async () => (await bearbeiten("kontakte", "Neuer Kontakt", KONTAKT_FELDER, null)) && kontakte();
seite("Kontakte", { text: "Neuer Kontakt", aktion: neu });
const [zeilen, 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,11 +72,13 @@ 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", adresse: { plz: "baustelle_plz", ort: "baustelle_ort" } }, { name: "baustelle_plz", titel: "Baustelle: PLZ" }, { name: "baustelle_ort", titel: "Baustelle: Ort" },
@@ -220,6 +221,8 @@ 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 neuLaden = () => projektSeite(id);
const kontakt = Object.fromEntries(kontaktListe.map((k) => [k.id, k]));
const kunde = kontakt[p.bauherr_id];
@@ -229,6 +232,15 @@ 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></div>`;
}
inhalt.innerHTML = `${hinweisHtml()}
<div class="kopf projekt-kopf"><a class="neben zurueck" href="#projekte" aria-label="Zurück zur Projektliste">←</a>
@@ -311,9 +323,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
@@ -363,7 +375,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 },
@@ -557,7 +569,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])] },
@@ -689,6 +701,37 @@ 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();
}
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)
@@ -1572,6 +1615,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];
@@ -1592,13 +1637,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)

371
src/web/kontakt.ts Normal file
View File

@@ -0,0 +1,371 @@
// 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>
${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) => {
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,
};
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; }
}
}

View File

@@ -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>`);
}

View File

@@ -509,12 +509,6 @@ async function neuerMitarbeiter(): Promise<void> {
location.hash = `mitarbeiter-${id}`;
}
/** Kontaktdaten auf der Mitarbeiterseite: dieselben wie unter Kontakte */
const KONTAKTDATEN: Feld[] = [
{ name: "name", titel: "Name", pflicht: true }, { name: "telefon", titel: "Telefon" }, { name: "mobil", titel: "Mobil" }, { name: "email", titel: "E-Mail" },
{ name: "strasse", titel: "Straße", adresse: { plz: "plz", ort: "ort" } }, { name: "plz", titel: "PLZ" }, { name: "ort", titel: "Ort" },
];
export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Promise<void> {
const jahr = Number(heute().slice(0, 4));
const bis = new Date(Date.now() + 27 * 86400000).toISOString().slice(0, 10);
@@ -544,7 +538,7 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro
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><button class="neben" data-a="kontakt">Bearbeiten</button></div>
<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>
@@ -694,12 +688,6 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro
raster.addEventListener("click", (ev) => {
const a = (ev.target as HTMLElement).dataset.a;
if (a === "stamm") void stammDialog();
if (a === "kontakt") void (async () => {
const r = await dialog("Kontakt bearbeiten", KONTAKTDATEN, kontakt, false);
if (r?.aktion !== "speichern") return;
await api(`kontakte/${kontaktId}`, "PATCH", r.daten);
neuLaden();
})();
if (a === "konto") void kontoDialog();
if (a === "modell") void modellDialog(null);
if (a === "abw") void abwDialog(null);

View File

@@ -2054,3 +2054,114 @@ 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; }
}

View File

@@ -334,7 +334,7 @@ export function seite(titel: string, knopf?: { text: string; aktion: () => void
}
interface Adressvorschlag { strasse: string; plz: string; ort: string; titel: string; quelle: "kontakt" | "projekt" | "karte" }
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" };
/**
@@ -343,8 +343,20 @@ const QUELLE: Record<Adressvorschlag["quelle"], string> = { kontakt: "Kontakt",
*/
export function adressVorschlaege(form: HTMLElement, name: string, ziel: { plz: string; ort: string }): void {
const feld = form.querySelector<HTMLInputElement>(`#f-${name}`);
const liste = feld?.parentElement?.querySelector<HTMLElement>(".adr-liste");
if (!feld || !liste) return;
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; };
@@ -358,19 +370,12 @@ export function adressVorschlaege(form: HTMLElement, name: string, ziel: { plz:
liste.hidden = false;
feld.setAttribute("aria-expanded", "true");
};
const setze = (id: string, wert: string) => {
const el = form.querySelector<HTMLInputElement>(`#f-${id}`);
if (!el || !wert) return;
el.value = wert;
el.dispatchEvent(new Event("input", { bubbles: true }));
};
const nehmen = (i: number) => {
const t = treffer[i];
if (!t) return;
feld.value = t.strasse;
feld.dispatchEvent(new Event("change", { bubbles: true }));
setze(ziel.plz, t.plz);
setze(ziel.ort, t.ort);
uebernehmen(t);
treffer = [];
zu();
};

View File

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

View File

@@ -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,37 +29,85 @@ 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 }));