From 7f8f50512611d0a35a1840f969b57e0dcf74a13c Mon Sep 17 00:00:00 2001 From: Florian Wilde Date: Fri, 11 Sep 2026 23:03:32 +0200 Subject: [PATCH 01/14] feat: Datenmodell und Umgebung fuer Integrationen MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ein Zustand je Quelle haelt fest, wie weit gelesen wurde und ob es klappt. Der Merker ist bewusst ein freier Text: Zammad braucht darin einen Zeitstempel, Telegram den Zaehler der zuletzt geholten Nachricht. Dazu die gespiegelte Belegung ohne Titel, das Adressbuch der erlaubten Telegram-Chats und der Einmalcode, mit dem sich ein Chat anmeldet. Welche Integration eine Instanz darf, entscheidet weiterhin INSTANZ. Ein Zammad-Token in der Instanz daheim bleibt wirkungslos — das steht in den Faehigkeiten, nicht in einer Einstellung, die sich verstellen liesse. Co-Authored-By: Claude Opus 5 --- .env.example | 23 +++++ .../migration.sql | 62 ++++++++++++ .../migration.sql | 16 ++++ prisma/schema.prisma | 96 ++++++++++++++++++- src/server/umgebung.ts | 40 +++++++- 5 files changed, 233 insertions(+), 4 deletions(-) create mode 100644 prisma/migrations/20260911185221_integrationen/migration.sql create mode 100644 prisma/migrations/20260911204204_telegram_kopplung/migration.sql diff --git a/.env.example b/.env.example index 787a36e..614d955 100644 --- a/.env.example +++ b/.env.example @@ -97,6 +97,29 @@ SMTP_ABSENDER= # true bei Port 465 (SMTPS), false bei 587 mit STARTTLS. SMTP_TLS=false +# --- Integrationen --------------------------------------------------------- +# Alles freiwillig. Was fehlt, erscheint unter "Integrationen" als nicht +# eingerichtet; der Rest laeuft weiter. +# Welche Integration eine Instanz ueberhaupt darf, entscheidet INSTANZ: +# Zammad und Wartungsplaner nur "firma", Telegram nur "daheim". + +# Zammad (nur firma). Token in Zammad unter Profil > Token-Zugriff anlegen; +# er sieht genau das, was der zugehoerige Benutzer sehen darf. +ZAMMAD_URL= +ZAMMAD_TOKEN= +# Suchausdruck in Zammads Syntax. Was darauf passt, wird zur Aufgabe. +ZAMMAD_ABFRAGE=owner_id:me AND (state.name:new OR state.name:open) + +# Telegram (nur daheim). Bot bei @BotFather anlegen, Token hier eintragen. +# Welche Chats mitreden duerfen, wird in der Anwendung gekoppelt. +TELEGRAM_TOKEN= + +# Spiegel: firma sendet, daheim empfaengt. Dasselbe Geheimnis auf beiden +# Seiten, mindestens 32 Zeichen: openssl rand -base64 32 +SPIEGEL_GEHEIMNIS= +# Nur auf der sendenden Seite (firma): die Adresse der anderen Instanz. +SPIEGEL_ZIEL= + # --- Sonstiges ------------------------------------------------------------- # Zeitzone fuer Anzeigen und Tagesgrenzen. TZ=Europe/Berlin diff --git a/prisma/migrations/20260911185221_integrationen/migration.sql b/prisma/migrations/20260911185221_integrationen/migration.sql new file mode 100644 index 0000000..7a0d340 --- /dev/null +++ b/prisma/migrations/20260911185221_integrationen/migration.sql @@ -0,0 +1,62 @@ +-- AlterTable +ALTER TABLE "aufgabe" ADD COLUMN "spiegeln" BOOLEAN NOT NULL DEFAULT false; + +-- AlterTable +ALTER TABLE "benachrichtigungseinstellung" ADD COLUMN "perTelegram" BOOLEAN NOT NULL DEFAULT false; + +-- CreateTable +CREATE TABLE "integrationszustand" ( + "id" TEXT NOT NULL, + "quelle" "Quelle" NOT NULL, + "merker" TEXT, + "letzterLauf" TIMESTAMP(3), + "letzterErfolg" TIMESTAMP(3), + "letzterFehler" TEXT, + "fehlversuche" INTEGER NOT NULL DEFAULT 0, + "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + "aktualisiertAm" TIMESTAMP(3) NOT NULL, + + CONSTRAINT "integrationszustand_pkey" PRIMARY KEY ("id") +); + +-- CreateTable +CREATE TABLE "spiegelbelegung" ( + "id" TEXT NOT NULL, + "quelleRef" TEXT NOT NULL, + "beginn" TIMESTAMP(3) NOT NULL, + "ende" TIMESTAMP(3) NOT NULL, + "empfangenAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + + CONSTRAINT "spiegelbelegung_pkey" PRIMARY KEY ("id") +); + +-- CreateTable +CREATE TABLE "telegram_chat" ( + "id" TEXT NOT NULL, + "chatId" BIGINT NOT NULL, + "bezeichnung" TEXT, + "benutzerId" TEXT, + "meldungen" BOOLEAN NOT NULL DEFAULT true, + "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + "zuletztBenutzt" TIMESTAMP(3), + + CONSTRAINT "telegram_chat_pkey" PRIMARY KEY ("id") +); + +-- CreateIndex +CREATE UNIQUE INDEX "integrationszustand_quelle_key" ON "integrationszustand"("quelle"); + +-- CreateIndex +CREATE UNIQUE INDEX "spiegelbelegung_quelleRef_key" ON "spiegelbelegung"("quelleRef"); + +-- CreateIndex +CREATE INDEX "spiegelbelegung_beginn_idx" ON "spiegelbelegung"("beginn"); + +-- CreateIndex +CREATE UNIQUE INDEX "telegram_chat_chatId_key" ON "telegram_chat"("chatId"); + +-- CreateIndex +CREATE INDEX "telegram_chat_benutzerId_idx" ON "telegram_chat"("benutzerId"); + +-- AddForeignKey +ALTER TABLE "telegram_chat" ADD CONSTRAINT "telegram_chat_benutzerId_fkey" FOREIGN KEY ("benutzerId") REFERENCES "benutzer"("id") ON DELETE SET NULL ON UPDATE CASCADE; diff --git a/prisma/migrations/20260911204204_telegram_kopplung/migration.sql b/prisma/migrations/20260911204204_telegram_kopplung/migration.sql new file mode 100644 index 0000000..d0945b7 --- /dev/null +++ b/prisma/migrations/20260911204204_telegram_kopplung/migration.sql @@ -0,0 +1,16 @@ +-- CreateTable +CREATE TABLE "telegram_kopplung" ( + "id" TEXT NOT NULL, + "code" TEXT NOT NULL, + "benutzerId" TEXT NOT NULL, + "gueltigBis" TIMESTAMP(3) NOT NULL, + "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + + CONSTRAINT "telegram_kopplung_pkey" PRIMARY KEY ("id") +); + +-- CreateIndex +CREATE UNIQUE INDEX "telegram_kopplung_code_key" ON "telegram_kopplung"("code"); + +-- CreateIndex +CREATE INDEX "telegram_kopplung_gueltigBis_idx" ON "telegram_kopplung"("gueltigBis"); diff --git a/prisma/schema.prisma b/prisma/schema.prisma index dd7b924..772bf88 100644 --- a/prisma/schema.prisma +++ b/prisma/schema.prisma @@ -38,6 +38,7 @@ model Benutzer { benachrichtigung Benachrichtigungseinstellung? pushGeraete PushGeraet[] meldungen Meldungsnachweis[] + telegramChats TelegramChat[] @@index([aktiv]) @@map("benutzer") @@ -222,6 +223,10 @@ model Aufgabe { /// Kennung beim Ursprungssystem, z. B. die Ticketnummer. quelleRef String? + /// Ausdruecklich zum Spiegeln freigegeben. Nur was hier true ist, verlaesst + /// die Instanz mit Titel – alles andere bleibt, wo es ist. + spiegeln Boolean @default(false) + erstelltAm DateTime @default(now()) aktualisiertAm DateTime @updatedAt @@ -391,9 +396,10 @@ model Benachrichtigungseinstellung { benutzerId String @unique /// Kommagetrennte Anlaesse, siehe src/lib/benachrichtigung.ts. - anlaesse String @default("tagesueberblick,faelligkeit") - perPush Boolean @default(false) - perMail Boolean @default(false) + anlaesse String @default("tagesueberblick,faelligkeit") + perPush Boolean @default(false) + perMail Boolean @default(false) + perTelegram Boolean @default(false) /// Alles als Minuten seit Mitternacht, Europe/Berlin. ueberblickUm Int @default(420) @@ -448,3 +454,87 @@ model Meldungsnachweis { @@index([gesendetAm]) @@map("meldungsnachweis") } + +/// Zustand einer Integration: wie weit sie gelesen hat und ob es klappt. +/// +/// Eine Zeile je Quelle. Der Merker ist bewusst ein freier Text – jede +/// Integration legt darin ab, was sie zum Fortsetzen braucht: Zammad einen +/// Zeitstempel, Telegram den Zaehler der zuletzt geholten Nachricht. +model Integrationszustand { + id String @id @default(cuid()) + quelle Quelle @unique + + /// Woher es weitergeht. Bedeutung haengt an der Quelle. + merker String? + + letzterLauf DateTime? + letzterErfolg DateTime? + letzterFehler String? + /// Fehlschlaege in Folge; bei Erfolg wieder null. + fehlversuche Int @default(0) + + erstelltAm DateTime @default(now()) + aktualisiertAm DateTime @updatedAt + + @@map("integrationszustand") +} + +/// Dienstliche Belegung, die aus der anderen Instanz kommt. +/// +/// Bewusst ohne Titel: Daheim soll sehen, *dass* die Zeit weg ist, nicht +/// woran gearbeitet wird. Firmeninhalte verlassen die Firma nicht. +model Spiegelbelegung { + id String @id @default(cuid()) + + /// Kennung des Zeitblocks in der sendenden Instanz. + quelleRef String @unique + + beginn DateTime + ende DateTime + + empfangenAm DateTime @default(now()) + + @@index([beginn]) + @@map("spiegelbelegung") +} + +/// Ein Telegram-Chat, der mit dem Planer reden darf. +/// +/// Wer nicht hier steht, wird verworfen – ein Bot-Token laesst sich erraten +/// oder abgreifen, die Chatkennung ist der zweite Riegel. +model TelegramChat { + id String @id @default(cuid()) + /// Chatkennung bei Telegram; kann negativ sein (Gruppen). + chatId BigInt @unique + + bezeichnung String? + benutzerId String? + + /// Empfaengt dieser Chat auch Meldungen, nicht nur Aufgaben? + meldungen Boolean @default(true) + + erstelltAm DateTime @default(now()) + zuletztBenutzt DateTime? + + benutzer Benutzer? @relation(fields: [benutzerId], references: [id], onDelete: SetNull) + + @@index([benutzerId]) + @@map("telegram_chat") +} + +/// Einmalcode, mit dem sich ein Telegram-Chat anmeldet. +/// +/// Ohne ihn muesste die Chatkennung von Hand eingetragen werden – und um sie +/// zu erfahren, muesste der Planer auf Nachrichten Unbekannter antworten. +/// Genau das soll er nicht. +model TelegramKopplung { + id String @id @default(cuid()) + code String @unique + benutzerId String + gueltigBis DateTime + + erstelltAm DateTime @default(now()) + + @@index([gueltigBis]) + @@map("telegram_kopplung") +} diff --git a/src/server/umgebung.ts b/src/server/umgebung.ts index 832ae18..1c3f953 100644 --- a/src/server/umgebung.ts +++ b/src/server/umgebung.ts @@ -1,6 +1,6 @@ import 'server-only' import { z } from 'zod' -import { INSTANZEN, type Instanz } from '@/lib/instanz' +import { INSTANZEN, istErlaubt, type Instanz } from '@/lib/instanz' /** * Jede Einstellung von aussen wird geprueft, bevor sie benutzt wird. Fehlt @@ -57,6 +57,26 @@ const schema = z.object({ /// Implizites TLS (Port 465). Sonst wird STARTTLS versucht. SMTP_TLS: jaNein.default(false), + // --- Integrationen (M6) --- + // Zammad, nur in der Instanz "firma". Der Token gehoert einem Benutzer und + // sieht genau das, was dieser Benutzer sehen darf. + ZAMMAD_URL: z.string().trim().default(''), + ZAMMAD_TOKEN: z.string().trim().default(''), + /// Suchausdruck in Zammads Syntax. Was hier passt, wird zur Aufgabe. + ZAMMAD_ABFRAGE: z + .string() + .trim() + .default('owner_id:me AND (state.name:new OR state.name:open)'), + + // Telegram, nur in der Instanz "daheim". + TELEGRAM_TOKEN: z.string().trim().default(''), + + // Spiegel: firma sendet, daheim empfaengt. Dasselbe Geheimnis auf beiden + // Seiten; ohne gueltige Signatur nimmt der Empfaenger nichts an. + SPIEGEL_GEHEIMNIS: z.string().trim().default(''), + /// Nur auf der sendenden Seite: wohin geschickt wird. + SPIEGEL_ZIEL: z.string().trim().default(''), + DEMO_MODUS: jaNein.default(false), }) @@ -70,6 +90,12 @@ export type Umgebung = z.infer & { /** Web-Push ist erst mit vollstaendigem VAPID-Satz moeglich. */ pushAktiv: boolean mailAktiv: boolean + /** Zammad braucht Adresse und Token – und die Instanz muss es erlauben. */ + zammadAktiv: boolean + telegramAktiv: boolean + /** Senden geht nur mit Ziel, Empfangen schon mit dem Geheimnis allein. */ + spiegelSendenAktiv: boolean + spiegelEmpfangenAktiv: boolean } let zwischengespeichert: Umgebung | null = null @@ -95,6 +121,18 @@ function lesen(): Umgebung { werte.VAPID_OEFFENTLICH && werte.VAPID_PRIVAT && werte.VAPID_KONTAKT, ), mailAktiv: Boolean(werte.SMTP_HOST && werte.SMTP_ABSENDER), + // Die Instanz entscheidet mit: eine Integration, die hier nicht erlaubt + // ist, laesst sich auch mit vollstaendiger Konfiguration nicht anschalten. + zammadAktiv: + istErlaubt(werte.INSTANZ, 'integration:zammad') && + Boolean(werte.ZAMMAD_URL && werte.ZAMMAD_TOKEN), + telegramAktiv: + istErlaubt(werte.INSTANZ, 'integration:telegram') && Boolean(werte.TELEGRAM_TOKEN), + spiegelSendenAktiv: + istErlaubt(werte.INSTANZ, 'spiegel:senden') && + Boolean(werte.SPIEGEL_GEHEIMNIS && werte.SPIEGEL_ZIEL), + spiegelEmpfangenAktiv: + istErlaubt(werte.INSTANZ, 'spiegel:empfangen') && Boolean(werte.SPIEGEL_GEHEIMNIS), } } From e4d3547457e4ca835243a1e86b526168abed4a2a Mon Sep 17 00:00:00 2001 From: Florian Wilde Date: Fri, 11 Sep 2026 23:03:33 +0200 Subject: [PATCH 02/14] feat: Aufnahmeregeln fuer Integrationen als reine Logik MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Was aus einem Fund wird, entscheidet fuer alle Integrationen dieselbe Stelle: anlegen, aktualisieren, schliessen oder nichts tun. Gefuehrt werden nur Titel, Notiz, Verweis und Faelligkeit. Bereich, Projekt, Prioritaet und geschaetzter Aufwand gehoeren der Planung — wer ein Ticket einsortiert und schaetzt, will nicht, dass der naechste Lauf das wieder wegraeumt. Dazu die Regeln des Spiegels: Aufbau der Sendung und ihre Frist. Ohne Frist liesse sich ein abgefangenes Paket beliebig oft erneut einspielen. 21 Tests. Co-Authored-By: Claude Opus 5 --- src/lib/integration.test.ts | 188 ++++++++++++++++++++++++++++++++++++ src/lib/integration.ts | 177 +++++++++++++++++++++++++++++++++ 2 files changed, 365 insertions(+) create mode 100644 src/lib/integration.test.ts create mode 100644 src/lib/integration.ts diff --git a/src/lib/integration.test.ts b/src/lib/integration.test.ts new file mode 100644 index 0000000..0242415 --- /dev/null +++ b/src/lib/integration.test.ts @@ -0,0 +1,188 @@ +import { describe, expect, test } from 'vitest' +import { + alsTitel, + sendungFrisch, + spiegelSendung, + TITEL_MAX, + uebernahmeEntscheiden, + type Bestand, + type Fund, +} from '@/lib/integration' + +function fund(teile: Partial = {}): Fund { + return { ref: 'T-1', titel: 'Drucker klemmt', ...teile } +} + +function bestand(teile: Partial = {}): Bestand { + return { + titel: 'Drucker klemmt', + notiz: null, + quelleUrl: null, + faelligAm: null, + prioritaet: 3, + aufwandMinuten: null, + erledigt: false, + ...teile, + } +} + +describe('uebernahmeEntscheiden', () => { + test('legt an, was es hier noch nicht gibt', () => { + expect(uebernahmeEntscheiden(fund(), null)).toEqual({ tun: 'anlegen' }) + }) + + test('legt nichts an, was drüben schon erledigt ist', () => { + expect(uebernahmeEntscheiden(fund({ erledigt: true }), null)).toEqual({ + tun: 'nichts', + grund: 'schon-erledigt', + }) + }) + + test('erkennt den unveränderten Fall', () => { + expect(uebernahmeEntscheiden(fund(), bestand())).toEqual({ + tun: 'nichts', + grund: 'unveraendert', + }) + }) + + test('übernimmt einen geänderten Titel', () => { + const entscheidung = uebernahmeEntscheiden( + fund({ titel: 'Drucker klemmt weiterhin' }), + bestand(), + ) + expect(entscheidung).toEqual({ + tun: 'aktualisieren', + felder: { titel: 'Drucker klemmt weiterhin' }, + }) + }) + + test('übernimmt eine neue Fälligkeit', () => { + const faelligAm = new Date('2026-04-01T00:00:00.000Z') + expect(uebernahmeEntscheiden(fund({ faelligAm }), bestand())).toEqual({ + tun: 'aktualisieren', + felder: { faelligAm }, + }) + }) + + test('vergleicht Datumswerte nach Zeitpunkt, nicht nach Objekt', () => { + const faelligAm = new Date('2026-04-01T00:00:00.000Z') + const entscheidung = uebernahmeEntscheiden( + fund({ faelligAm: new Date(faelligAm.getTime()) }), + bestand({ faelligAm }), + ) + expect(entscheidung).toEqual({ tun: 'nichts', grund: 'unveraendert' }) + }) + + test('rührt Priorität und Aufwand nicht an', () => { + // Beides wird hier geschätzt, nicht drüben. Ein Abgleich, der die + // Schätzung wegräumt, macht die Wochenplanung kaputt. + const entscheidung = uebernahmeEntscheiden( + fund({ prioritaet: 1, aufwandMinuten: 30 }), + bestand({ prioritaet: 4, aufwandMinuten: 90 }), + ) + expect(entscheidung).toEqual({ tun: 'nichts', grund: 'unveraendert' }) + }) + + test('schließt, was drüben erledigt wurde', () => { + expect(uebernahmeEntscheiden(fund({ erledigt: true }), bestand())).toEqual({ + tun: 'schliessen', + }) + }) + + test('schließt nicht zweimal', () => { + expect( + uebernahmeEntscheiden(fund({ erledigt: true }), bestand({ erledigt: true })), + ).toEqual({ tun: 'nichts', grund: 'schon-erledigt' }) + }) + + test('holt eine hier erledigte Aufgabe zurück, wenn sie drüben wieder offen ist', () => { + const entscheidung = uebernahmeEntscheiden(fund(), bestand({ erledigt: true })) + // Das Ursprungssystem führt den Zustand; wer dort neu öffnet, meint es so. + expect(entscheidung).toEqual({ tun: 'nichts', grund: 'unveraendert' }) + }) +}) + +describe('alsTitel', () => { + test('lässt kurze Texte in Ruhe', () => { + expect(alsTitel('Angebot schreiben')).toEqual({ + titel: 'Angebot schreiben', + rest: null, + }) + }) + + test('macht aus Zeilenumbrüchen Leerzeichen', () => { + expect(alsTitel('Angebot\n\nschreiben ')).toEqual({ + titel: 'Angebot schreiben', + rest: null, + }) + }) + + test('kürzt lange Texte und hebt den Rest auf', () => { + const lang = `${'wort '.repeat(60)}ende` + const { titel, rest } = alsTitel(lang) + expect(titel.length).toBeLessThanOrEqual(TITEL_MAX + 1) + expect(titel.endsWith('…')).toBe(true) + expect(rest).not.toBeNull() + expect(rest?.endsWith('ende')).toBe(true) + }) + + test('trennt nicht mitten im Wort, wenn eine Fuge in der Nähe ist', () => { + const lang = `${'a'.repeat(60)} ${'b'.repeat(80)}` + const { titel } = alsTitel(lang) + expect(titel).toBe(`${'a'.repeat(60)}…`) + }) + + test('trennt hart, wenn es keine Fuge gibt', () => { + const { titel } = alsTitel('x'.repeat(200)) + expect(titel).toBe(`${'x'.repeat(TITEL_MAX)}…`) + }) +}) + +describe('sendungFrisch', () => { + const jetzt = new Date('2026-03-17T08:20:00.000Z') + + test('nimmt an, was gerade erst losgeschickt wurde', () => { + expect(sendungFrisch(new Date('2026-03-17T08:18:00.000Z'), jetzt)).toBe(true) + }) + + test('lehnt ein altes Paket ab', () => { + expect(sendungFrisch(new Date('2026-03-17T08:10:00.000Z'), jetzt)).toBe(false) + }) + + test('lehnt auch ein Paket aus der Zukunft ab', () => { + // Eine verstellte Uhr auf der Gegenseite ist genauso verdächtig. + expect(sendungFrisch(new Date('2026-03-17T08:40:00.000Z'), jetzt)).toBe(false) + }) +}) + +describe('spiegelSendung', () => { + test('nimmt ein vollständiges Paket an', () => { + const gelesen = spiegelSendung.safeParse({ + gesendetAm: '2026-03-17T08:20:00.000Z', + belegungen: [ + { + ref: 'zb-1', + beginn: '2026-03-17T09:00:00.000Z', + ende: '2026-03-17T10:00:00.000Z', + }, + ], + aufgaben: [{ ref: 'a-1', titel: 'Angebot schreiben' }], + }) + expect(gelesen.success).toBe(true) + expect(gelesen.success && gelesen.data.aufgaben[0]?.erledigt).toBe(false) + }) + + test('weist ein Paket ohne Zeitstempel ab', () => { + const gelesen = spiegelSendung.safeParse({ belegungen: [], aufgaben: [] }) + expect(gelesen.success).toBe(false) + }) + + test('weist eine Belegung mit kaputtem Datum ab', () => { + const gelesen = spiegelSendung.safeParse({ + gesendetAm: '2026-03-17T08:20:00.000Z', + belegungen: [{ ref: 'zb-1', beginn: 'morgen', ende: 'später' }], + aufgaben: [], + }) + expect(gelesen.success).toBe(false) + }) +}) diff --git a/src/lib/integration.ts b/src/lib/integration.ts new file mode 100644 index 0000000..858b183 --- /dev/null +++ b/src/lib/integration.ts @@ -0,0 +1,177 @@ +import { z } from 'zod' + +/** + * Gemeinsame Regeln für alle Integrationen. + * + * Der Kern jeder Integration ist derselbe: ein fremdes System liefert Zeug, + * daraus wird eine Aufgabe, und beim nächsten Lauf darf dieselbe Sache keine + * zweite Aufgabe ergeben. Was sich unterscheidet, ist allein das Abholen. + * + * Reine Logik ohne Datenbank, ohne Netz und ohne Systemzeit. + */ + +/** Was eine Integration liefert, bevor daraus eine Aufgabe wird. */ +export type Fund = { + /** Kennung beim Ursprungssystem. Bleibt über die Lebensdauer gleich. */ + ref: string + titel: string + notiz?: string | null + url?: string | null + faelligAm?: Date | null + /** 1 = dringend, 5 = irgendwann. */ + prioritaet?: number | null + aufwandMinuten?: number | null + /** Im Ursprungssystem abgeschlossen: die Aufgabe darf zu. */ + erledigt?: boolean +} + +/** + * Was beim Übernehmen eines Fundes passieren soll. + * + * Der heikle Teil ist nicht das Anlegen, sondern das zweite Mal: Eine Aufgabe, + * an der hier gearbeitet wurde, darf ein Abgleich nicht zurücksetzen. + */ +export type Uebernahme = + | { tun: 'anlegen' } + | { tun: 'aktualisieren'; felder: Partial } + | { tun: 'schliessen' } + | { tun: 'nichts'; grund: 'unveraendert' | 'von-hand-geaendert' | 'schon-erledigt' } + +/** Der Stand, wie er in der Datenbank liegt. */ +export type Bestand = { + titel: string + notiz: string | null + quelleUrl: string | null + faelligAm: Date | null + prioritaet: number + aufwandMinuten: number | null + erledigt: boolean +} + +/** + * Felder, die das Ursprungssystem führt — und nur diese. + * + * Bereich, Projekt und Zeitblöcke gehören der Planung und werden nie aus + * einer Integration überschrieben. Wer ein Ticket einem Bereich zuordnet, + * will nicht, dass der nächste Lauf das wieder wegräumt. + */ +const GEFUEHRT = ['titel', 'notiz', 'quelleUrl', 'faelligAm'] as const + +function gleich(a: unknown, b: unknown): boolean { + if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime() + return a === b +} + +export function uebernahmeEntscheiden(fund: Fund, bestand: Bestand | null): Uebernahme { + if (!bestand) { + // Ein Fund, der drüben schon erledigt ist, braucht hier nicht erst zu + // entstehen, nur um sofort wieder zuzugehen. + return fund.erledigt ? { tun: 'nichts', grund: 'schon-erledigt' } : { tun: 'anlegen' } + } + + if (fund.erledigt) { + return bestand.erledigt + ? { tun: 'nichts', grund: 'schon-erledigt' } + : { tun: 'schliessen' } + } + + const neu: Partial = {} + const gewuenscht: Bestand = { + titel: fund.titel, + notiz: fund.notiz ?? null, + quelleUrl: fund.url ?? null, + faelligAm: fund.faelligAm ?? null, + prioritaet: bestand.prioritaet, + aufwandMinuten: bestand.aufwandMinuten, + erledigt: false, + } + + for (const feld of GEFUEHRT) { + if (!gleich(bestand[feld], gewuenscht[feld])) { + // @ts-expect-error – der Index ist über GEFUEHRT eingegrenzt. + neu[feld] = gewuenscht[feld] + } + } + + return Object.keys(neu).length === 0 + ? { tun: 'nichts', grund: 'unveraendert' } + : { tun: 'aktualisieren', felder: neu } +} + +/** + * Ab wann ein Fehlschlag gemeldet wird — dieselbe Schwelle wie beim + * Kalenderabgleich. Ein Aussetzer ist keine Nachricht wert. + */ +export const INTEGRATION_FEHLER_AB_VERSUCH = 3 + +/** + * Kürzt einen Text auf eine Länge, die als Aufgabentitel taugt. + * + * Fremde Systeme kennen keine Grenze; ein Titel über mehrere Zeilen macht + * jede Liste unlesbar. Der Rest wandert in die Notiz, geht also nicht + * verloren. + */ +export const TITEL_MAX = 120 + +export function alsTitel(text: string): { titel: string; rest: string | null } { + const sauber = text.replace(/\s+/g, ' ').trim() + if (sauber.length <= TITEL_MAX) return { titel: sauber, rest: null } + + // Lieber an einem Wort trennen als mitten hinein – aber nur, solange + // dabei nicht mehr als die Haelfte des Titels wegfaellt. + const schnitt = sauber.lastIndexOf(' ', TITEL_MAX) + const bei = schnitt >= TITEL_MAX / 2 ? schnitt : TITEL_MAX + return { titel: `${sauber.slice(0, bei).trimEnd()}…`, rest: sauber.slice(bei).trim() } +} + +// --- Spiegel --------------------------------------------------------------- + +/** + * Was von einer Instanz zur anderen geht. + * + * Belegungen tragen keinen Titel: Daheim soll sehen, *dass* die Zeit weg ist, + * nicht woran gearbeitet wird. Aufgaben gehen nur mit, wenn sie ausdrücklich + * dafür markiert sind. + */ +export const spiegelBelegung = z.object({ + ref: z.string().min(1).max(64), + beginn: z.iso.datetime(), + ende: z.iso.datetime(), +}) + +export const spiegelAufgabe = z.object({ + ref: z.string().min(1).max(64), + titel: z + .string() + .min(1) + .max(TITEL_MAX + 1), + faelligAm: z.iso.datetime().nullable().default(null), + erledigt: z.boolean().default(false), +}) + +export const spiegelSendung = z.object({ + /** Wann der Sender das Paket geschnürt hat, für die Frische. */ + gesendetAm: z.iso.datetime(), + belegungen: z.array(spiegelBelegung).max(500), + aufgaben: z.array(spiegelAufgabe).max(500), +}) + +export type SpiegelSendung = z.infer + +/** + * Wie alt eine Sendung höchstens sein darf. + * + * Ohne Frist ließe sich ein abgefangenes Paket beliebig oft erneut + * einspielen. Fünf Minuten sind genug für eine träge Leitung und zu wenig + * für ein Archiv. + */ +export const SENDUNG_FRIST_MINUTEN = 5 + +export function sendungFrisch( + gesendetAm: Date, + jetzt: Date, + fristMinuten = SENDUNG_FRIST_MINUTEN, +): boolean { + const abstandMinuten = Math.abs(jetzt.getTime() - gesendetAm.getTime()) / 60_000 + return abstandMinuten <= fristMinuten +} From 6dad3331e28b71ff4c6b9ae48294f4f3646aeec7 Mon Sep 17 00:00:00 2001 From: Florian Wilde Date: Fri, 11 Sep 2026 23:04:03 +0200 Subject: [PATCH 03/14] feat: Zammad, Telegram und den Spiegel anbinden MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Zammad liest ueber die Suche und schreibt nichts zurueck. Telegram holt per getUpdates statt per Webhook — der Planer soll auch hinter einem Anschluss ohne feste Adresse laufen. Der Spiegel schickt Belegungen ohne Titel und nur die ausdruecklich markierten Aufgaben. Wer dem Telegram-Bot schreibt, ohne im Adressbuch zu stehen, bekommt keine Antwort. Die einzige Ausnahme ist ein gueltiger Kopplungscode: Er ist der Beweis, dass jemand mit Zugang zur Anwendung diesen Chat will. Ohne ihn muesste man die Chatkennung von Hand eintragen — und um sie zu erfahren, muesste der Bot Unbekannten antworten. Jede Sendung des Spiegels traegt eine Signatur ueber den Rumpf und gilt fuenf Minuten. Der Empfaenger antwortet auf jeden Fehlschlag gleich: falsches Geheimnis, verstellte Uhr oder Unsinn im Inhalt sind von aussen nicht zu unterscheiden. Co-Authored-By: Claude Opus 5 --- src/app/api/spiegel/route.ts | 45 ++++ src/server/integration/aufnahme.ts | 197 +++++++++++++++ src/server/integration/spiegel.ts | 213 ++++++++++++++++ src/server/integration/telegram.ts | 392 +++++++++++++++++++++++++++++ src/server/integration/zammad.ts | 143 +++++++++++ 5 files changed, 990 insertions(+) create mode 100644 src/app/api/spiegel/route.ts create mode 100644 src/server/integration/aufnahme.ts create mode 100644 src/server/integration/spiegel.ts create mode 100644 src/server/integration/telegram.ts create mode 100644 src/server/integration/zammad.ts diff --git a/src/app/api/spiegel/route.ts b/src/app/api/spiegel/route.ts new file mode 100644 index 0000000..cbfeea9 --- /dev/null +++ b/src/app/api/spiegel/route.ts @@ -0,0 +1,45 @@ +import { NextResponse } from 'next/server' +import { auditSchreiben } from '@/server/audit' +import { sendungAufnehmen, sendungPruefen } from '@/server/integration/spiegel' +import { jetzt } from '@/server/zeitgeber' + +export const dynamic = 'force-dynamic' + +/** + * Der Eingang des Spiegels — nur in der Instanz `daheim`. + * + * Hier meldet sich kein Mensch an: Die Gegenstelle weist sich über eine + * Signatur aus, die sie mit dem gemeinsamen Geheimnis über den Rumpf bildet. + * + * Jede Zurückweisung sieht gleich aus. Ob das Geheimnis falsch war, die Uhr + * verstellt oder der Inhalt Unsinn — von außen ist das nicht zu unterscheiden, + * und genau so soll es sein. + */ + +export async function POST(anfrage: Request) { + // Der Rumpf muss als Text gelesen werden: Die Signatur gilt für genau diese + // Zeichen, nicht für das, was ein JSON-Parser daraus und wieder zurück macht. + const koerper = await anfrage.text() + const signatur = anfrage.headers.get('X-Planer-Signatur') + + const geprueft = sendungPruefen(koerper, signatur, jetzt()) + if (!geprueft.ok) { + return NextResponse.json({ fehler: 'Abgelehnt.' }, { status: 401 }) + } + + const bericht = await sendungAufnehmen(geprueft.sendung, { + id: null, + email: 'spiegel@intern', + }) + + await auditSchreiben({ + akteur: { id: null, email: 'spiegel@intern' }, + aktion: 'spiegel.empfangen', + objektTyp: 'Spiegelbelegung', + objektId: null, + // Nur Zahlen: Was gespiegelt wurde, steht in den Datensätzen selbst. + details: bericht, + }) + + return NextResponse.json({ ok: true, ...bericht }) +} diff --git a/src/server/integration/aufnahme.ts b/src/server/integration/aufnahme.ts new file mode 100644 index 0000000..f94dc27 --- /dev/null +++ b/src/server/integration/aufnahme.ts @@ -0,0 +1,197 @@ +import 'server-only' +import type { Quelle } from '@/generated/prisma/enums' +import { uebernahmeEntscheiden, type Bestand, type Fund } from '@/lib/integration' +import { auditSchreiben } from '@/server/audit' +import { db } from '@/server/db' +import { jetzt } from '@/server/zeitgeber' + +/** + * Die gemeinsame Aufnahmestelle für alle Integrationen. + * + * Jede Integration liefert eine Liste von Funden; was daraus wird, entscheidet + * für alle dieselbe Stelle. Damit verhält sich Zammad wie Telegram wie der + * Spiegel — und eine neue Integration muss nur noch abholen können. + * + * Hier hängt später auch der Wartungsplaner ein: Er braucht eine Funktion, die + * seine Daten in `Fund` übersetzt, sonst nichts. + */ + +export type Aufnahmebericht = { + angelegt: number + aktualisiert: number + geschlossen: number + unveraendert: number +} + +const LEER: Aufnahmebericht = { + angelegt: 0, + aktualisiert: 0, + geschlossen: 0, + unveraendert: 0, +} + +/** Wer die Aufnahme angestoßen hat – für das Protokoll. */ +export type Anstoss = { id: string | null; email: string } + +/** + * Nimmt eine Runde Funde auf. + * + * Anschließend gilt: Zu jedem Fund gibt es genau eine Aufgabe mit + * `[quelle, ref]`, und keine Aufgabe wurde in Feldern angefasst, die hier + * gepflegt werden statt drüben. + */ +export async function fundeAufnehmen( + quelle: Quelle, + funde: readonly Fund[], + anstoss: Anstoss, +): Promise { + const bericht = { ...LEER } + const zeitpunkt = jetzt() + + for (const fund of funde) { + const vorhanden = await db.aufgabe.findUnique({ + where: { quelle_quelleRef: { quelle, quelleRef: fund.ref } }, + select: { + id: true, + titel: true, + notiz: true, + quelleUrl: true, + faelligAm: true, + prioritaet: true, + aufwandMinuten: true, + status: true, + }, + }) + + const bestand: Bestand | null = vorhanden + ? { + titel: vorhanden.titel, + notiz: vorhanden.notiz, + quelleUrl: vorhanden.quelleUrl, + faelligAm: vorhanden.faelligAm, + prioritaet: vorhanden.prioritaet, + aufwandMinuten: vorhanden.aufwandMinuten, + erledigt: vorhanden.status === 'ERLEDIGT' || vorhanden.status === 'VERWORFEN', + } + : null + + const entscheidung = uebernahmeEntscheiden(fund, bestand) + + if (entscheidung.tun === 'nichts') { + bericht.unveraendert++ + continue + } + + if (entscheidung.tun === 'anlegen') { + const angelegt = await db.aufgabe.create({ + data: { + titel: fund.titel, + notiz: fund.notiz ?? null, + quelle, + quelleRef: fund.ref, + quelleUrl: fund.url ?? null, + faelligAm: fund.faelligAm ?? null, + ...(fund.prioritaet ? { prioritaet: fund.prioritaet } : {}), + ...(fund.aufwandMinuten ? { aufwandMinuten: fund.aufwandMinuten } : {}), + }, + select: { id: true }, + }) + bericht.angelegt++ + await auditSchreiben({ + akteur: anstoss, + aktion: 'integration.angelegt', + objektTyp: 'Aufgabe', + objektId: angelegt.id, + // Der Titel steht schon in der Aufgabe; hier genügt die Herkunft. + details: { quelle, ref: fund.ref }, + }) + continue + } + + if (entscheidung.tun === 'schliessen') { + await db.aufgabe.update({ + where: { id: vorhanden?.id ?? '' }, + data: { status: 'ERLEDIGT', erledigtAm: zeitpunkt }, + }) + bericht.geschlossen++ + await auditSchreiben({ + akteur: anstoss, + aktion: 'integration.geschlossen', + objektTyp: 'Aufgabe', + objektId: vorhanden?.id ?? null, + details: { quelle, ref: fund.ref }, + }) + continue + } + + await db.aufgabe.update({ + where: { id: vorhanden?.id ?? '' }, + data: entscheidung.felder, + }) + bericht.aktualisiert++ + await auditSchreiben({ + akteur: anstoss, + aktion: 'integration.aktualisiert', + objektTyp: 'Aufgabe', + objektId: vorhanden?.id ?? null, + details: { quelle, ref: fund.ref, felder: Object.keys(entscheidung.felder) }, + }) + } + + return bericht +} + +// --- Zustand je Integration ------------------------------------------------ + +/** Liest den Merker, an dem eine Integration weitermacht. */ +export async function merkerLesen(quelle: Quelle): Promise { + const zeile = await db.integrationszustand.findUnique({ + where: { quelle }, + select: { merker: true }, + }) + return zeile?.merker ?? null +} + +/** Hält fest, dass ein Lauf geklappt hat. */ +export async function laufGeglueckt(quelle: Quelle, merker?: string): Promise { + const zeitpunkt = jetzt() + const werte = { + letzterLauf: zeitpunkt, + letzterErfolg: zeitpunkt, + letzterFehler: null, + fehlversuche: 0, + ...(merker === undefined ? {} : { merker }), + } + await db.integrationszustand.upsert({ + where: { quelle }, + update: werte, + create: { quelle, ...werte }, + }) +} + +/** + * Hält einen Fehlschlag fest und zählt hoch. + * + * Nur die Meldung, nie die Antwort des fremden Systems: Darin stehen gern + * Tokens, Kopfzeilen und ganze Datensätze. + */ +export async function laufGescheitert(quelle: Quelle, fehler: unknown): Promise { + const meldung = fehler instanceof Error ? fehler.message : 'unbekannter Fehler' + const zeitpunkt = jetzt() + const zeile = await db.integrationszustand.upsert({ + where: { quelle }, + update: { + letzterLauf: zeitpunkt, + letzterFehler: meldung.slice(0, 500), + fehlversuche: { increment: 1 }, + }, + create: { + quelle, + letzterLauf: zeitpunkt, + letzterFehler: meldung.slice(0, 500), + fehlversuche: 1, + }, + select: { fehlversuche: true }, + }) + return zeile.fehlversuche +} diff --git a/src/server/integration/spiegel.ts b/src/server/integration/spiegel.ts new file mode 100644 index 0000000..fb5819b --- /dev/null +++ b/src/server/integration/spiegel.ts @@ -0,0 +1,213 @@ +import 'server-only' +import { createHmac, timingSafeEqual } from 'node:crypto' +import { + sendungFrisch, + spiegelSendung, + type Fund, + type SpiegelSendung, +} from '@/lib/integration' +import { db } from '@/server/db' +import { umgebung } from '@/server/umgebung' +import { jetzt } from '@/server/zeitgeber' +import { + fundeAufnehmen, + laufGescheitert, + laufGeglueckt, + type Anstoss, +} from '@/server/integration/aufnahme' + +/** + * Der Spiegel: `firma` sendet, `daheim` empfängt. + * + * Zwei Dinge gehen hinüber. **Belegungen** sagen nur, wann Zeit weg ist — + * ohne Titel, ohne Aufgabe, ohne Kunde. So kollidiert die private Planung + * nicht mit der dienstlichen, ohne dass Firmeninhalte das Haus verlassen. + * **Aufgaben** gehen nur mit, wenn sie ausdrücklich dafür markiert sind; das + * ist eine bewusste Einzelentscheidung, kein Schalter für alles. + * + * Die Richtung ist fest verdrahtet: Was in der Firma passiert, darf daheim + * sichtbar sein, umgekehrt nicht. Das ist keine Technik, sondern eine + * Hausregel — und deshalb steckt sie in den Instanzfähigkeiten, nicht in + * einer Einstellung, die sich verstellen ließe. + */ + +/** Wie weit voraus gespiegelt wird. Weiter zurück interessiert niemanden. */ +const FENSTER_TAGE_VORAUS = 30 + +export function signieren(koerper: string, geheimnis: string): string { + return createHmac('sha256', geheimnis).update(koerper).digest('hex') +} + +/** + * Prüft die Signatur in gleichbleibender Zeit. + * + * Ein einfacher Vergleich verrät über die Laufzeit, wie viele Zeichen schon + * stimmen — damit ließe sich die Signatur Stück für Stück erraten. + */ +export function signaturStimmt( + koerper: string, + signatur: string, + geheimnis: string, +): boolean { + const erwartet = Buffer.from(signieren(koerper, geheimnis), 'utf8') + const bekommen = Buffer.from(signatur, 'utf8') + if (erwartet.length !== bekommen.length) return false + return timingSafeEqual(erwartet, bekommen) +} + +// --- Senden (firma) -------------------------------------------------------- + +/** Stellt zusammen, was hinübergeht. */ +export async function sendungBauen(zeitpunkt: Date): Promise { + const bis = new Date(zeitpunkt.getTime() + FENSTER_TAGE_VORAUS * 86_400_000) + + const [zeitbloecke, aufgaben] = await Promise.all([ + db.zeitblock.findMany({ + where: { beginn: { gte: zeitpunkt, lte: bis } }, + orderBy: { beginn: 'asc' }, + take: 500, + // Kein Titel, keine Aufgabe: Nur wann die Zeit weg ist. + select: { id: true, beginn: true, ende: true }, + }), + db.aufgabe.findMany({ + where: { spiegeln: true }, + orderBy: { erstelltAm: 'asc' }, + take: 500, + select: { id: true, titel: true, faelligAm: true, status: true }, + }), + ]) + + return { + gesendetAm: zeitpunkt.toISOString(), + belegungen: zeitbloecke.map((z) => ({ + ref: z.id, + beginn: z.beginn.toISOString(), + ende: z.ende.toISOString(), + })), + aufgaben: aufgaben.map((a) => ({ + ref: a.id, + titel: a.titel, + faelligAm: a.faelligAm ? a.faelligAm.toISOString() : null, + erledigt: a.status === 'ERLEDIGT' || a.status === 'VERWORFEN', + })), + } +} + +/** Schickt eine Runde an die andere Instanz. */ +export async function spiegelSenden(): Promise<{ belegungen: number; aufgaben: number }> { + const einst = umgebung() + try { + const sendung = await sendungBauen(jetzt()) + const koerper = JSON.stringify(sendung) + + const gelesen = await fetch(`${einst.SPIEGEL_ZIEL.replace(/\/+$/, '')}/api/spiegel`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + 'X-Planer-Signatur': signieren(koerper, einst.SPIEGEL_GEHEIMNIS), + }, + body: koerper, + signal: AbortSignal.timeout(20_000), + }) + + if (!gelesen.ok) { + throw new Error(`Der Spiegel antwortete mit HTTP ${gelesen.status}.`) + } + + await laufGeglueckt('SPIEGEL') + return { belegungen: sendung.belegungen.length, aufgaben: sendung.aufgaben.length } + } catch (fehler) { + await laufGescheitert('SPIEGEL', fehler) + throw fehler + } +} + +// --- Empfangen (daheim) ---------------------------------------------------- + +export type Empfangsbericht = { + belegungen: number + entfernt: number + aufgaben: number +} + +/** + * Nimmt eine geprüfte Sendung auf. + * + * Belegungen werden abgeglichen, nicht angehäuft: Was der Sender nicht mehr + * schickt, ist drüben ausgeplant worden und verschwindet auch hier. Sonst + * stünde daheim für immer eine Sperre, die es längst nicht mehr gibt. + */ +export async function sendungAufnehmen( + sendung: SpiegelSendung, + anstoss: Anstoss, +): Promise { + const gesehen = new Set(sendung.belegungen.map((b) => b.ref)) + + for (const belegung of sendung.belegungen) { + const werte = { + beginn: new Date(belegung.beginn), + ende: new Date(belegung.ende), + empfangenAm: jetzt(), + } + await db.spiegelbelegung.upsert({ + where: { quelleRef: belegung.ref }, + update: werte, + create: { quelleRef: belegung.ref, ...werte }, + }) + } + + const veraltet = await db.spiegelbelegung.findMany({ + where: { quelleRef: { notIn: [...gesehen] } }, + select: { id: true }, + }) + if (veraltet.length > 0) { + await db.spiegelbelegung.deleteMany({ + where: { id: { in: veraltet.map((v) => v.id) } }, + }) + } + + const funde: Fund[] = sendung.aufgaben.map((a) => ({ + ref: a.ref, + titel: a.titel, + faelligAm: a.faelligAm ? new Date(a.faelligAm) : null, + erledigt: a.erledigt, + })) + const bericht = await fundeAufnehmen('SPIEGEL', funde, anstoss) + + await laufGeglueckt('SPIEGEL') + + return { + belegungen: sendung.belegungen.length, + entfernt: veraltet.length, + aufgaben: bericht.angelegt + bericht.aktualisiert + bericht.geschlossen, + } +} + +/** + * Prüft Signatur und Frische und gibt die Sendung frei. + * + * Gibt bei jedem Fehlschlag dieselbe knappe Auskunft: Wer von außen probiert, + * soll nicht erfahren, ob das Geheimnis stimmte und nur die Uhr falsch ging. + */ +export function sendungPruefen( + koerper: string, + signatur: string | null, + zeitpunkt: Date, +): { ok: true; sendung: SpiegelSendung } | { ok: false } { + const einst = umgebung() + if (!einst.spiegelEmpfangenAktiv || !signatur) return { ok: false } + if (!signaturStimmt(koerper, signatur, einst.SPIEGEL_GEHEIMNIS)) return { ok: false } + + let inhalt: unknown + try { + inhalt = JSON.parse(koerper) + } catch { + return { ok: false } + } + + const gelesen = spiegelSendung.safeParse(inhalt) + if (!gelesen.success) return { ok: false } + if (!sendungFrisch(new Date(gelesen.data.gesendetAm), zeitpunkt)) return { ok: false } + + return { ok: true, sendung: gelesen.data } +} diff --git a/src/server/integration/telegram.ts b/src/server/integration/telegram.ts new file mode 100644 index 0000000..68ea363 --- /dev/null +++ b/src/server/integration/telegram.ts @@ -0,0 +1,392 @@ +import 'server-only' +import { randomBytes } from 'node:crypto' +import { z } from 'zod' +import { alsTitel, type Fund } from '@/lib/integration' +import type { Meldung } from '@/lib/benachrichtigung' +import { auditSchreiben } from '@/server/audit' +import { db } from '@/server/db' +import { umgebung } from '@/server/umgebung' +import { jetzt } from '@/server/zeitgeber' +import { + fundeAufnehmen, + laufGescheitert, + laufGeglueckt, + merkerLesen, + type Anstoss, +} from '@/server/integration/aufnahme' + +/** + * Telegram – nur in der Instanz „daheim". + * + * Drei Dinge in einem Kanal: erfassen (Nachricht wird Aufgabe), melden + * (dritter Weg neben Push und Mail) und abhaken (Knopf unter der Meldung). + * + * Geholt wird per `getUpdates`, nicht per Webhook. Ein Webhook verlangt eine + * von außen erreichbare Adresse mit gültigem Zertifikat; der Planer soll auch + * hinter einem Anschluss ohne feste Adresse laufen. + * + * **Wer nicht im Adressbuch steht, wird verworfen.** Ein Bot-Token lässt sich + * abgreifen, und wer die Kennung des Bots kennt, kann ihm schreiben. Die + * erlaubten Chats stehen in der Datenbank; alles andere wird stillschweigend + * weggeworfen — eine Antwort wäre schon die Auskunft, dass es den Bot gibt. + */ + +const HOECHSTENS = 50 + +const nachricht = z.object({ + message_id: z.number().int(), + date: z.number().int(), + chat: z.object({ id: z.number().int() }), + text: z.string().optional(), +}) + +const rueckfrage = z.object({ + id: z.string(), + data: z.string().optional(), + message: z + .object({ message_id: z.number().int(), chat: z.object({ id: z.number().int() }) }) + .optional(), +}) + +const aktualisierung = z.object({ + update_id: z.number().int(), + message: nachricht.optional(), + callback_query: rueckfrage.optional(), +}) + +const antwort = z.object({ + ok: z.boolean(), + result: z.array(z.unknown()).optional(), + description: z.string().optional(), +}) + +async function rufen( + methode: string, + koerper: Record, +): Promise { + const einst = umgebung() + const gelesen = await fetch( + `https://api.telegram.org/bot${einst.TELEGRAM_TOKEN}/${methode}`, + { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify(koerper), + signal: AbortSignal.timeout(70_000), + }, + ) + + if (!gelesen.ok) { + // Der Körper enthält im Fehlerfall den Token nicht, wohl aber die + // Nachricht – deshalb nur der Status. + throw new Error(`Telegram antwortete mit HTTP ${gelesen.status}.`) + } + + const inhalt: unknown = await gelesen.json() + const geprueft = antwort.safeParse(inhalt) + if (!geprueft.success || !geprueft.data.ok) { + throw new Error('Telegram lehnte die Anfrage ab.') + } + return geprueft.data.result +} + +// --- Senden ---------------------------------------------------------------- + +export type Knopf = { text: string; daten: string } + +/** Schickt eine Nachricht in einen Chat. Gibt zurück, ob es geklappt hat. */ +export async function telegramSenden( + chatId: bigint, + text: string, + knoepfe: readonly Knopf[] = [], +): Promise { + try { + await rufen('sendMessage', { + chat_id: Number(chatId), + text, + ...(knoepfe.length > 0 + ? { + reply_markup: { + inline_keyboard: [ + knoepfe.map((k) => ({ text: k.text, callback_data: k.daten })), + ], + }, + } + : {}), + }) + return true + } catch (fehler) { + console.error( + 'Telegram-Versand fehlgeschlagen:', + fehler instanceof Error ? fehler.message : 'unbekannter Fehler', + ) + return false + } +} + +/** + * Schickt eine Meldung an alle Chats eines Benutzers, die Meldungen wollen. + * + * Hängt eine Aufgabe daran, kommt ein Knopf mit: abhaken, ohne die Anwendung + * zu öffnen. Genau dafür lohnt sich der Umweg über Telegram. + */ +export async function telegramMeldung( + benutzerId: string, + meldung: Meldung, +): Promise { + const chats = await db.telegramChat.findMany({ + where: { benutzerId, meldungen: true }, + select: { id: true, chatId: true }, + }) + + const einst = umgebung() + const text = `${meldung.titel}\n\n${meldung.text}\n\n${einst.APP_URL}${meldung.pfad}` + const knoepfe: Knopf[] = meldung.objektId + ? [{ text: '✓ Erledigt', daten: `erledigt:${meldung.objektId}` }] + : [] + + let zugestellt = 0 + for (const chat of chats) { + if (await telegramSenden(chat.chatId, text, knoepfe)) { + zugestellt++ + await db.telegramChat.update({ + where: { id: chat.id }, + data: { zuletztBenutzt: jetzt() }, + }) + } + } + return zugestellt +} + +// --- Kopplung -------------------------------------------------------------- + +/** + * Wie lange ein Kopplungscode gilt. + * + * Kurz genug, dass ein abgeschriebener Code nichts mehr nützt; lang genug, + * um in Ruhe das Handy zu suchen. + */ +export const KOPPLUNG_MINUTEN = 10 + +/** Ziffern und Großbuchstaben ohne die, die sich verwechseln lassen. */ +const ZEICHEN = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789' + +/** + * Der Code, allein oder hinter `/start`. + * + * Telegram schickt beim ersten Öffnen eines Bots `/start` mit; wer den Code + * abtippt, schickt ihn nackt. Beides muss gehen. + */ +const KOPPLUNGSBEFEHL = /^(?:\/start\s+)?([A-Za-z0-9]{8})$/ + +export function kopplungscodeBauen(): string { + const bytes = randomBytes(8) + return [...bytes] + .map((b) => ZEICHEN[b % ZEICHEN.length]) + .join('') + .slice(0, 8) +} + +/** + * Löst einen Code ein und trägt den Chat ein. + * + * Der Code gilt genau einmal: Er verschwindet mit dem ersten Einlösen, auch + * wenn dabei etwas schiefgeht. + */ +async function kopplungEinloesen( + code: string, + chatId: number, +): Promise<'gekoppelt' | 'schon-da' | 'unbekannt'> { + const kopplung = await db.telegramKopplung.findUnique({ + where: { code }, + select: { id: true, benutzerId: true, gueltigBis: true }, + }) + if (!kopplung) return 'unbekannt' + + await db.telegramKopplung.delete({ where: { id: kopplung.id } }) + if (kopplung.gueltigBis.getTime() < jetzt().getTime()) return 'unbekannt' + + const vorhanden = await db.telegramChat.findUnique({ + where: { chatId: BigInt(chatId) }, + select: { id: true }, + }) + if (vorhanden) return 'schon-da' + + const chat = await db.telegramChat.create({ + data: { chatId: BigInt(chatId), benutzerId: kopplung.benutzerId }, + select: { id: true }, + }) + + await auditSchreiben({ + akteur: { id: kopplung.benutzerId, email: 'telegram@intern' }, + aktion: 'telegram.gekoppelt', + objektTyp: 'TelegramChat', + objektId: chat.id, + // Die Chatkennung gehört zu einer Person und bleibt draußen. + }) + return 'gekoppelt' +} + +/** Entfernt abgelaufene Codes. */ +export async function alteKopplungenEntfernen(zeitpunkt: Date): Promise { + const weg = await db.telegramKopplung.deleteMany({ + where: { gueltigBis: { lt: zeitpunkt } }, + }) + return weg.count +} + +// --- Holen ----------------------------------------------------------------- + +/** Ein bekannter Chat, oder null. Unbekannte werden nicht beantwortet. */ +async function chatPruefen(chatId: number) { + return db.telegramChat.findUnique({ + where: { chatId: BigInt(chatId) }, + select: { id: true, benutzerId: true }, + }) +} + +/** + * Hakt eine Aufgabe über den Knopf unter einer Meldung ab. + * + * Nur abhaken, nichts anderes: Ein Knopf, der löscht oder verschiebt, wäre + * aus einem Chat heraus zu leicht versehentlich getroffen. + */ +async function erledigtMelden(aufgabeId: string, anstoss: Anstoss): Promise { + const aufgabe = await db.aufgabe.findUnique({ + where: { id: aufgabeId }, + select: { id: true, titel: true, status: true }, + }) + if (!aufgabe) return 'Diese Aufgabe gibt es nicht mehr.' + if (aufgabe.status === 'ERLEDIGT') return 'War schon erledigt.' + + await db.aufgabe.update({ + where: { id: aufgabe.id }, + data: { status: 'ERLEDIGT', erledigtAm: jetzt() }, + }) + await auditSchreiben({ + akteur: anstoss, + aktion: 'aufgabe.erledigt', + objektTyp: 'Aufgabe', + objektId: aufgabe.id, + details: { ueber: 'telegram' }, + }) + return 'Erledigt.' +} + +/** + * Holt alles Neue ab und arbeitet es ab. + * + * Der Merker ist die Kennung der zuletzt geholten Aktualisierung. Telegram + * löscht alles darunter, sobald wir mit dem nächsten Offset fragen — das ist + * zugleich die Bestätigung, dass wir es haben. + */ +export async function telegramAbholen(anstoss: Anstoss): Promise<{ + aufgaben: number + abgehakt: number + gekoppelt: number + verworfen: number +}> { + try { + const merker = await merkerLesen('TELEGRAM') + const offset = merker ? Number(merker) : undefined + + const roh = await rufen('getUpdates', { + ...(offset === undefined || Number.isNaN(offset) ? {} : { offset }), + limit: HOECHSTENS, + // Kein Long-Polling: Der Job läuft ohnehin im Takt und soll nicht + // minutenlang eine Verbindung offen halten. + timeout: 0, + allowed_updates: ['message', 'callback_query'], + }) + + const eintraege = z.array(aktualisierung).safeParse(roh) + if (!eintraege.success) throw new Error('Telegram antwortete in unbekannter Form.') + + const funde: Fund[] = [] + let abgehakt = 0 + let gekoppelt = 0 + let verworfen = 0 + let hoechste = offset ? offset - 1 : 0 + + for (const eintrag of eintraege.data) { + hoechste = Math.max(hoechste, eintrag.update_id) + + if (eintrag.callback_query) { + const chatId = eintrag.callback_query.message?.chat.id + const bekannt = chatId === undefined ? null : await chatPruefen(chatId) + if (!bekannt) { + verworfen++ + continue + } + + const daten = eintrag.callback_query.data ?? '' + const [was, id] = daten.split(':') + const meldung = + was === 'erledigt' && id + ? await erledigtMelden(id, { + id: bekannt.benutzerId, + email: anstoss.email, + }) + : 'Unbekannter Knopf.' + abgehakt += meldung === 'Erledigt.' ? 1 : 0 + + await rufen('answerCallbackQuery', { + callback_query_id: eintrag.callback_query.id, + text: meldung, + }).catch(() => undefined) + continue + } + + const nachricht = eintrag.message + if (!nachricht?.text) continue + + const bekannt = await chatPruefen(nachricht.chat.id) + if (!bekannt) { + // Die einzige Ausnahme: ein gültiger Kopplungscode. Er ist der + // Beweis, dass jemand mit Zugang zur Anwendung diesen Chat will. + const code = KOPPLUNGSBEFEHL.exec(nachricht.text.trim())?.[1]?.toUpperCase() + if (code) { + const ergebnis = await kopplungEinloesen(code, nachricht.chat.id) + if (ergebnis !== 'unbekannt') { + gekoppelt++ + await telegramSenden( + BigInt(nachricht.chat.id), + ergebnis === 'gekoppelt' + ? 'Verbunden. Schick mir eine Nachricht, und daraus wird eine Aufgabe.' + : 'Dieser Chat war schon verbunden.', + ) + continue + } + } + // Sonst kein Wort zurück. Wer nicht eingetragen ist, soll nicht + // erfahren, dass hier etwas läuft. + verworfen++ + continue + } + + const { titel, rest } = alsTitel(nachricht.text) + if (titel.length === 0) continue + + funde.push({ + ref: `${nachricht.chat.id}:${nachricht.message_id}`, + titel, + notiz: rest, + }) + + await db.telegramChat.update({ + where: { id: bekannt.id }, + data: { zuletztBenutzt: jetzt() }, + }) + } + + const bericht = await fundeAufnehmen('TELEGRAM', funde, anstoss) + + // Erst bestätigen, wenn alles verarbeitet ist: Ein Offset, der zu früh + // hochgezählt wird, verliert Nachrichten unwiederbringlich. + await laufGeglueckt('TELEGRAM', String(hoechste + 1)) + + return { aufgaben: bericht.angelegt, abgehakt, gekoppelt, verworfen } + } catch (fehler) { + await laufGescheitert('TELEGRAM', fehler) + throw fehler + } +} diff --git a/src/server/integration/zammad.ts b/src/server/integration/zammad.ts new file mode 100644 index 0000000..5a34395 --- /dev/null +++ b/src/server/integration/zammad.ts @@ -0,0 +1,143 @@ +import 'server-only' +import { z } from 'zod' +import { alsTitel, type Fund } from '@/lib/integration' +import { umgebung } from '@/server/umgebung' +import { + fundeAufnehmen, + laufGescheitert, + laufGeglueckt, + type Anstoss, + type Aufnahmebericht, +} from '@/server/integration/aufnahme' + +/** + * Zammad – nur in der Instanz „firma". + * + * Gelesen wird über die Suche mit einem Ausdruck aus der Konfiguration; was + * darauf passt, wird zur Aufgabe. Der Token gehört einem Benutzer und sieht + * genau das, was dieser Benutzer sehen darf — der Planer umgeht keine Rechte. + * + * Geschrieben wird nach Zammad **nicht**. Ein Ticket schließt man im + * Ticketsystem, sonst weiß die Kollegin nicht, warum es plötzlich zu ist. + */ + +/** Wie viele Tickets höchstens je Lauf. Mehr wäre ohnehin keine Planung. */ +const HOECHSTENS = 100 + +/** + * Zammads Zuständen ist nicht anzusehen, ob sie „fertig" bedeuten. Der + * `state_type` sagt es; die Suche liefert ihn nicht immer mit, deshalb + * zusätzlich die üblichen Namen. + */ +const ERLEDIGT_ZUSTAENDE = ['closed', 'merged', 'removed'] + +const ticket = z.object({ + id: z.number().int(), + number: z.string(), + title: z.string(), + state: z.string().optional(), + /** 1 low, 2 normal, 3 high – Zammads Voreinstellung. */ + priority: z.string().optional(), + pending_time: z.string().nullable().optional(), +}) + +type Ticket = z.infer + +const antwort = z.object({ + assets: z.object({ Ticket: z.record(z.string(), z.unknown()).optional() }).optional(), + tickets: z.array(z.number().int()).optional(), +}) + +/** + * Übersetzt Zammads Priorität in unsere Skala. + * + * Zammad: 1 niedrig, 2 normal, 3 hoch. Hier: 1 dringend … 5 irgendwann. + * Die Zahlen laufen also gegenläufig, was beim Lesen gern übersehen wird. + */ +function prioritaetVon(zammad: string | undefined): number | null { + if (!zammad) return null + if (zammad.startsWith('3')) return 2 + if (zammad.startsWith('1')) return 4 + return 3 +} + +function alsFund(t: Ticket, basis: string): Fund { + const { titel, rest } = alsTitel(`#${t.number} ${t.title}`) + const zustand = (t.state ?? '').toLowerCase() + + return { + ref: String(t.id), + titel, + notiz: rest, + url: `${basis}/#ticket/zoom/${t.id}`, + faelligAm: t.pending_time ? new Date(t.pending_time) : null, + prioritaet: prioritaetVon(t.priority), + erledigt: ERLEDIGT_ZUSTAENDE.some((z) => zustand.includes(z)), + } +} + +/** Holt die Tickets, auf die der Suchausdruck passt. */ +export async function ticketsHolen(): Promise { + const einst = umgebung() + const basis = einst.ZAMMAD_URL.replace(/\/+$/, '') + + const adresse = new URL(`${basis}/api/v1/tickets/search`) + adresse.searchParams.set('query', einst.ZAMMAD_ABFRAGE) + adresse.searchParams.set('limit', String(HOECHSTENS)) + // Ohne "full" liefert die Suche nur Kennungen und wir müssten jedes Ticket + // einzeln nachladen. + adresse.searchParams.set('expand', 'true') + + const gelesen = await fetch(adresse, { + headers: { + Authorization: `Token token=${einst.ZAMMAD_TOKEN}`, + Accept: 'application/json', + }, + // Ein hängendes Ticketsystem darf den Job nicht festhalten. + signal: AbortSignal.timeout(20_000), + }) + + if (!gelesen.ok) { + // Nie den Antwortkörper: Zammad schickt im Fehlerfall gern den ganzen + // Datensatz mit. + throw new Error(`Zammad antwortete mit HTTP ${gelesen.status}.`) + } + + const inhalt: unknown = await gelesen.json() + + // Mit expand=true ist die Antwort eine Liste, ohne ein Objekt mit assets. + if (Array.isArray(inhalt)) { + return inhalt + .map((eintrag) => ticket.safeParse(eintrag)) + .filter((g) => g.success) + .map((g) => alsFund(g.data, basis)) + } + + const huelle = antwort.safeParse(inhalt) + if (!huelle.success) throw new Error('Zammad antwortete in unbekannter Form.') + + const werte = Object.values(huelle.data.assets?.Ticket ?? {}) + return werte + .map((eintrag) => ticket.safeParse(eintrag)) + .filter((g) => g.success) + .map((g) => alsFund(g.data, basis)) +} + +/** + * Ein Durchlauf: holen, aufnehmen, Zustand fortschreiben. + * + * Scheitert das Holen, bleibt der bisherige Stand stehen. Eine leere Antwort + * darf niemals als „alles erledigt" durchgehen — deshalb schließt diese + * Integration nur, was Zammad ausdrücklich als geschlossen liefert. + */ +export async function zammadAbgleichen(anstoss: Anstoss): Promise { + try { + const funde = await ticketsHolen() + const bericht = await fundeAufnehmen('ZAMMAD', funde, anstoss) + await laufGeglueckt('ZAMMAD') + return bericht + } catch (fehler) { + await laufGescheitert('ZAMMAD', fehler) + throw fehler + } +} From bc60e5f864209e1f729773688ac0a0f743685c9e Mon Sep 17 00:00:00 2001 From: Florian Wilde Date: Fri, 11 Sep 2026 23:04:05 +0200 Subject: [PATCH 04/14] feat: Integrationen takten und Telegram als dritten Meldeweg MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Telegram alle zwei Minuten, Zammad und Spiegel alle fuenfzehn. Wer dem Bot etwas schickt, erwartet die Aufgabe gleich in der Liste; in Zammad aendert sich dagegen nichts im Minutentakt. Meldungen gehen jetzt auch per Telegram hinaus — mit einem Knopf zum Abhaken, wenn es um genau eine Aufgabe geht. Eine klemmende Integration meldet sich wie ein klemmender Kalender: erst nach dem dritten Fehlversuch, dann aber deutlich. Co-Authored-By: Claude Opus 5 --- src/lib/benachrichtigung.ts | 12 ++++- src/server/benachrichtigung/versand.ts | 56 ++++++++++++++++++---- src/server/jobs.ts | 64 ++++++++++++++++++++++++++ 3 files changed, 123 insertions(+), 9 deletions(-) diff --git a/src/lib/benachrichtigung.ts b/src/lib/benachrichtigung.ts index 0fbb16b..ab756b5 100644 --- a/src/lib/benachrichtigung.ts +++ b/src/lib/benachrichtigung.ts @@ -47,6 +47,7 @@ export type Einstellung = { anlaesse: readonly Anlass[] perPush: boolean perMail: boolean + perTelegram: boolean /** Uhrzeit des Tagesüberblicks, Minuten seit Mitternacht. */ ueberblickUm: number /** Ruhezeit: von hier bis … nichts melden. */ @@ -68,6 +69,7 @@ export const VOREINSTELLUNG: Einstellung = { anlaesse: ['tagesueberblick', 'faelligkeit'], perPush: false, perMail: false, + perTelegram: false, ueberblickUm: 7 * 60, ruheVon: 20 * 60, ruheBis: 7 * 60, @@ -103,6 +105,13 @@ export type Meldung = { text: string /** Wohin der Klick führt. */ pfad: string + /** + * Die Aufgabe, um die es geht — sofern es genau eine ist. + * + * Nur dann lässt sich unter die Meldung ein Knopf hängen, der sie abhakt. + * Ein Tagesüberblick hat keine. + */ + objektId?: string } /** @@ -124,7 +133,7 @@ export function sendenEntscheiden( if (!einstellung.anlaesse.includes(meldung.anlass)) { return { senden: false, grund: 'abgeschaltet' } } - if (!einstellung.perPush && !einstellung.perMail) { + if (!einstellung.perPush && !einstellung.perMail && !einstellung.perTelegram) { return { senden: false, grund: 'kein-weg' } } if (bereitsGemeldet.has(meldung.schluessel)) { @@ -202,6 +211,7 @@ export const einstellungSchema = z.object({ anlaesse: z.array(z.enum(ANLAESSE)).default([]), perPush: z.coerce.boolean().default(false), perMail: z.coerce.boolean().default(false), + perTelegram: z.coerce.boolean().default(false), ueberblickUm: uhrzeit, ruheVon: uhrzeit, ruheBis: uhrzeit, diff --git a/src/server/benachrichtigung/versand.ts b/src/server/benachrichtigung/versand.ts index c3be9ee..dc97ccd 100644 --- a/src/server/benachrichtigung/versand.ts +++ b/src/server/benachrichtigung/versand.ts @@ -17,9 +17,13 @@ import { tagesBeginn, tagesEnde, } from '@/lib/zeit' +import type { Quelle } from '@/generated/prisma/enums' +import { INTEGRATION_FEHLER_AB_VERSUCH } from '@/lib/integration' import { db } from '@/server/db' import { mailSenden } from '@/server/benachrichtigung/mail' import { pushSenden } from '@/server/benachrichtigung/push' +import { telegramMeldung } from '@/server/integration/telegram' +import { umgebung } from '@/server/umgebung' import { jetzt } from '@/server/zeitgeber' /** @@ -46,6 +50,7 @@ export function alsEinstellung( anlaesse: string perPush: boolean perMail: boolean + perTelegram: boolean ueberblickUm: number ruheVon: number ruheBis: number @@ -66,6 +71,7 @@ export function alsEinstellung( anlaesse, perPush: zeile.perPush, perMail: zeile.perMail, + perTelegram: zeile.perTelegram, ueberblickUm: zeile.ueberblickUm, ruheVon: zeile.ruheVon, ruheBis: zeile.ruheBis, @@ -86,6 +92,7 @@ async function empfaengerLaden(): Promise { anlaesse: true, perPush: true, perMail: true, + perTelegram: true, ueberblickUm: true, ruheVon: true, ruheBis: true, @@ -141,6 +148,9 @@ export async function meldungZustellen( if (benutzer.einstellung.perPush) await pushSenden(benutzer.id, meldung) if (benutzer.einstellung.perMail) await mailSenden(benutzer.email, meldung) + if (benutzer.einstellung.perTelegram && umgebung().telegramAktiv) { + await telegramMeldung(benutzer.id, meldung) + } return true } @@ -232,6 +242,8 @@ async function faelligkeitenBauen(zeitpunkt: Date): Promise { titel: 'Heute fällig', text: aufgabe.titel, pfad: '/aufgaben', + // Genau eine Aufgabe: Telegram kann einen Knopf zum Abhaken anbieten. + objektId: aufgabe.id, })) } @@ -266,7 +278,15 @@ async function zeitblockErinnerungenBauen( })) } -/** Kalender, die mehrfach hintereinander nicht abgleichbar waren. */ +/** Lesbare Namen für die Meldung; die Aufzählung selbst ist technisch. */ +const INTEGRATION_NAME: Partial> = { + ZAMMAD: 'Zammad', + WARTUNGSPLANER: 'Wartungsplaner', + TELEGRAM: 'Telegram', + SPIEGEL: 'Spiegel', +} + +/** Kalender und Integrationen, die mehrfach hintereinander klemmten. */ async function abgleichfehlerBauen( benutzerId: string, zeitpunkt: Date, @@ -283,14 +303,34 @@ async function abgleichfehlerBauen( select: { id: true, anzeigename: true, letzterFehler: true }, }) + // Eine klemmende Integration wiegt genauso schwer wie ein klemmender + // Kalender: In beiden Fällen steht die Liste auf einem alten Stand, ohne + // dass es jemandem auffiele. + const integrationen = await db.integrationszustand.findMany({ + where: { + letzterFehler: { not: null }, + fehlversuche: { gte: INTEGRATION_FEHLER_AB_VERSUCH }, + }, + select: { quelle: true, letzterFehler: true }, + }) + const tag = alsTagesschluessel(zeitpunkt) - return konten.map((konto) => ({ - anlass: 'abgleichfehler' as const, - schluessel: meldungsSchluessel('abgleichfehler', konto.id, tag), - titel: 'Ein Kalender lässt sich nicht abgleichen', - text: `„${konto.anzeigename}": ${konto.letzterFehler ?? 'unbekannter Fehler'}`, - pfad: '/kalenderkonten', - })) + return [ + ...konten.map((konto) => ({ + anlass: 'abgleichfehler' as const, + schluessel: meldungsSchluessel('abgleichfehler', konto.id, tag), + titel: 'Ein Kalender lässt sich nicht abgleichen', + text: `„${konto.anzeigename}": ${konto.letzterFehler ?? 'unbekannter Fehler'}`, + pfad: '/kalenderkonten', + })), + ...integrationen.map((i) => ({ + anlass: 'abgleichfehler' as const, + schluessel: meldungsSchluessel('abgleichfehler', i.quelle, tag), + titel: 'Eine Integration klemmt', + text: `${INTEGRATION_NAME[i.quelle] ?? i.quelle}: ${i.letzterFehler ?? 'unbekannter Fehler'}`, + pfad: '/integrationen', + })), + ] } export type VersandBericht = { geprueft: number; gesendet: number } diff --git a/src/server/jobs.ts b/src/server/jobs.ts index 62a33ec..93196a5 100644 --- a/src/server/jobs.ts +++ b/src/server/jobs.ts @@ -7,6 +7,10 @@ import { alteNachweiseEntfernen, benachrichtigungenVerschicken, } from '@/server/benachrichtigung/versand' +import { zammadAbgleichen } from '@/server/integration/zammad' +import { alteKopplungenEntfernen, telegramAbholen } from '@/server/integration/telegram' +import { spiegelSenden } from '@/server/integration/spiegel' +import { umgebung } from '@/server/umgebung' import { jetzt } from '@/server/zeitgeber' /** @@ -31,6 +35,24 @@ const AUFRAEUM_PLAN = '17 3 * * *' * dank Wiederholungssperre nur einmal gemeldet. */ const MELDUNGS_PLAN = '*/10 * * * *' +/** + * Integrationen laufen im eigenen Takt. + * + * Telegram oefter als der Rest: Wer dem Bot etwas schickt, erwartet die + * Aufgabe gleich in der Liste, nicht in einer Viertelstunde. Zammad und der + * Spiegel duerfen traeger sein — dort aendert sich nichts im Minutentakt. + */ +const TELEGRAM_PLAN = '*/2 * * * *' +const ZAMMAD_PLAN = '*/15 * * * *' +const SPIEGEL_PLAN = '*/15 * * * *' + +/** + * Wer im Protokoll steht, wenn niemand geklickt hat. + * + * Ein Job hat keinen Benutzer. Statt den Eintrag wegzulassen, traegt er + * sichtbar den Dienst ein — sonst sieht es aus, als sei nichts passiert. + */ +const DIENST = { id: null, email: 'dienst@intern' } async function alleKontenAbgleichen(): Promise { const zeitpunkt = jetzt() @@ -87,11 +109,53 @@ export function jobsStarten(): void { }) }) + const einst = umgebung() + + if (einst.zammadAktiv) { + cron.schedule(ZAMMAD_PLAN, () => { + void zammadAbgleichen(DIENST) + .then((bericht) => { + if (bericht.angelegt > 0 || bericht.geschlossen > 0) { + console.warn( + `Zammad: ${bericht.angelegt} neu, ${bericht.geschlossen} geschlossen.`, + ) + } + }) + .catch((fehler: unknown) => { + console.error('Zammad-Abgleich abgebrochen:', fehler) + }) + }) + } + + if (einst.telegramAktiv) { + cron.schedule(TELEGRAM_PLAN, () => { + void telegramAbholen(DIENST) + .then((bericht) => { + if (bericht.verworfen > 0) { + // Nie die Chatkennung: Sie gehoert zu einer Person. + console.warn(`Telegram: ${bericht.verworfen} Nachricht(en) verworfen.`) + } + }) + .catch((fehler: unknown) => { + console.error('Telegram-Abholen abgebrochen:', fehler) + }) + }) + } + + if (einst.spiegelSendenAktiv) { + cron.schedule(SPIEGEL_PLAN, () => { + void spiegelSenden().catch((fehler: unknown) => { + console.error('Spiegel-Versand abgebrochen:', fehler) + }) + }) + } + cron.schedule(AUFRAEUM_PLAN, () => { void Promise.all([ alteTermineEntfernen(), abgelaufeneChallengesEntfernen(jetzt()), alteNachweiseEntfernen(jetzt()), + alteKopplungenEntfernen(jetzt()), ]) .then(() => undefined) .catch((fehler: unknown) => { From 1281c3ea9662d9eb47a231412b72223edbfe8426 Mon Sep 17 00:00:00 2001 From: Florian Wilde Date: Fri, 11 Sep 2026 23:04:33 +0200 Subject: [PATCH 05/14] feat: Integrationen sichtbar und bedienbar machen MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Eine Seite zeigt je Integration, ob sie vorgesehen, eingerichtet oder gestoert ist, wann sie zuletzt geglueckt ist und woran sie klemmt. Der Wartungsplaner steht sichtbar als offene Luecke darin, nicht als Leerstelle. Telegram-Chats werden hier gekoppelt und wieder getrennt, Meldungen je Chat einzeln geschaltet. Aufgaben bekommen einen Schalter zum Spiegeln — einzeln und je Aufgabe, denn wer versehentlich einen ganzen Bereich spiegelt, schickt Kundennamen nach Hause. Co-Authored-By: Claude Opus 5 --- .../einstellungen/benachrichtigungen.tsx | 35 ++++ src/app/(app)/einstellungen/page.tsx | 7 +- src/app/(app)/integrationen/page.tsx | 180 +++++++++++++++++ .../(app)/integrationen/telegram-chats.tsx | 139 +++++++++++++ src/components/kopfleiste.tsx | 1 + src/server/aktionen/aufgaben.ts | 49 +++++ src/server/aktionen/benachrichtigungen.ts | 25 ++- src/server/aktionen/integrationen.ts | 191 ++++++++++++++++++ 8 files changed, 624 insertions(+), 3 deletions(-) create mode 100644 src/app/(app)/integrationen/page.tsx create mode 100644 src/app/(app)/integrationen/telegram-chats.tsx create mode 100644 src/server/aktionen/integrationen.ts diff --git a/src/app/(app)/einstellungen/benachrichtigungen.tsx b/src/app/(app)/einstellungen/benachrichtigungen.tsx index a5baa5e..c8eb0aa 100644 --- a/src/app/(app)/einstellungen/benachrichtigungen.tsx +++ b/src/app/(app)/einstellungen/benachrichtigungen.tsx @@ -34,6 +34,7 @@ export type EinstellungAnzeige = { anlaesse: Anlass[] perPush: boolean perMail: boolean + perTelegram: boolean ueberblickUm: string ruheVon: string ruheBis: string @@ -46,6 +47,9 @@ type Eigenschaften = { geraete: GeraetAnzeige[] pushMoeglich: boolean mailMoeglich: boolean + telegramMoeglich: boolean + /** Wie viele Chats Meldungen empfangen. Null heisst: noch keiner. */ + telegramChats: number } /** @@ -68,6 +72,8 @@ export function Benachrichtigungen({ geraete, pushMoeglich, mailMoeglich, + telegramMoeglich, + telegramChats, }: Eigenschaften) { const router = useRouter() const [laeuft, starte] = useTransition() @@ -311,6 +317,35 @@ export function Benachrichtigungen({ )} + +
diff --git a/src/app/(app)/einstellungen/page.tsx b/src/app/(app)/einstellungen/page.tsx index c1514a4..4562bec 100644 --- a/src/app/(app)/einstellungen/page.tsx +++ b/src/app/(app)/einstellungen/page.tsx @@ -23,13 +23,14 @@ export default async function EinstellungenSeite() { const einst = umgebung() - const [benachrichtigung, pushGeraete] = await Promise.all([ + const [benachrichtigung, telegramChats, pushGeraete] = await Promise.all([ db.benachrichtigungseinstellung.findUnique({ where: { benutzerId: benutzer.id }, select: { anlaesse: true, perPush: true, perMail: true, + perTelegram: true, ueberblickUm: true, ruheVon: true, ruheBis: true, @@ -37,6 +38,7 @@ export default async function EinstellungenSeite() { zeitblockVorlaufMinuten: true, }, }), + db.telegramChat.count({ where: { benutzerId: benutzer.id, meldungen: true } }), db.pushGeraet.findMany({ where: { benutzerId: benutzer.id }, orderBy: { erstelltAm: 'asc' }, @@ -119,10 +121,13 @@ export default async function EinstellungenSeite() { [z.quelle, z])) + + const zeilen: Zeile[] = [ + { + quelle: 'ZAMMAD', + name: 'Zammad', + beschreibung: + 'Tickets, auf die der Suchausdruck passt, werden zu Aufgaben. Geschrieben wird nach Zammad nichts — ein Ticket schließt man im Ticketsystem.', + vorgesehen: einst.instanz === 'firma', + aktiv: einst.zammadAktiv, + hinweis: 'ZAMMAD_URL und ZAMMAD_TOKEN fehlen.', + }, + { + quelle: 'WARTUNGSPLANER', + name: 'Wartungsplaner', + beschreibung: + 'Noch nicht angebunden: Die Schnittstelle ist offen. Die Aufnahmestelle steht bereit, es fehlt allein das Abholen.', + vorgesehen: einst.instanz === 'firma', + aktiv: false, + hinweis: 'Kommt, sobald die Schnittstelle feststeht.', + }, + { + quelle: 'TELEGRAM', + name: 'Telegram', + beschreibung: + 'Eine Nachricht an den Bot wird zur Aufgabe. Meldungen gehen denselben Weg zurück — mit einem Knopf zum Abhaken.', + vorgesehen: einst.instanz === 'daheim', + aktiv: einst.telegramAktiv, + hinweis: 'TELEGRAM_TOKEN fehlt.', + }, + { + quelle: 'SPIEGEL', + name: 'Spiegel', + beschreibung: + einst.instanz === 'firma' + ? 'Schickt Belegungen ohne Titel nach Hause, dazu die Aufgaben, die ausdrücklich zum Spiegeln markiert sind.' + : 'Empfängt dienstliche Belegungen. Sie erscheinen in der Wochenansicht als „Dienstlich belegt", ohne Betreff.', + vorgesehen: true, + aktiv: einst.spiegelSendenAktiv || einst.spiegelEmpfangenAktiv, + hinweis: 'SPIEGEL_GEHEIMNIS fehlt.', + }, + ] + + return ( +
+
+ +
+

Integrationen

+

+ Was von außen hereinkommt — und was diese Instanz hinausgibt. +

+
+
+ +
+ {zeilen.map((zeile) => { + const zustand = nachQuelle.get(zeile.quelle) + const gestoert = (zustand?.fehlversuche ?? 0) >= INTEGRATION_FEHLER_AB_VERSUCH + + return ( + + +
+ {zeile.name} + {!zeile.vorgesehen ? ( + + In dieser Instanz nicht vorgesehen + + ) : gestoert ? ( + Gestört + ) : zeile.aktiv ? ( + Läuft + ) : ( + Nicht eingerichtet + )} +
+ {zeile.beschreibung} + + + + {zeile.vorgesehen && !zeile.aktiv &&

{zeile.hinweis}

} + + {zustand?.letzterErfolg && ( +

Zuletzt geglückt: {alsDatumUhrzeit(zustand.letzterErfolg)}

+ )} + {zustand?.letzterFehler && ( +

+ Letzter Fehler: {zustand.letzterFehler} + {zustand.fehlversuche > 1 && ` (${zustand.fehlversuche}× in Folge)`} +

+ )} + {!zustand && zeile.aktiv &&

Noch kein Lauf.

} + + + ) + })} +
+ + {einst.telegramAktiv && ( + + + Telegram-Chats + + Nur wer hier steht, darf mit dem Bot reden — und nur diese Chats bekommen + Meldungen. Alles andere wird verworfen, ohne zu antworten. Die Kennung + deines Chats verrät dir der Bot, wenn du ihm{' '} + /start schickst und danach hier nachsiehst; + steht sie noch nicht drin, findest du sie im Protokoll. + + + + ({ + id: c.id, + chatId: c.chatId.toString(), + bezeichnung: c.bezeichnung, + meldungen: c.meldungen, + erstelltAm: alsDatumUhrzeit(c.erstelltAm), + zuletztBenutzt: c.zuletztBenutzt + ? alsDatumUhrzeit(c.zuletztBenutzt) + : null, + }))} + /> + + + )} +
+ ) +} diff --git a/src/app/(app)/integrationen/telegram-chats.tsx b/src/app/(app)/integrationen/telegram-chats.tsx new file mode 100644 index 0000000..50c349c --- /dev/null +++ b/src/app/(app)/integrationen/telegram-chats.tsx @@ -0,0 +1,139 @@ +'use client' + +import { useState, useTransition } from 'react' +import { useRouter } from 'next/navigation' +import { Bell, BellOff, Link2, Loader2, Trash2 } from 'lucide-react' +import { toast } from 'sonner' +import { Button } from '@/components/ui/button' +import { + chatEntfernen, + chatMeldungenUmschalten, + kopplungAnfordern, +} from '@/server/aktionen/integrationen' + +export type ChatAnzeige = { + id: string + chatId: string + bezeichnung: string | null + meldungen: boolean + erstelltAm: string + zuletztBenutzt: string | null +} + +export function TelegramChats({ chats }: { chats: ChatAnzeige[] }) { + const router = useRouter() + const [laeuft, starte] = useTransition() + const [code, setCode] = useState<{ code: string; minuten: number } | null>(null) + + function anfordern() { + starte(async () => { + const antwort = await kopplungAnfordern() + if (antwort.ok) { + setCode({ code: antwort.code, minuten: antwort.minuten }) + } else { + toast.error(antwort.fehler) + } + }) + } + + function mitRueckmeldung( + tun: () => Promise<{ ok: boolean; meldung?: string; fehler?: string }>, + ) { + starte(async () => { + const antwort = await tun() + if (antwort.ok) { + toast.success(antwort.meldung ?? 'Erledigt.') + router.refresh() + } else { + toast.error(antwort.fehler ?? 'Das hat nicht geklappt.') + } + }) + } + + return ( +
+ {chats.length === 0 ? ( +

+ Noch kein Chat verbunden. Ohne Verbindung nimmt der Bot nichts an. +

+ ) : ( +
    + {chats.map((chat) => ( +
  • +
    +

    {chat.bezeichnung ?? `Chat ${chat.chatId}`}

    +

    + Verbunden {chat.erstelltAm} + {chat.zuletztBenutzt + ? ` · zuletzt benutzt ${chat.zuletztBenutzt}` + : ' · noch nichts geschickt'} +

    +
    + + + + +
    • + ))} +
+ )} + + {code ? ( +
+

+ Schick dem Bot jetzt diesen Code — als Nachricht oder als{' '} + /start {code.code}: +

+

{code.code}

+

+ Gültig für {code.minuten} Minuten und nur ein einziges Mal. Danach erscheint + der Chat hier — spätestens nach dem nächsten Abholen. +

+
+ ) : ( +
+ +
+ )} +
+ ) +} diff --git a/src/components/kopfleiste.tsx b/src/components/kopfleiste.tsx index e00c58d..f314be0 100644 --- a/src/components/kopfleiste.tsx +++ b/src/components/kopfleiste.tsx @@ -35,6 +35,7 @@ export function Kopfleiste({ { pfad: '/ideen', name: 'Ideen' }, { pfad: '/bereiche', name: 'Bereiche' }, { pfad: '/kalenderkonten', name: 'Kalender' }, + { pfad: '/integrationen', name: 'Integrationen' }, { pfad: '/einstellungen', name: 'Einstellungen' }, { pfad: '/verwaltung/protokoll', name: 'Protokoll', nurAdmin: true }, ] diff --git a/src/server/aktionen/aufgaben.ts b/src/server/aktionen/aufgaben.ts index 2a8af5a..6fcf1ea 100644 --- a/src/server/aktionen/aufgaben.ts +++ b/src/server/aktionen/aufgaben.ts @@ -12,6 +12,7 @@ import { import { auditSchreiben } from '@/server/audit' import { NichtErlaubt, pruefeRolle } from '@/server/berechtigung' import { db } from '@/server/db' +import { umgebung } from '@/server/umgebung' import { jetzt } from '@/server/zeitgeber' /** @@ -347,6 +348,54 @@ export async function einsortieren(daten: FormData): Promise { return { ok: true, meldung: `„${aufgabe.titel}" liegt jetzt in ${bereich.name}.` } } +/** + * Gibt eine Aufgabe zum Spiegeln frei – oder nimmt die Freigabe zurück. + * + * Nur was hier ausdrücklich markiert ist, verlässt die Instanz mit Titel. + * Deshalb ein eigener Handgriff je Aufgabe und kein Schalter für alles: Wer + * versehentlich einen Bereich spiegelt, schickt Kundennamen nach Hause. + */ +export async function spiegelnUmschalten(daten: FormData): Promise { + const geprueft = await akteurOder((fehler) => ({ ok: false, fehler })) + if ('antwort' in geprueft) return geprueft.antwort + const { akteur } = geprueft + + if (!umgebung().spiegelSendenAktiv) { + return { ok: false, fehler: 'Diese Instanz spiegelt nicht.' } + } + + const id = daten.get('id') + if (typeof id !== 'string' || id.length === 0) { + return { ok: false, fehler: 'Ungültige Anfrage.' } + } + + const aufgabe = await db.aufgabe.findUnique({ + where: { id }, + select: { id: true, titel: true, spiegeln: true }, + }) + if (!aufgabe) return { ok: false, fehler: 'Diese Aufgabe gibt es nicht mehr.' } + + const kuenftig = !aufgabe.spiegeln + await db.aufgabe.update({ where: { id: aufgabe.id }, data: { spiegeln: kuenftig } }) + + await auditSchreiben({ + akteur: { id: akteur.id, email: akteur.email }, + aktion: kuenftig ? 'aufgabe.spiegeln-an' : 'aufgabe.spiegeln-aus', + objektTyp: 'Aufgabe', + objektId: aufgabe.id, + details: { titel: aufgabe.titel }, + }) + + revalidatePath('/aufgaben') + revalidatePath('/inbox') + return { + ok: true, + meldung: kuenftig + ? `„${aufgabe.titel}" geht künftig mit nach Hause.` + : `„${aufgabe.titel}" bleibt hier.`, + } +} + /** Aus einer Idee wird eine Aufgabe. */ export async function ideeUebernehmen(daten: FormData): Promise { const geprueft = await akteurOder((fehler) => ({ ok: false, fehler })) diff --git a/src/server/aktionen/benachrichtigungen.ts b/src/server/aktionen/benachrichtigungen.ts index ca7f71e..2385591 100644 --- a/src/server/aktionen/benachrichtigungen.ts +++ b/src/server/aktionen/benachrichtigungen.ts @@ -8,6 +8,7 @@ import { NichtErlaubt, pruefeRolle } from '@/server/berechtigung' import { mailSenden } from '@/server/benachrichtigung/mail' import { pushSenden } from '@/server/benachrichtigung/push' import { alsEinstellung } from '@/server/benachrichtigung/versand' +import { telegramMeldung } from '@/server/integration/telegram' import { db } from '@/server/db' import { umgebung } from '@/server/umgebung' import { jetzt } from '@/server/zeitgeber' @@ -37,6 +38,7 @@ export async function einstellungSpeichern(daten: FormData): Promise { anlaesse: true, perPush: true, perMail: true, + perTelegram: true, ueberblickUm: true, ruheVon: true, ruheBis: true, @@ -112,8 +117,11 @@ export async function probeSenden(): Promise { }) const einstellung = alsEinstellung(zeile) - if (!einstellung.perPush && !einstellung.perMail) { - return { ok: false, fehler: 'Erst einen Weg einschalten — Push oder E-Mail.' } + if (!einstellung.perPush && !einstellung.perMail && !einstellung.perTelegram) { + return { + ok: false, + fehler: 'Erst einen Weg einschalten — Push, E-Mail oder Telegram.', + } } const meldung = { @@ -153,6 +161,19 @@ export async function probeSenden(): Promise { } } + if (einstellung.perTelegram) { + if (!einst.telegramAktiv) { + wege.push('Telegram ist auf diesem Server nicht eingerichtet') + } else { + const zugestellt = await telegramMeldung(akteur.id, meldung) + wege.push( + zugestellt > 0 + ? `Telegram an ${zugestellt} Chat(s)` + : 'kein Telegram-Chat eingetragen', + ) + } + } + await auditSchreiben({ akteur: { id: akteur.id, email: akteur.email }, aktion: 'benachrichtigung.probe', diff --git a/src/server/aktionen/integrationen.ts b/src/server/aktionen/integrationen.ts new file mode 100644 index 0000000..db2db95 --- /dev/null +++ b/src/server/aktionen/integrationen.ts @@ -0,0 +1,191 @@ +'use server' + +import { revalidatePath } from 'next/cache' +import { auditSchreiben } from '@/server/audit' +import { NichtErlaubt, pruefeRolle } from '@/server/berechtigung' +import { db } from '@/server/db' +import { + KOPPLUNG_MINUTEN, + kopplungscodeBauen, + telegramAbholen, +} from '@/server/integration/telegram' +import { zammadAbgleichen } from '@/server/integration/zammad' +import { spiegelSenden } from '@/server/integration/spiegel' +import { umgebung } from '@/server/umgebung' +import { jetzt } from '@/server/zeitgeber' + +export type Rueckmeldung = { ok: true; meldung: string } | { ok: false; fehler: string } + +async function akteurOderFehler() { + try { + return { akteur: await pruefeRolle('BENUTZER') } + } catch (fehler) { + if (fehler instanceof NichtErlaubt) { + return { antwort: { ok: false as const, fehler: fehler.message } } + } + throw fehler + } +} + +/** + * Erzeugt einen Kopplungscode für einen Telegram-Chat. + * + * Alte Codes desselben Benutzers fallen dabei weg: Zwei gültige Codes + * gleichzeitig sind einer zu viel. + */ +export async function kopplungAnfordern(): Promise< + { ok: true; code: string; minuten: number } | { ok: false; fehler: string } +> { + const geprueft = await akteurOderFehler() + if ('antwort' in geprueft) return geprueft.antwort + const { akteur } = geprueft + + if (!umgebung().telegramAktiv) { + return { ok: false, fehler: 'Telegram ist auf diesem Server nicht eingerichtet.' } + } + + await db.telegramKopplung.deleteMany({ where: { benutzerId: akteur.id } }) + + const code = kopplungscodeBauen() + await db.telegramKopplung.create({ + data: { + code, + benutzerId: akteur.id, + gueltigBis: new Date(jetzt().getTime() + KOPPLUNG_MINUTEN * 60_000), + }, + }) + + await auditSchreiben({ + akteur: { id: akteur.id, email: akteur.email }, + aktion: 'telegram.kopplung-angefordert', + objektTyp: 'TelegramKopplung', + objektId: null, + // Nie der Code selbst: Wer das Protokoll liest, könnte sonst koppeln. + }) + + return { ok: true, code, minuten: KOPPLUNG_MINUTEN } +} + +/** Trennt einen Chat wieder. */ +export async function chatEntfernen(daten: FormData): Promise { + const geprueft = await akteurOderFehler() + if ('antwort' in geprueft) return geprueft.antwort + const { akteur } = geprueft + + const id = daten.get('id') + if (typeof id !== 'string' || id.length === 0) { + return { ok: false, fehler: 'Ungültige Anfrage.' } + } + + const chat = await db.telegramChat.findUnique({ + where: { id }, + select: { id: true, bezeichnung: true }, + }) + if (!chat) return { ok: false, fehler: 'Diesen Chat gibt es nicht.' } + + await db.telegramChat.delete({ where: { id: chat.id } }) + + await auditSchreiben({ + akteur: { id: akteur.id, email: akteur.email }, + aktion: 'telegram.getrennt', + objektTyp: 'TelegramChat', + objektId: chat.id, + }) + + revalidatePath('/integrationen') + return { ok: true, meldung: 'Chat getrennt.' } +} + +/** Schaltet um, ob ein Chat Meldungen bekommt. */ +export async function chatMeldungenUmschalten(daten: FormData): Promise { + const geprueft = await akteurOderFehler() + if ('antwort' in geprueft) return geprueft.antwort + const { akteur } = geprueft + + const id = daten.get('id') + if (typeof id !== 'string' || id.length === 0) { + return { ok: false, fehler: 'Ungültige Anfrage.' } + } + + const chat = await db.telegramChat.findUnique({ + where: { id }, + select: { id: true, meldungen: true }, + }) + if (!chat) return { ok: false, fehler: 'Diesen Chat gibt es nicht.' } + + const kuenftig = !chat.meldungen + await db.telegramChat.update({ + where: { id: chat.id }, + data: { meldungen: kuenftig }, + }) + + await auditSchreiben({ + akteur: { id: akteur.id, email: akteur.email }, + aktion: kuenftig ? 'telegram.meldungen-an' : 'telegram.meldungen-aus', + objektTyp: 'TelegramChat', + objektId: chat.id, + }) + + revalidatePath('/integrationen') + return { + ok: true, + meldung: kuenftig + ? 'Dieser Chat bekommt Meldungen.' + : 'Dieser Chat bekommt keine Meldungen mehr.', + } +} + +/** + * Stößt einen Lauf von Hand an. + * + * Nützlich nach dem Einrichten: Sonst wüsste man erst beim nächsten Takt, ob + * die Zugangsdaten stimmen. + */ +export async function laufAnstossen(daten: FormData): Promise { + const geprueft = await akteurOderFehler() + if ('antwort' in geprueft) return geprueft.antwort + const { akteur } = geprueft + + const quelle = daten.get('quelle') + const anstoss = { id: akteur.id, email: akteur.email } + const einst = umgebung() + + try { + if (quelle === 'ZAMMAD' && einst.zammadAktiv) { + const bericht = await zammadAbgleichen(anstoss) + revalidatePath('/integrationen') + revalidatePath('/aufgaben') + return { + ok: true, + meldung: `${bericht.angelegt} neu, ${bericht.aktualisiert} geändert, ${bericht.geschlossen} geschlossen.`, + } + } + + if (quelle === 'TELEGRAM' && einst.telegramAktiv) { + const bericht = await telegramAbholen(anstoss) + revalidatePath('/integrationen') + revalidatePath('/aufgaben') + return { + ok: true, + meldung: `${bericht.aufgaben} Aufgabe(n), ${bericht.gekoppelt} Kopplung(en), ${bericht.abgehakt} abgehakt.`, + } + } + + if (quelle === 'SPIEGEL' && einst.spiegelSendenAktiv) { + const bericht = await spiegelSenden() + revalidatePath('/integrationen') + return { + ok: true, + meldung: `${bericht.belegungen} Belegung(en) und ${bericht.aufgaben} Aufgabe(n) geschickt.`, + } + } + + return { ok: false, fehler: 'Diese Integration ist hier nicht eingerichtet.' } + } catch (fehler) { + // Die Meldung des fremden Systems, nicht dessen Antwort im Ganzen. + return { + ok: false, + fehler: fehler instanceof Error ? fehler.message : 'Der Lauf ist gescheitert.', + } + } +} From 0d0f8503ccf8efcd5aa9dc26f8f7430c2e08cb8d Mon Sep 17 00:00:00 2001 From: Florian Wilde Date: Fri, 11 Sep 2026 23:04:35 +0200 Subject: [PATCH 06/14] feat: Gespiegelte Belegung in der Wochenansicht zeigen MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sie zaehlt gegen die Tageskapazitaet wie jeder fremde Termin, traegt aber keinen Betreff und ist gestreift gezeichnet — damit niemand darin einen Termin vermutet, dem der Titel fehlt. Co-Authored-By: Claude Opus 5 --- src/app/(app)/woche/page.tsx | 1 + src/app/(app)/woche/wochenraster.tsx | 17 ++++++++-- src/server/abfragen/woche.ts | 48 +++++++++++++++++++++------- 3 files changed, 53 insertions(+), 13 deletions(-) diff --git a/src/app/(app)/woche/page.tsx b/src/app/(app)/woche/page.tsx index a7c7430..19f7ef2 100644 --- a/src/app/(app)/woche/page.tsx +++ b/src/app/(app)/woche/page.tsx @@ -187,6 +187,7 @@ export default async function WocheSeite({ ganztaegig: t.ganztaegig, frei: t.zeigtAls === 'FREI', kalenderName: t.kalenderName, + gespiegelt: t.gespiegelt, }))} aufgaben={aufgaben.map((a) => ({ id: a.id, diff --git a/src/app/(app)/woche/wochenraster.tsx b/src/app/(app)/woche/wochenraster.tsx index d1de1ed..a4926cc 100644 --- a/src/app/(app)/woche/wochenraster.tsx +++ b/src/app/(app)/woche/wochenraster.tsx @@ -64,6 +64,8 @@ export type RasterTermin = { ganztaegig: boolean frei: boolean kalenderName: string + /** Aus der anderen Instanz gespiegelt: belegt, aber ohne Betreff. */ + gespiegelt?: boolean } export type RasterSpalte = { @@ -321,6 +323,11 @@ export function Wochenraster({ eintrag.frei ? 'bg-gedaempft/60 text-gedaempft-vordergrund' : 'bg-gedaempft text-gedaempft-vordergrund', + // Gespiegeltes gehört sichtbar in eine eigene + // Klasse: gestreift, damit niemand darin einen + // Termin mit fehlendem Betreff vermutet. + eintrag.gespiegelt && + 'border-rand border border-dashed bg-[repeating-linear-gradient(45deg,transparent,transparent_4px,color-mix(in_oklch,currentColor_12%,transparent)_4px,color-mix(in_oklch,currentColor_12%,transparent)_8px)]', )} style={{ top: lage.oben, @@ -328,10 +335,16 @@ export function Wochenraster({ left: `${(spur / spuren) * 100}%`, width: `${100 / spuren}%`, }} - title={`${eintrag.betreff ?? 'Termin'} · ${eintrag.kalenderName}`} + title={ + eintrag.gespiegelt + ? 'Dienstlich belegt – gespiegelt aus der anderen Instanz' + : `${eintrag.betreff ?? 'Termin'} · ${eintrag.kalenderName}` + } > - {eintrag.betreff ?? 'Termin'} + {eintrag.gespiegelt + ? 'Dienstlich belegt' + : (eintrag.betreff ?? 'Termin')}
) diff --git a/src/server/abfragen/woche.ts b/src/server/abfragen/woche.ts index bbb7f0d..5493985 100644 --- a/src/server/abfragen/woche.ts +++ b/src/server/abfragen/woche.ts @@ -33,6 +33,13 @@ export type WochenTermin = { ganztaegig: boolean zeigtAls: ZeigtAls kalenderName: string + /** + * Kommt aus der anderen Instanz und trägt darum keinen Betreff. + * + * Für die Ansicht ist so eine Belegung ein fremder Termin wie jeder andere: + * Sie blockiert Zeit und lässt sich hier nicht verschieben. + */ + gespiegelt: boolean } export type WocheDaten = { @@ -55,7 +62,7 @@ export async function wocheLaden( ): Promise { const fenster = wochenFenster(zeitpunkt) - const [zeitbloecke, termine] = await Promise.all([ + const [zeitbloecke, termine, belegungen] = await Promise.all([ db.zeitblock.findMany({ where: { kalenderkonto: { benutzerId }, @@ -97,6 +104,11 @@ export async function wocheLaden( kalenderkonto: { select: { anzeigename: true } }, }, }), + db.spiegelbelegung.findMany({ + where: { beginn: { lt: fenster.bis }, ende: { gt: fenster.von } }, + orderBy: { beginn: 'asc' }, + select: { id: true, beginn: true, ende: true }, + }), ]) // Ein Zeitblock steht auch im Kalender und damit im Spiegel. Er würde sonst @@ -118,17 +130,31 @@ export async function wocheLaden( letzterFehler: z.letzterFehler, offen: z.extId === null, })), - termine: termine - .filter((t) => !eigeneExtIds.has(t.extId)) - .map((t) => ({ - id: t.id, - beginn: t.beginn, - ende: t.ende, - betreff: t.betreff, - ganztaegig: t.ganztaegig, - zeigtAls: t.zeigtAls, - kalenderName: t.kalenderkonto.anzeigename, + termine: [ + ...termine + .filter((t) => !eigeneExtIds.has(t.extId)) + .map((t) => ({ + id: t.id, + beginn: t.beginn, + ende: t.ende, + betreff: t.betreff, + ganztaegig: t.ganztaegig, + zeigtAls: t.zeigtAls, + kalenderName: t.kalenderkonto.anzeigename, + gespiegelt: false, + })), + ...belegungen.map((b) => ({ + id: b.id, + beginn: b.beginn, + ende: b.ende, + // Kein Betreff: Die andere Instanz schickt bewusst keinen. + betreff: null, + ganztaegig: false, + zeigtAls: 'GEBUCHT' as const, + kalenderName: 'Dienstlich', + gespiegelt: true, })), + ].sort((a, b) => a.beginn.getTime() - b.beginn.getTime()), } } From 4da2f3d9c6a92ed620948f0e3eac1fcd32aa7b68 Mon Sep 17 00:00:00 2001 From: Florian Wilde Date: Fri, 11 Sep 2026 23:58:43 +0200 Subject: [PATCH 07/14] test: Spiegel-Eingang und Integrationstabellen absichern MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Der Eingang des Spiegels ist die einzige Tuer, die ohne Anmeldung aufgeht. Vier Faelle: ohne Signatur, falsch signiert, zu alt, und der gute Fall — bei dem eine nicht mehr geschickte Belegung auch hier verschwinden muss. Der Testserver bekommt dafuer dasselbe Geheimnis wie der Test. Eine Pruefung, die immer uebersprungen wird, prueft nichts. Co-Authored-By: Claude Opus 5 --- e2e/hilfe.ts | 10 +++ e2e/spiegel.spec.ts | 138 ++++++++++++++++++++++++++++++++++++ playwright.config.ts | 3 + scripts/integrationstest.ts | 83 ++++++++++++++++++++++ 4 files changed, 234 insertions(+) create mode 100644 e2e/spiegel.spec.ts diff --git a/e2e/hilfe.ts b/e2e/hilfe.ts index d5b601b..965a681 100644 --- a/e2e/hilfe.ts +++ b/e2e/hilfe.ts @@ -6,6 +6,16 @@ export const EMAIL = process.env.ADMIN_EMAIL ?? '' export const PASSWORT = process.env.ADMIN_PASSWORT ?? '' export const VERBINDUNG = process.env.DATABASE_URL ?? '' +/** + * Geheimnis fuer den Spiegel im Test. + * + * Der Testserver bekommt denselben Wert ueber playwright.config.ts, sonst + * liesse sich die Tuer gar nicht pruefen — und eine Pruefung, die immer + * uebersprungen wird, prueft nichts. + */ +export const SPIEGEL_GEHEIMNIS = + process.env.SPIEGEL_GEHEIMNIS ?? 'e2e-spiegel-geheimnis-nur-lokal' + /** * Meldet das Testkonto mit Passwort an. * diff --git a/e2e/spiegel.spec.ts b/e2e/spiegel.spec.ts new file mode 100644 index 0000000..c000580 --- /dev/null +++ b/e2e/spiegel.spec.ts @@ -0,0 +1,138 @@ +import { createHmac } from 'node:crypto' +import { PrismaPg } from '@prisma/adapter-pg' +import { expect, test } from '@playwright/test' +import { PrismaClient } from '../src/generated/prisma/client.js' +import { SPIEGEL_GEHEIMNIS, VERBINDUNG } from './hilfe' + +/** + * Der Eingang des Spiegels. + * + * Hier meldet sich kein Mensch an — die Gegenstelle weist sich allein über + * eine Signatur aus. Deshalb wird hier nicht die Oberfläche geprüft, sondern + * genau diese Tür: Sie muss zu sein, wenn irgendetwas nicht stimmt. + */ + +const GEHEIMNIS = SPIEGEL_GEHEIMNIS +const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: VERBINDUNG }) }) + +const PRAEFIX = `E2E-S-${Date.now()}` + +function signieren(koerper: string, geheimnis = GEHEIMNIS): string { + return createHmac('sha256', geheimnis).update(koerper).digest('hex') +} + +function sendung(teile: Record = {}): string { + return JSON.stringify({ + gesendetAm: new Date().toISOString(), + belegungen: [], + aufgaben: [], + ...teile, + }) +} + +test.describe('Spiegel', () => { + test.afterAll(async () => { + await db.spiegelbelegung.deleteMany({ where: { quelleRef: { startsWith: PRAEFIX } } }) + await db.aufgabe.deleteMany({ where: { quelleRef: { startsWith: PRAEFIX } } }) + await db.auditEintrag.deleteMany({ where: { aktion: 'spiegel.empfangen' } }) + await db.$disconnect() + }) + + test('weist eine Sendung ohne Signatur ab', async ({ request }) => { + const antwort = await request.post('/api/spiegel', { + headers: { 'Content-Type': 'application/json' }, + data: sendung(), + }) + expect(antwort.status()).toBe(401) + }) + + test('weist eine falsch signierte Sendung ab', async ({ request }) => { + const koerper = sendung() + const antwort = await request.post('/api/spiegel', { + headers: { + 'Content-Type': 'application/json', + 'X-Planer-Signatur': signieren(koerper, 'das-ist-nicht-das-geheimnis'), + }, + data: koerper, + }) + expect(antwort.status()).toBe(401) + }) + + test('weist eine Sendung ab, die zu lange unterwegs war', async ({ request }) => { + test.skip(!GEHEIMNIS, 'Ohne SPIEGEL_GEHEIMNIS ist der Eingang ohnehin zu.') + + // Eine Stunde alt: richtig signiert, trotzdem wertlos. Sonst ließe sich + // ein abgefangenes Paket beliebig oft erneut einspielen. + const koerper = sendung({ + gesendetAm: new Date(Date.now() - 3_600_000).toISOString(), + }) + const antwort = await request.post('/api/spiegel', { + headers: { + 'Content-Type': 'application/json', + 'X-Planer-Signatur': signieren(koerper), + }, + data: koerper, + }) + expect(antwort.status()).toBe(401) + }) + + test('nimmt eine gültige Sendung an und räumt Veraltetes weg', async ({ request }) => { + test.skip( + !GEHEIMNIS, + 'Ohne SPIEGEL_GEHEIMNIS auf dem Testserver lässt sich das nicht prüfen.', + ) + + const beginn = new Date(Date.now() + 86_400_000) + const ende = new Date(beginn.getTime() + 3_600_000) + + const erste = sendung({ + belegungen: [ + { + ref: `${PRAEFIX}-a`, + beginn: beginn.toISOString(), + ende: ende.toISOString(), + }, + ], + aufgaben: [{ ref: `${PRAEFIX}-1`, titel: `${PRAEFIX} Angebot schreiben` }], + }) + + const antwort = await request.post('/api/spiegel', { + headers: { + 'Content-Type': 'application/json', + 'X-Planer-Signatur': signieren(erste), + }, + data: erste, + }) + expect(antwort.ok()).toBe(true) + + expect(await db.spiegelbelegung.count({ where: { quelleRef: `${PRAEFIX}-a` } })).toBe( + 1, + ) + const aufgabe = await db.aufgabe.findFirst({ + where: { quelle: 'SPIEGEL', quelleRef: `${PRAEFIX}-1` }, + select: { titel: true }, + }) + expect(aufgabe?.titel).toBe(`${PRAEFIX} Angebot schreiben`) + + // Zweite Runde ohne die Belegung: Sie wurde drüben ausgeplant und muss + // auch hier verschwinden — sonst stünde für immer eine Sperre, die es + // längst nicht mehr gibt. + const zweite = sendung({ aufgaben: [] }) + const nachher = await request.post('/api/spiegel', { + headers: { + 'Content-Type': 'application/json', + 'X-Planer-Signatur': signieren(zweite), + }, + data: zweite, + }) + expect(nachher.ok()).toBe(true) + expect(await db.spiegelbelegung.count({ where: { quelleRef: `${PRAEFIX}-a` } })).toBe( + 0, + ) + + // Die Aufgabe bleibt: Sie ist Planung, keine Sperre. + expect( + await db.aufgabe.count({ where: { quelle: 'SPIEGEL', quelleRef: `${PRAEFIX}-1` } }), + ).toBe(1) + }) +}) diff --git a/playwright.config.ts b/playwright.config.ts index e7de6a3..6cf733a 100644 --- a/playwright.config.ts +++ b/playwright.config.ts @@ -1,5 +1,6 @@ import { defineConfig, devices } from '@playwright/test' import 'dotenv/config' +import { SPIEGEL_GEHEIMNIS } from './e2e/hilfe' const PORT = Number(process.env.E2E_PORT ?? 3100) const BASIS = `http://127.0.0.1:${PORT}` @@ -41,6 +42,8 @@ export default defineConfig({ APP_URL: BASIS, WEBAUTHN_ORIGIN: BASIS, WEBAUTHN_RP_ID: '127.0.0.1', + // Ohne Geheimnis waere der Spiegel-Eingang zu und sein Test sinnlos. + SPIEGEL_GEHEIMNIS, }, }, }) diff --git a/scripts/integrationstest.ts b/scripts/integrationstest.ts index 58b4cd6..889f400 100644 --- a/scripts/integrationstest.ts +++ b/scripts/integrationstest.ts @@ -41,6 +41,9 @@ async function scheitert(name: string, tun: () => Promise): Promise { @@ -58,6 +61,12 @@ async function aufraeumen(): Promise { await db.webauthnChallenge.deleteMany({ where: { kennung } }) await db.pushGeraet.deleteMany({ where: { endpunkt: { contains: kennung } } }) await db.meldungsnachweis.deleteMany({ where: { schluessel: { contains: kennung } } }) + await db.spiegelbelegung.deleteMany({ where: { quelleRef: { contains: kennung } } }) + await db.telegramKopplung.deleteMany({ + where: { code: { contains: kennung.slice(-8) } }, + }) + await db.telegramChat.deleteMany({ where: { chatId: testChatId } }) + await db.integrationszustand.deleteMany({ where: { quelle: 'TELEGRAM' } }) } async function main(): Promise { @@ -316,6 +325,76 @@ async function main(): Promise { ).id.length > 0, ) + // --- Integrationen ------------------------------------------------------- + // Der Zustand haengt an der Quelle: eine Zeile je Integration, nicht mehr. + await db.integrationszustand.create({ + data: { quelle: 'TELEGRAM', merker: '42' }, + }) + await scheitert('Je Quelle nur ein Integrationszustand', () => + db.integrationszustand.create({ data: { quelle: 'TELEGRAM' } }), + ) + await db.integrationszustand.deleteMany({ where: { quelle: 'TELEGRAM' } }) + + // Zwei Aufgaben aus derselben Quelle mit derselben Kennung darf es nicht + // geben – sonst legte jeder Lauf dieselbe Sache erneut an. + const ausZammad = await db.aufgabe.create({ + data: { titel: `${kennung}-ticket`, quelle: 'ZAMMAD', quelleRef: `${kennung}-1` }, + }) + pruefe('Aufgabe aus einer Integration anlegen', ausZammad.id.length > 0) + pruefe('Ohne Freigabe wird nicht gespiegelt', ausZammad.spiegeln === false) + + await scheitert('Dieselbe Quelle mit derselben Kennung nur einmal (Integration)', () => + db.aufgabe.create({ + data: { + titel: `${kennung}-ticket-doppelt`, + quelle: 'ZAMMAD', + quelleRef: `${kennung}-1`, + }, + }), + ) + + await db.spiegelbelegung.create({ + data: { + quelleRef: `${kennung}-zb`, + beginn: new Date(Date.UTC(2026, 2, 17, 8, 0)), + ende: new Date(Date.UTC(2026, 2, 17, 9, 0)), + }, + }) + await scheitert('Dieselbe gespiegelte Belegung nur einmal', () => + db.spiegelbelegung.create({ + data: { + quelleRef: `${kennung}-zb`, + beginn: new Date(Date.UTC(2026, 2, 18, 8, 0)), + ende: new Date(Date.UTC(2026, 2, 18, 9, 0)), + }, + }), + ) + + const chat = await db.telegramChat.create({ + data: { chatId: testChatId, benutzerId: benutzer.id }, + }) + pruefe('Telegram-Chat empfaengt im Zweifel Meldungen', chat.meldungen === true) + await scheitert('Dieselbe Chatkennung nur einmal', () => + db.telegramChat.create({ data: { chatId: chat.chatId } }), + ) + + await db.telegramKopplung.create({ + data: { + code: `${kennung.slice(-8)}`, + benutzerId: benutzer.id, + gueltigBis: new Date(Date.now() + 600_000), + }, + }) + await scheitert('Denselben Kopplungscode nur einmal', () => + db.telegramKopplung.create({ + data: { + code: `${kennung.slice(-8)}`, + benutzerId: benutzer.id, + gueltigBis: new Date(Date.now() + 600_000), + }, + }), + ) + await db.benutzer.delete({ where: { id: benutzer.id } }) const nachher = await db.auditEintrag.findUnique({ where: { id: audit.id } }) @@ -341,6 +420,10 @@ async function main(): Promise { 'Push-Geräte verschwinden mit dem Benutzer', (await db.pushGeraet.count({ where: { endpunkt: { contains: kennung } } })) === 0, ) + pruefe( + 'Telegram-Chats verschwinden nicht, verlieren aber den Benutzer', + (await db.telegramChat.count({ where: { benutzerId: benutzer.id } })) === 0, + ) pruefe( 'Meldungsnachweise verschwinden mit dem Benutzer', (await db.meldungsnachweis.count({ From 3befcc19a35d535311d0b1f7aa249b2587138460 Mon Sep 17 00:00:00 2001 From: Florian Wilde Date: Fri, 11 Sep 2026 23:58:46 +0200 Subject: [PATCH 08/14] feat: Aufgaben einzeln zum Spiegeln freigeben Der Schalter erscheint nur, wo auch gespiegelt wird. Co-Authored-By: Claude Opus 5 --- src/app/(app)/aufgaben/page.tsx | 4 ++++ src/lib/aufgabe-anzeige.test.ts | 1 + src/lib/aufgabe-anzeige.ts | 4 ++++ src/server/abfragen/aufgaben.ts | 1 + 4 files changed, 10 insertions(+) diff --git a/src/app/(app)/aufgaben/page.tsx b/src/app/(app)/aufgaben/page.tsx index ee47777..d46ec4a 100644 --- a/src/app/(app)/aufgaben/page.tsx +++ b/src/app/(app)/aufgaben/page.tsx @@ -14,6 +14,7 @@ import { type AufgabenFilter, } from '@/server/abfragen/aufgaben' import { verlangeAnmeldung } from '@/server/berechtigung' +import { umgebung } from '@/server/umgebung' export const metadata: Metadata = { title: 'Aufgaben' } @@ -67,6 +68,7 @@ export default async function AufgabenSeite({ searchParams: Promise> }) { await verlangeAnmeldung('/aufgaben') + const spiegelt = umgebung().spiegelSendenAktiv const parameter = await searchParams const [aufgaben, bereiche, projekte] = await Promise.all([ @@ -101,11 +103,13 @@ export default async function AufgabenSeite({ + {/* Nur wo auch gespiegelt wird, hat der Schalter einen Sinn. */} ) diff --git a/src/lib/aufgabe-anzeige.test.ts b/src/lib/aufgabe-anzeige.test.ts index 2d78313..69d7774 100644 --- a/src/lib/aufgabe-anzeige.test.ts +++ b/src/lib/aufgabe-anzeige.test.ts @@ -16,6 +16,7 @@ function roh(teil: Partial = {}): AufgabeRoh { faelligAm: null, quelle: 'MANUELL', quelleUrl: null, + spiegeln: false, bereich: null, projekt: null, ...teil, diff --git a/src/lib/aufgabe-anzeige.ts b/src/lib/aufgabe-anzeige.ts index 2403aa7..b5aeffa 100644 --- a/src/lib/aufgabe-anzeige.ts +++ b/src/lib/aufgabe-anzeige.ts @@ -26,6 +26,7 @@ export type AufgabeRoh = { faelligAm: Date | null quelle: Quelle quelleUrl: string | null + spiegeln: boolean bereich: { id: string; name: string; farbe: string } | null projekt: { id: string; name: string } | null } @@ -48,6 +49,8 @@ export type AufgabeAnzeige = { ueberfaellig: boolean quelle: Quelle quelleUrl: string | null + /** Ausdruecklich zum Spiegeln freigegeben. */ + spiegeln: boolean bereich: { id: string; name: string; farbe: string } | null projekt: { id: string; name: string } | null } @@ -79,6 +82,7 @@ export function fuerAnzeige(aufgabe: AufgabeRoh, jetzt: Date): AufgabeAnzeige { ueberfaellig: istUeberfaellig(aufgabe.faelligAm, aufgabe.status, jetzt), quelle: aufgabe.quelle, quelleUrl: aufgabe.quelleUrl, + spiegeln: aufgabe.spiegeln, bereich: aufgabe.bereich, projekt: aufgabe.projekt, } diff --git a/src/server/abfragen/aufgaben.ts b/src/server/abfragen/aufgaben.ts index 8e0a43c..98a0195 100644 --- a/src/server/abfragen/aufgaben.ts +++ b/src/server/abfragen/aufgaben.ts @@ -25,6 +25,7 @@ const AUSWAHL = { faelligAm: true, quelle: true, quelleUrl: true, + spiegeln: true, bereich: { select: { id: true, name: true, farbe: true } }, projekt: { select: { id: true, name: true } }, } satisfies Prisma.AufgabeSelect From f5eadefdbb88e7b6644889d41d7338e6abd9ef8c Mon Sep 17 00:00:00 2001 From: Florian Wilde Date: Fri, 11 Sep 2026 23:59:14 +0200 Subject: [PATCH 09/14] feat: Lauf von Hand anstossen und Spiegelschalter in der Liste Direkt nach dem Einrichten wuesste man sonst erst beim naechsten Takt, ob die Zugangsdaten stimmen. Co-Authored-By: Claude Opus 5 --- src/app/(app)/integrationen/lauf-knopf.tsx | 46 ++++++++++++++++++++++ src/app/(app)/integrationen/page.tsx | 13 ++++++ src/components/aufgaben/aufgaben-liste.tsx | 4 ++ src/components/aufgaben/aufgaben-zeile.tsx | 37 ++++++++++++++++- 4 files changed, 99 insertions(+), 1 deletion(-) create mode 100644 src/app/(app)/integrationen/lauf-knopf.tsx diff --git a/src/app/(app)/integrationen/lauf-knopf.tsx b/src/app/(app)/integrationen/lauf-knopf.tsx new file mode 100644 index 0000000..35198af --- /dev/null +++ b/src/app/(app)/integrationen/lauf-knopf.tsx @@ -0,0 +1,46 @@ +'use client' + +import { useTransition } from 'react' +import { useRouter } from 'next/navigation' +import { Loader2, RefreshCw } from 'lucide-react' +import { toast } from 'sonner' +import { Button } from '@/components/ui/button' +import { laufAnstossen } from '@/server/aktionen/integrationen' + +/** + * Stößt einen Lauf von Hand an. + * + * Vor allem direkt nach dem Einrichten: Sonst wüsste man erst beim nächsten + * Takt, ob die Zugangsdaten stimmen. + */ +export function LaufKnopf({ quelle }: { quelle: string }) { + const router = useRouter() + const [laeuft, starte] = useTransition() + + return ( + + ) +} diff --git a/src/app/(app)/integrationen/page.tsx b/src/app/(app)/integrationen/page.tsx index 079483d..c768703 100644 --- a/src/app/(app)/integrationen/page.tsx +++ b/src/app/(app)/integrationen/page.tsx @@ -1,5 +1,6 @@ import type { Metadata } from 'next' import { Plug } from 'lucide-react' +import { LaufKnopf } from '@/app/(app)/integrationen/lauf-knopf' import { TelegramChats } from '@/app/(app)/integrationen/telegram-chats' import { Card, @@ -27,6 +28,8 @@ type Zeile = { /** Und auch eingerichtet? */ aktiv: boolean hinweis: string + /** Laesst sich der Lauf von Hand anstossen? Der Empfaenger wartet nur. */ + abrufbar?: boolean } export default async function IntegrationenSeite() { @@ -59,6 +62,7 @@ export default async function IntegrationenSeite() { vorgesehen: einst.instanz === 'firma', aktiv: einst.zammadAktiv, hinweis: 'ZAMMAD_URL und ZAMMAD_TOKEN fehlen.', + abrufbar: einst.zammadAktiv, }, { quelle: 'WARTUNGSPLANER', @@ -77,6 +81,7 @@ export default async function IntegrationenSeite() { vorgesehen: einst.instanz === 'daheim', aktiv: einst.telegramAktiv, hinweis: 'TELEGRAM_TOKEN fehlt.', + abrufbar: einst.telegramAktiv, }, { quelle: 'SPIEGEL', @@ -88,6 +93,8 @@ export default async function IntegrationenSeite() { vorgesehen: true, aktiv: einst.spiegelSendenAktiv || einst.spiegelEmpfangenAktiv, hinweis: 'SPIEGEL_GEHEIMNIS fehlt.', + // Die empfangende Seite ruft nichts ab – sie wartet. + abrufbar: einst.spiegelSendenAktiv, }, ] @@ -141,6 +148,12 @@ export default async function IntegrationenSeite() {

)} {!zustand && zeile.aktiv &&

Noch kein Lauf.

} + + {zeile.abrufbar && ( +
+ +
+ )} ) diff --git a/src/components/aufgaben/aufgaben-liste.tsx b/src/components/aufgaben/aufgaben-liste.tsx index 4e3dfac..29784d4 100644 --- a/src/components/aufgaben/aufgaben-liste.tsx +++ b/src/components/aufgaben/aufgaben-liste.tsx @@ -14,6 +14,8 @@ type Eigenschaften = { leerText: string mitEinsortieren?: boolean mitUebernehmen?: boolean + /** Schalter zum Spiegeln zeigen; nur auf der sendenden Instanz sinnvoll. */ + mitSpiegeln?: boolean /** Bearbeiten direkt in der Liste erlauben. */ mitBearbeiten?: boolean } @@ -25,6 +27,7 @@ export function AufgabenListe({ leerText, mitEinsortieren = false, mitUebernehmen = false, + mitSpiegeln = false, mitBearbeiten = true, }: Eigenschaften) { const [bearbeitet, setBearbeitet] = useState(null) @@ -60,6 +63,7 @@ export function AufgabenListe({ bereiche={bereiche} mitEinsortieren={mitEinsortieren} mitUebernehmen={mitUebernehmen} + mitSpiegeln={mitSpiegeln} {...(mitBearbeiten ? { onBearbeiten: () => setBearbeitet(aufgabe.id) } : {})} diff --git a/src/components/aufgaben/aufgaben-zeile.tsx b/src/components/aufgaben/aufgaben-zeile.tsx index 73476a1..752adac 100644 --- a/src/components/aufgaben/aufgaben-zeile.tsx +++ b/src/components/aufgaben/aufgaben-zeile.tsx @@ -3,7 +3,15 @@ import { useState, useTransition } from 'react' import { useRouter } from 'next/navigation' import Link from 'next/link' -import { Check, ExternalLink, Loader2, Pencil, RotateCcw, Trash2 } from 'lucide-react' +import { + Check, + ExternalLink, + Loader2, + Pencil, + RotateCcw, + Share2, + Trash2, +} from 'lucide-react' import { toast } from 'sonner' import { Button } from '@/components/ui/button' import { Kennzeichen } from '@/components/ui/kennzeichen' @@ -22,6 +30,7 @@ import { aufgabeLoeschen, einsortieren, ideeUebernehmen, + spiegelnUmschalten, statusSetzen, type Rueckmeldung, } from '@/server/aktionen/aufgaben' @@ -36,6 +45,8 @@ type Eigenschaften = { mitEinsortieren?: boolean /** Zeigt den Knopf "Zur Aufgabe machen" (Ideen). */ mitUebernehmen?: boolean + /** Zeigt den Schalter zum Spiegeln; nur auf der sendenden Instanz. */ + mitSpiegeln?: boolean onBearbeiten?: (aufgabe: AufgabeAnzeige) => void } @@ -44,6 +55,7 @@ export function AufgabenZeile({ bereiche = [], mitEinsortieren = false, mitUebernehmen = false, + mitSpiegeln = false, onBearbeiten, }: Eigenschaften) { const router = useRouter() @@ -198,6 +210,29 @@ export function AufgabenZeile({
+ {mitSpiegeln && ( + + )} {onBearbeiten && (