0.47.0: Kontaktmaske, übergeordnete Kontakte, freie Rollen, Ansprechpartner im Projekt
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

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 82da397c96
22 changed files with 1413 additions and 169 deletions

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