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

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++;
}