Merge: Meilenstein 6 – Integrationen (0.6.0)
Aufgaben entstehen jetzt auch dort, wo sie anfallen: Zammad-Tickets werden zu Aufgaben, eine Telegram-Nachricht wird zur Aufgabe, und der Spiegel bringt dienstliche Belegung nach Hause — ohne Titel. Ueber allem steht eine Regel: Das fremde System fuehrt Titel, Notiz, Verweis und Faelligkeit. Bereich, Projekt, Prioritaet und geschaetzter Aufwand gehoeren der Planung und werden nie von aussen ueberschrieben. Ohne diese Trennung waere die Wochenplanung nach jedem Lauf kaputt. Der Wartungsplaner ist bewusst nicht angebunden: Die Schnittstelle steht noch nicht fest. Die Aufnahmestelle ist vorbereitet, und die Seite "Integrationen" fuehrt ihn als sichtbare Luecke statt als Leerstelle. Geprueft vor dem Merge: npm run pruefen mit 301 Unit-Tests, 56 Integrationspruefungen, Migrationstest und 23 E2E-Tests. Der Spiegel ist end-to-end geprueft, weil beide Enden dieselbe Anwendung sind; Zammad und Telegram nur gegen die Logik — dafuer fehlen Zugangsdaten. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Florian Wilde
Claude Opus 5
@@ -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
|
||||
|
||||
@@ -6,6 +6,49 @@ die Versionierung [Semantic Versioning](https://semver.org/lang/de/).
|
||||
|
||||
## [Unveröffentlicht]
|
||||
|
||||
## [0.6.0] – 2026-09-12
|
||||
|
||||
### Hinzugefügt
|
||||
|
||||
- **Zammad** (nur `firma`): Tickets, auf die der Suchausdruck passt, werden zu
|
||||
Aufgaben — mit Verweis ins Ticket. Wird ein Ticket dort geschlossen, hakt
|
||||
der Planer die Aufgabe ab.
|
||||
- **Telegram** (nur `daheim`): Eine Nachricht an den Bot wird zur Aufgabe.
|
||||
Meldungen gehen denselben Weg zurück, mit einem Knopf zum Abhaken. Ein Chat
|
||||
meldet sich über einen Einmalcode an, der zehn Minuten gilt.
|
||||
- **Telegram als dritter Meldeweg** neben Push und E-Mail.
|
||||
- **Spiegel** zwischen den Instanzen: `firma` schickt Belegungen ohne Titel
|
||||
und die einzeln dafür markierten Aufgaben, `daheim` empfängt. Gespiegelte
|
||||
Belegung erscheint in der Wochenansicht als „Dienstlich belegt" und zählt
|
||||
gegen die Tageskapazität.
|
||||
- Seite **Integrationen**: je Integration Zustand, letzter Erfolg, letzter
|
||||
Fehler und ein Knopf, der einen Lauf sofort anstößt.
|
||||
- Handbuchseite zu den Integrationen.
|
||||
|
||||
### Geändert
|
||||
|
||||
- Was aus einem Fund wird, entscheidet für alle Integrationen dieselbe
|
||||
Stelle. Geführt werden nur Titel, Notiz, Verweis und Fälligkeit — Bereich,
|
||||
Projekt, Priorität und geschätzter Aufwand gehören der Planung und werden
|
||||
nie von außen überschrieben.
|
||||
- Eine klemmende Integration meldet sich wie ein klemmender Kalender: erst
|
||||
nach dem dritten Fehlversuch in Folge.
|
||||
- Die Demo-Instanz für die Bilder spricht nicht mehr nach außen.
|
||||
|
||||
### Sicherheit
|
||||
|
||||
- Wer dem Telegram-Bot schreibt, ohne verbunden zu sein, bekommt **keine
|
||||
Antwort** — auch keine Fehlermeldung. Sonst ließe sich herausfinden, dass
|
||||
es diesen Planer gibt.
|
||||
- Jede Sendung des Spiegels trägt eine Signatur über den Rumpf und ist nach
|
||||
fünf Minuten wertlos. Der Empfänger antwortet auf jeden Fehlschlag gleich:
|
||||
falsches Geheimnis, verstellte Uhr und Unsinn im Inhalt sind von außen
|
||||
nicht zu unterscheiden.
|
||||
- Der Signaturvergleich läuft in gleichbleibender Zeit.
|
||||
- Aufgaben verlassen die Instanz nur mit ausdrücklicher Freigabe je Aufgabe.
|
||||
Ein Schalter für einen ganzen Bereich würde zu leicht Kundennamen nach
|
||||
Hause schicken.
|
||||
|
||||
## [0.5.0] – 2026-09-11
|
||||
|
||||
### Hinzugefügt
|
||||
|
||||
@@ -33,8 +33,12 @@ wird.
|
||||
Bereich, wie voll der heutige Tag schon ist
|
||||
- **Wochenplanung** per Ziehen und Ablegen: Aufgaben werden zu echten
|
||||
Kalenderterminen, Verschiebungen im Kalender kommen zurück
|
||||
- **Benachrichtigungen** per Web-Push und E-Mail: Tagesüberblick, fällige
|
||||
Aufgaben, Vorlauf vor einem Zeitblock — mit Ruhezeiten und ab Werk still
|
||||
- **Benachrichtigungen** per Web-Push, E-Mail und Telegram: Tagesüberblick,
|
||||
fällige Aufgaben, Vorlauf vor einem Zeitblock — mit Ruhezeiten und ab Werk
|
||||
still
|
||||
- **Integrationen**: Zammad-Tickets werden zu Aufgaben, Telegram erfasst und
|
||||
hakt ab, und der Spiegel bringt dienstliche Belegung nach Hause — ohne
|
||||
Titel
|
||||
- Anmeldung über einen OIDC-Anbieter, über Passkeys oder mit E-Mail und
|
||||
Passwort — je Instanz einzeln zuschaltbar
|
||||
- Rollen `Benutzer` und `Verwaltung`; jede schreibende Aktion wird
|
||||
@@ -45,7 +49,7 @@ wird.
|
||||
|
||||
### Geplant
|
||||
|
||||
Integrationen, Schnellerfassung vom Handy und ein MCP-Server.
|
||||
Schnellerfassung vom Handy, eine öffentliche API und ein MCP-Server.
|
||||
Siehe [ROADMAP.md](ROADMAP.md).
|
||||
|
||||
## Bildergalerie
|
||||
@@ -63,6 +67,7 @@ Siehe [ROADMAP.md](ROADMAP.md).
|
||||
| Bereiche |  |  |
|
||||
| Einstellungen |  |  |
|
||||
| Meldungen |  |  |
|
||||
| Integrationen |  |  |
|
||||
| Protokoll |  |  |
|
||||
|
||||
Alle Bilder entstehen mit `npm run screenshots` in einer Wegwerf-Instanz mit
|
||||
@@ -171,6 +176,44 @@ Klartextadresse nicht.
|
||||
Was der Planer wann meldet, steht im
|
||||
[Handbuch](docs/handbuch/benachrichtigungen.md).
|
||||
|
||||
### Integrationen
|
||||
|
||||
Welche Integration eine Instanz überhaupt darf, entscheidet `INSTANZ` — nicht
|
||||
die Konfiguration. Ein Zammad-Token in der Instanz `daheim` bleibt wirkungslos.
|
||||
|
||||
| Variable | Standard | Bedeutung |
|
||||
| ------------------- | ------------------- | ---------------------------------------------------------------- |
|
||||
| `ZAMMAD_URL` | _(leer)_ | Adresse der Zammad-Instanz, nur `firma` |
|
||||
| `ZAMMAD_TOKEN` | _(leer)_ | Token aus **Profil → Token-Zugriff** |
|
||||
| `ZAMMAD_ABFRAGE` | `owner_id:me AND …` | Suchausdruck; was darauf passt, wird zur Aufgabe |
|
||||
| `TELEGRAM_TOKEN` | _(leer)_ | Bot-Token von [@BotFather](https://t.me/BotFather), nur `daheim` |
|
||||
| `SPIEGEL_GEHEIMNIS` | _(leer)_ | Gemeinsames Geheimnis beider Instanzen |
|
||||
| `SPIEGEL_ZIEL` | _(leer)_ | Adresse der empfangenden Instanz; nur auf der sendenden Seite |
|
||||
|
||||
**Zammad** liest nur. Ein Ticket schließt man im Ticketsystem — sonst weiß die
|
||||
Kollegin nicht, warum es plötzlich zu ist. Umgekehrt schließt der Planer eine
|
||||
Aufgabe, sobald Zammad das Ticket als erledigt meldet.
|
||||
|
||||
**Telegram** braucht keinen Webhook und damit keine von außen erreichbare
|
||||
Adresse. Welche Chats mitreden dürfen, wird in der Anwendung unter
|
||||
**Integrationen** gekoppelt: Knopf drücken, Code an den Bot schicken, fertig.
|
||||
Nachrichten aus unbekannten Chats werden verworfen, ohne zu antworten.
|
||||
|
||||
**Der Spiegel** geht in eine Richtung: `firma` sendet, `daheim` empfängt.
|
||||
Hinüber gehen Belegungen **ohne Titel** — daheim ist zu sehen, _dass_ die Zeit
|
||||
weg ist, nicht woran gearbeitet wird — und jene Aufgaben, die einzeln zum
|
||||
Spiegeln markiert wurden. Jede Sendung ist mit dem gemeinsamen Geheimnis
|
||||
signiert und älter als fünf Minuten wertlos.
|
||||
|
||||
Das Geheimnis erzeugst du wie das Sitzungsgeheimnis:
|
||||
|
||||
```bash
|
||||
openssl rand -base64 32
|
||||
```
|
||||
|
||||
Was der Alltag damit anfängt, steht im
|
||||
[Handbuch](docs/handbuch/integrationen.md).
|
||||
|
||||
### Einrichtung und Sonstiges
|
||||
|
||||
| Variable | Standard | Bedeutung |
|
||||
|
||||
+20
-5
@@ -10,7 +10,7 @@ grünen Prüfungen, aktueller Dokumentation und einem Eintrag im DEVLOG.
|
||||
| [M3](#m3--kalender-lesen) | Kalender lesen | erledigt |
|
||||
| [M4](#m4--wochenplanung-und-zeitblöcke) | Wochenplanung und Zeitblöcke | erledigt |
|
||||
| [M5](#m5--benachrichtigungen) | Benachrichtigungen | erledigt |
|
||||
| [M6](#m6--integrationen) | Integrationen | geplant |
|
||||
| [M6](#m6--integrationen) | Integrationen | erledigt |
|
||||
| [M7](#m7--schnellerfassung-und-api) | Schnellerfassung und API | geplant |
|
||||
| [M8](#m8--mcp) | MCP | geplant |
|
||||
|
||||
@@ -112,10 +112,25 @@ Erinnerung an einen Zeitblock, der längst begonnen hat, hilft niemandem.
|
||||
|
||||
## M6 – Integrationen
|
||||
|
||||
- [ ] Zammad und Wartungsplaner-API (nur `firma`)
|
||||
- [ ] Telegram (nur `daheim`)
|
||||
- [ ] Spiegel: `firma` sendet, `daheim` empfängt
|
||||
- [ ] Jede Integration upsertet über `[quelle, quelleRef]`
|
||||
**Erledigt am 12.09.2026 mit Version 0.6.0.**
|
||||
|
||||
**Ziel:** Aufgaben dort abholen, wo sie entstehen — ohne dass die Planung
|
||||
darunter leidet, die hier passiert.
|
||||
|
||||
- [x] Gemeinsame Aufnahmestelle: jede Integration liefert nur Funde
|
||||
- [x] Zammad (nur `firma`), lesend
|
||||
- [ ] **Wartungsplaner-API** — Schnittstelle steht noch nicht fest
|
||||
- [x] Telegram (nur `daheim`): erfassen, melden, abhaken
|
||||
- [x] Spiegel: `firma` sendet, `daheim` empfängt
|
||||
- [x] Jede Integration upsertet über `[quelle, quelleRef]`
|
||||
|
||||
**Offen geblieben:** Der **Wartungsplaner** ist nicht angebunden. Die
|
||||
Aufnahmestelle steht bereit und die Seite „Integrationen" führt ihn als
|
||||
sichtbare Lücke; es fehlt allein das Abholen, und dafür muss erst feststehen,
|
||||
was das Produkt an Schnittstelle hergibt.
|
||||
|
||||
**Bewusst offen gelassen:** Zammad wird nur gelesen. Ein Ticket schließt man
|
||||
im Ticketsystem — sonst weiß die Kollegin nicht, warum es plötzlich zu ist.
|
||||
|
||||
## M7 – Schnellerfassung und API
|
||||
|
||||
|
||||
+116
-8
@@ -5,14 +5,122 @@ die Übersicht aus `scripts/zeit.sh summe`.
|
||||
|
||||
## Zeit je Meilenstein
|
||||
|
||||
| Meilenstein | Art | Minuten | Stunden |
|
||||
| ----------- | ------ | ------- | --------- |
|
||||
| M1 | claude | 161 | 2,68 |
|
||||
| M2 | claude | 44 | 0,73 |
|
||||
| M3 | claude | 41 | 0,68 |
|
||||
| M4 | claude | 167 | 2,78 |
|
||||
| M5 | claude | 420 | 7,00 |
|
||||
| **Gesamt** | | **833** | **13,88** |
|
||||
| Meilenstein | Art | Minuten | Stunden |
|
||||
| ----------- | ------ | -------- | --------- |
|
||||
| M1 | claude | 161 | 2,68 |
|
||||
| M2 | claude | 44 | 0,73 |
|
||||
| M3 | claude | 41 | 0,68 |
|
||||
| M4 | claude | 167 | 2,78 |
|
||||
| M5 | claude | 420 | 7,00 |
|
||||
| M6 | claude | 733 | 12,22 |
|
||||
| **Gesamt** | | **1566** | **26,10** |
|
||||
|
||||
---
|
||||
|
||||
## 2026-09-12 – M6: Integrationen
|
||||
|
||||
**Dauer:** 733 Minuten (20:47–09:00), Art `claude`.
|
||||
|
||||
> Die Zahl täuscht. Ein großer Teil davon war Warten auf Docker-Bauten, die
|
||||
> in der Nacht dreimal hängen blieben — einmal 39 Minuten ohne eine Zeile
|
||||
> Ausgabe. Die eigentliche Arbeit war knapper.
|
||||
|
||||
**Ziel der Sitzung:** Aufgaben dort abholen, wo sie entstehen — ohne dass die
|
||||
Planung darunter leidet, die hier passiert.
|
||||
|
||||
### Erledigt
|
||||
|
||||
- Gemeinsame Aufnahmestelle für alle Integrationen (21 Tests)
|
||||
- Zammad, lesend, mit Suchausdruck aus der Konfiguration
|
||||
- Telegram: erfassen, melden, abhaken — mit Kopplung über Einmalcode
|
||||
- Spiegel zwischen den Instanzen: Belegung ohne Titel, Aufgaben nur markiert
|
||||
- Seite „Integrationen" mit Zustand, Fehler und Knopf für den Sofortlauf
|
||||
- Gespiegelte Belegung in der Wochenansicht
|
||||
- 4 neue E2E-Tests, 9 neue Integrationsprüfungen, Handbuchseite
|
||||
|
||||
### Entscheidungen mit Begründung
|
||||
|
||||
**Das Ursprungssystem führt Titel, Notiz, Verweis und Fälligkeit — mehr
|
||||
nicht.** Bereich, Projekt, Priorität und geschätzter Aufwand gehören der
|
||||
Planung. Wer ein Ticket einsortiert und schätzt, muss sich darauf verlassen
|
||||
können, dass der nächste Abgleich das nicht wegräumt. Ohne diese Trennung
|
||||
wäre die Wochenplanung nach jedem Lauf kaputt.
|
||||
|
||||
**Zammad wird nur gelesen.** Ein Ticket schließt man im Ticketsystem, sonst
|
||||
weiß die Kollegin nicht, warum es plötzlich zu ist. Umgekehrt darf Zammad
|
||||
hier abhaken — dort ist die Wahrheit über den Zustand des Tickets.
|
||||
|
||||
**Telegram holt ab, statt einen Webhook zu bekommen.** Ein Webhook verlangt
|
||||
eine von außen erreichbare Adresse mit gültigem Zertifikat. Der Planer soll
|
||||
auch hinter einem Anschluss ohne feste Adresse laufen, und der Preis dafür
|
||||
sind zwei Minuten Verzögerung.
|
||||
|
||||
**Unbekannte Chats bekommen keine Antwort — auch keine Fehlermeldung.** Wer
|
||||
die Kennung des Bots kennt, könnte ihm sonst schreiben und daran erkennen,
|
||||
dass es diesen Planer gibt. Die einzige Ausnahme ist ein gültiger
|
||||
Kopplungscode.
|
||||
|
||||
**Der Kopplungscode entstand aus einem Widerspruch.** Erst sollte die
|
||||
Chatkennung von Hand eingetragen werden. Nur: Um sie zu erfahren, müsste der
|
||||
Bot Unbekannten antworten — genau das, was er nicht darf. Der Code dreht die
|
||||
Richtung um: Er kommt aus der Anwendung, in die man sich anmelden muss.
|
||||
|
||||
**Der Spiegel schickt Belegung ohne Titel.** Daheim soll zu sehen sein,
|
||||
_dass_ die Zeit weg ist, nicht woran gearbeitet wird. Aufgaben gehen nur
|
||||
einzeln markiert mit — ein Schalter für einen ganzen Bereich würde zu leicht
|
||||
Kundennamen nach Hause schicken.
|
||||
|
||||
**Was der Sender nicht mehr schickt, verschwindet beim Empfänger.** Sonst
|
||||
stünde daheim für immer eine Sperre, die es längst nicht mehr gibt. Für
|
||||
Aufgaben gilt das nicht: Sie sind Planung, keine Sperre.
|
||||
|
||||
**Jede Sendung ist fünf Minuten gültig.** Ohne Frist ließe sich ein
|
||||
abgefangenes Paket beliebig oft erneut einspielen. Der Empfänger antwortet
|
||||
auf jeden Fehlschlag gleich — falsches Geheimnis, verstellte Uhr und Unsinn
|
||||
im Inhalt sind von außen nicht zu unterscheiden.
|
||||
|
||||
**Die Demo-Instanz redet mit niemandem.** Sie ist mit erfundenen Daten
|
||||
gefüllt und steht nur für Bilder. Solange `DEMO_MODUS` gilt, starten die
|
||||
Jobs für Zammad, Telegram und den Spiegel gar nicht erst.
|
||||
|
||||
### Probleme und Lösungen
|
||||
|
||||
| Problem | Lösung |
|
||||
| ---------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| Die Kopfleiste verschluckte mit dem elften Eintrag „Einstellungen" und „Protokoll" | Sie ist jetzt breiter als die Inhaltsspalte. Eine Leiste, die Punkte stillschweigend abschneidet, ist schlimmer als eine, die nicht bündig mit dem Text steht. Gefunden im aufgenommenen Bild. |
|
||||
| Der Kartentext erklärte noch den Weg von vor dem Kopplungscode | Ersetzt. Ebenfalls erst im Bild aufgefallen — im Code war beides für sich stimmig. |
|
||||
| Ein Kürzungstest schlug an der Grenze fehl | Nicht der Test war falsch, sondern der Vergleich: Eine Worttrennung bei genau der halben Titellänge wurde abgelehnt. Jetzt `>=`. |
|
||||
| Ein regulärer Ausdruck ging beim Schreiben über die Shell kaputt | Das Muster steht jetzt als benannte Konstante im Code, geschrieben mit dem Edit-Werkzeug statt über ein Skript. |
|
||||
| Ein unsichtbares Zeichen (U+200B) landete mitten in einem Funktionsnamen | Entfernt und die Datei danach abgesucht. |
|
||||
| Das Aufräumen im Integrationstest hätte fremde Telegram-Chats treffen können | Es trifft jetzt genau die Kennung, die der Lauf selbst angelegt hat. |
|
||||
| Docker-Bauten blieben dreimal hängen, einmal 39 Minuten ohne Ausgabe | Kein Codeproblem: Nach Abbruch und Neustart lief derselbe Bau in Minuten durch. Die Bilder mussten deshalb viermal angestoßen werden. |
|
||||
|
||||
### Offene Punkte
|
||||
|
||||
- **Der Wartungsplaner ist nicht angebunden.** Die Aufnahmestelle steht
|
||||
bereit und die Seite führt ihn als sichtbare Lücke; es fehlt allein das
|
||||
Abholen. Dafür muss erst feststehen, was das Produkt an Schnittstelle
|
||||
hergibt.
|
||||
- Zammad und Telegram sind gegen die Logik geprüft, nicht gegen die echten
|
||||
Dienste — dafür fehlen Zugangsdaten. Der Spiegel dagegen ist end-to-end
|
||||
geprüft, weil beide Enden dieselbe Anwendung sind.
|
||||
- Ein Telegram-Chat lässt sich nicht umbenennen. Fällt das im Alltag auf,
|
||||
ist es ein Einzeiler.
|
||||
|
||||
### Commits
|
||||
|
||||
- 7f8f505 feat: Datenmodell und Umgebung für Integrationen
|
||||
- e4d3547 feat: Aufnahmeregeln für Integrationen als reine Logik
|
||||
- 6dad333 feat: Zammad, Telegram und den Spiegel anbinden
|
||||
- bc60e5f feat: Integrationen takten und Telegram als dritten Meldeweg
|
||||
- 1281c3e feat: Integrationen sichtbar und bedienbar machen
|
||||
- 0d0f850 feat: Gespiegelte Belegung in der Wochenansicht zeigen
|
||||
- 4da2f3d test: Spiegel-Eingang und Integrationstabellen absichern
|
||||
- 3befcc1 feat: Aufgaben einzeln zum Spiegeln freigeben
|
||||
- f5eadef feat: Lauf von Hand anstoßen und Spiegelschalter in der Liste
|
||||
- 3c7cdbb chore: Demo-Daten, Bildaufnahme und Platz in der Kopfleiste
|
||||
- 475b1d5 docs: Handbuchseite, README und Fahrplan für M6
|
||||
- 98d170b docs: Handbuchbilder für M6 neu aufnehmen
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -4,3 +4,4 @@ datum;start;ende;minuten;meilenstein;art;notiz
|
||||
2026-09-10;17:48;18:29;41;M3;claude;M3 Kalender lesen fertig
|
||||
2026-09-10;20:42;23:29;167;M4;claude;M4 Wochenplanung fertig
|
||||
2026-09-11;06:35;13:35;420;M5;claude;M5 Benachrichtigungen fertig
|
||||
2026-09-11;20:47;09:00;733;M6;claude;M6 Integrationen fertig
|
||||
|
||||
|
@@ -68,5 +68,10 @@ services:
|
||||
# moeglich, hinaus geht trotzdem nichts.
|
||||
SMTP_HOST: smtp.planer.invalid
|
||||
SMTP_ABSENDER: Planer <planer@planer.invalid>
|
||||
# Erfundene Werte, damit die Seite "Integrationen" den eingerichteten
|
||||
# Fall zeigt. Nach draussen geht davon nichts: Die Jobs schweigen,
|
||||
# solange DEMO_MODUS true ist.
|
||||
TELEGRAM_TOKEN: 000000:demo-token-ohne-funktion
|
||||
SPIEGEL_GEHEIMNIS: demo-geheimnis-ohne-funktion
|
||||
ports:
|
||||
- '${SCREENSHOT_APP_PORT:-3200}:3000'
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 33 KiB After Width: | Height: | Size: 33 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 46 KiB After Width: | Height: | Size: 46 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 34 KiB After Width: | Height: | Size: 34 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 47 KiB After Width: | Height: | Size: 47 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 267 KiB After Width: | Height: | Size: 267 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 282 KiB After Width: | Height: | Size: 282 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 272 KiB After Width: | Height: | Size: 272 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 288 KiB After Width: | Height: | Size: 289 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 168 KiB After Width: | Height: | Size: 176 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 156 KiB After Width: | Height: | Size: 164 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 172 KiB After Width: | Height: | Size: 180 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 160 KiB After Width: | Height: | Size: 168 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 217 KiB After Width: | Height: | Size: 217 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 234 KiB After Width: | Height: | Size: 235 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 221 KiB After Width: | Height: | Size: 221 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 238 KiB After Width: | Height: | Size: 239 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 270 KiB After Width: | Height: | Size: 278 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 282 KiB After Width: | Height: | Size: 291 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 277 KiB After Width: | Height: | Size: 286 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 289 KiB After Width: | Height: | Size: 298 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 111 KiB After Width: | Height: | Size: 111 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 131 KiB After Width: | Height: | Size: 132 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 113 KiB After Width: | Height: | Size: 113 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 133 KiB After Width: | Height: | Size: 134 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 101 KiB After Width: | Height: | Size: 101 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 121 KiB After Width: | Height: | Size: 122 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 103 KiB After Width: | Height: | Size: 103 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 124 KiB After Width: | Height: | Size: 124 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 204 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 213 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 210 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 219 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 135 KiB After Width: | Height: | Size: 135 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 152 KiB After Width: | Height: | Size: 152 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 139 KiB After Width: | Height: | Size: 139 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 155 KiB After Width: | Height: | Size: 155 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 68 KiB After Width: | Height: | Size: 68 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 98 KiB After Width: | Height: | Size: 98 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 69 KiB After Width: | Height: | Size: 69 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 99 KiB After Width: | Height: | Size: 100 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 70 KiB After Width: | Height: | Size: 70 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 118 KiB After Width: | Height: | Size: 119 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 69 KiB After Width: | Height: | Size: 69 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 120 KiB After Width: | Height: | Size: 122 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 228 KiB After Width: | Height: | Size: 228 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 236 KiB After Width: | Height: | Size: 237 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 234 KiB After Width: | Height: | Size: 234 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 242 KiB After Width: | Height: | Size: 243 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 269 KiB After Width: | Height: | Size: 286 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 301 KiB After Width: | Height: | Size: 349 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 268 KiB After Width: | Height: | Size: 284 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 301 KiB After Width: | Height: | Size: 349 KiB |
@@ -20,12 +20,14 @@ Anleitung für den Alltag mit dem Planer. Eine Seite je Thema.
|
||||
verbinden, Belegung verstehen
|
||||
7. **[Wochenplanung](woche.md)** – Aufgaben per Ziehen und Ablegen in den
|
||||
Kalender legen
|
||||
8. **[Benachrichtigungen](benachrichtigungen.md)** – Push und E-Mail
|
||||
einrichten, Ruhezeiten setzen
|
||||
8. **[Benachrichtigungen](benachrichtigungen.md)** – Push, E-Mail und
|
||||
Telegram einrichten, Ruhezeiten setzen
|
||||
9. **[Integrationen](integrationen.md)** – Zammad, Telegram und der Spiegel
|
||||
zwischen Firma und Daheim
|
||||
|
||||
## Verwaltung
|
||||
|
||||
9. **[Protokoll](protokoll.md)** – nachsehen, wer wann was geändert hat
|
||||
10. **[Protokoll](protokoll.md)** – nachsehen, wer wann was geändert hat
|
||||
|
||||
## Was noch kommt
|
||||
|
||||
@@ -33,7 +35,6 @@ Diese Seiten entstehen mit den nächsten Meilensteinen:
|
||||
|
||||
| Thema | Meilenstein |
|
||||
| ------------------------------- | ----------- |
|
||||
| Integrationen | M6 |
|
||||
| Schnellerfassung vom Handy, API | M7 |
|
||||
| MCP | M8 |
|
||||
|
||||
|
||||
@@ -0,0 +1,151 @@
|
||||
# Integrationen
|
||||
|
||||
Was von außen hereinkommt — und was diese Instanz hinausgibt. Du findest den
|
||||
Überblick im Menü unter **Integrationen**.
|
||||
|
||||
|
||||
|
||||
Welche Integration es überhaupt gibt, hängt an der Instanz und ist nicht
|
||||
verhandelbar:
|
||||
|
||||
| | Firma | Daheim |
|
||||
| -------------- | ------ | -------- |
|
||||
| Zammad | ja | nein |
|
||||
| Wartungsplaner | ja | nein |
|
||||
| Telegram | nein | ja |
|
||||
| Spiegel | sendet | empfängt |
|
||||
|
||||
Eine Integration, die deine Instanz nicht vorsieht, lässt sich auch mit
|
||||
vollständiger Konfiguration nicht anschalten. Das steckt in der Anwendung,
|
||||
nicht in einer Einstellung, die sich versehentlich verstellen ließe.
|
||||
|
||||
## Was jede Integration mit deinen Aufgaben darf
|
||||
|
||||
Für alle gilt dieselbe Regel — und die ist wichtiger als jedes Detail
|
||||
darunter:
|
||||
|
||||
| Führt das Ursprungssystem | Führst du |
|
||||
| --------------------------------- | ------------------------------------------------ |
|
||||
| Titel, Notiz, Verweis, Fälligkeit | Bereich, Projekt, Priorität, geschätzter Aufwand |
|
||||
|
||||
Wer ein Ticket in einen Bereich einsortiert und den Aufwand schätzt, muss
|
||||
sich darauf verlassen können, dass der nächste Abgleich das nicht wegräumt.
|
||||
Umgekehrt: Ändert sich drüben der Titel, zieht er hier mit.
|
||||
|
||||
Dieselbe Sache ergibt nie eine zweite Aufgabe. Der Planer merkt sich zu jeder
|
||||
Aufgabe, woher sie kam und unter welcher Kennung.
|
||||
|
||||
## Zammad
|
||||
|
||||
Tickets, auf die der Suchausdruck passt, werden zu Aufgaben. Voreingestellt
|
||||
sind die dir zugewiesenen offenen Tickets; der Ausdruck steht in der
|
||||
Konfiguration (`ZAMMAD_ABFRAGE`) und versteht Zammads Suchsyntax.
|
||||
|
||||
- Der Titel wird `#Nummer Betreff`, der Verweis führt direkt ins Ticket.
|
||||
- Ein Ticket, das Zammad als geschlossen meldet, hakt der Planer ab.
|
||||
- **Geschrieben wird nach Zammad nichts.** Ein Ticket schließt man im
|
||||
Ticketsystem — sonst weiß die Kollegin nicht, warum es plötzlich zu ist.
|
||||
|
||||
Der Token gehört einem Benutzer und sieht genau das, was dieser Benutzer
|
||||
sehen darf. Der Planer umgeht keine Rechte.
|
||||
|
||||
## Wartungsplaner
|
||||
|
||||
Noch nicht angebunden. Die Aufnahmestelle steht bereit — es fehlt allein das
|
||||
Abholen, und dafür muss die Schnittstelle feststehen. Auf der Seite
|
||||
**Integrationen** ist der Punkt als offene Lücke sichtbar, damit er nicht in
|
||||
Vergessenheit gerät.
|
||||
|
||||
## Telegram
|
||||
|
||||
Drei Dinge in einem Kanal.
|
||||
|
||||
### Chat verbinden
|
||||
|
||||
1. Unter **Integrationen** auf **Chat verbinden**.
|
||||
2. Der achtstellige Code erscheint. Er gilt **zehn Minuten** und genau
|
||||
**einmal**.
|
||||
3. Schick ihn dem Bot — als Nachricht oder als `/start ABCD2345`.
|
||||
4. Der Bot bestätigt, und der Chat erscheint in der Liste.
|
||||
|
||||
> **Warum der Umweg?** Wer nicht in der Liste steht, bekommt vom Bot keine
|
||||
> Antwort — auch keine Fehlermeldung. Sonst könnte jeder, der die Kennung des
|
||||
> Bots kennt, herausfinden, dass es dich gibt. Der Code ist der Beweis, dass
|
||||
> jemand mit Zugang zur Anwendung diesen Chat wirklich will.
|
||||
|
||||
### Erfassen
|
||||
|
||||
Jede Nachricht an den Bot wird eine Aufgabe. Lange Texte werden gekürzt; der
|
||||
Rest landet in der Notiz und geht nicht verloren. Die Aufgabe hat keinen
|
||||
Bereich — sie liegt also in der **Inbox** und will einsortiert werden.
|
||||
|
||||
### Melden und abhaken
|
||||
|
||||
Ist Telegram in den [Benachrichtigungen](benachrichtigungen.md) als Weg
|
||||
eingeschaltet, kommen Meldungen auch hier an. Geht es um genau eine Aufgabe,
|
||||
hängt darunter ein Knopf **✓ Erledigt** — ein Druck, und sie ist abgehakt,
|
||||
ohne die Anwendung zu öffnen.
|
||||
|
||||
Mehr kann der Knopf nicht. Löschen oder Verschieben aus einem Chat heraus
|
||||
wäre zu leicht versehentlich getroffen.
|
||||
|
||||
Je Chat lässt sich einzeln einstellen, ob er Meldungen bekommt: Das Glöckchen
|
||||
in der Liste schaltet um.
|
||||
|
||||
## Der Spiegel
|
||||
|
||||
Die Firma schickt nach Hause, nicht umgekehrt. Zwei Dinge gehen hinüber.
|
||||
|
||||
**Belegungen.** Wann dienstlich Zeit verplant ist — ohne Titel, ohne Aufgabe,
|
||||
ohne Kunde. Daheim erscheinen sie in der Wochenansicht als gestreifte Balken
|
||||
mit der Aufschrift „Dienstlich belegt" und zählen gegen die Tageskapazität.
|
||||
So kollidiert die private Planung nicht mit der dienstlichen, und trotzdem
|
||||
verlässt kein Firmeninhalt die Firma.
|
||||
|
||||
**Markierte Aufgaben.** Nur was du an der Aufgabe ausdrücklich zum Spiegeln
|
||||
freigibst, geht mit Titel hinüber. Das ist eine Einzelentscheidung je
|
||||
Aufgabe, kein Schalter für alles: Wer versehentlich einen ganzen Bereich
|
||||
spiegelt, schickt Kundennamen nach Hause.
|
||||
|
||||
Was der Sender nicht mehr schickt, verschwindet auch drüben. Wird ein
|
||||
Zeitblock in der Firma ausgeplant, ist die Sperre daheim beim nächsten Lauf
|
||||
weg — sonst stünde dort für immer eine Blockade, die es längst nicht mehr
|
||||
gibt.
|
||||
|
||||
## Wann läuft was
|
||||
|
||||
| Integration | Takt |
|
||||
| ----------- | --------------- |
|
||||
| Telegram | alle 2 Minuten |
|
||||
| Zammad | alle 15 Minuten |
|
||||
| Spiegel | alle 15 Minuten |
|
||||
|
||||
Wer dem Bot etwas schickt, erwartet die Aufgabe gleich in der Liste. In
|
||||
Zammad ändert sich dagegen nichts im Minutentakt.
|
||||
|
||||
Warten muss man trotzdem nicht: Auf der Seite **Integrationen** stößt
|
||||
**Jetzt abrufen** einen Lauf von Hand an. Das lohnt vor allem direkt nach dem
|
||||
Einrichten — sonst wüsstest du erst beim nächsten Takt, ob die Zugangsdaten
|
||||
stimmen.
|
||||
|
||||
## Wenn etwas klemmt
|
||||
|
||||
Unter jeder Integration steht, wann sie zuletzt geglückt ist und woran sie
|
||||
zuletzt gescheitert ist. Nach dem dritten Fehlschlag hintereinander gilt sie
|
||||
als **gestört** — und dann meldet sich der Planer auch, sofern du den Anlass
|
||||
„Ein Kalender lässt sich nicht abgleichen" eingeschaltet hast.
|
||||
|
||||
Erst nach dem dritten Mal: Ein Netz hustet, ein Anbieter hat Wartung. Beim
|
||||
ersten Fehlschlag zu melden hieße, dich für Dinge zu wecken, die sich von
|
||||
selbst erledigen.
|
||||
|
||||
| Symptom | Ursache |
|
||||
| ---------------------------------------- | --------------------------------------------------------------------------------- |
|
||||
| „Nicht eingerichtet" trotz Konfiguration | Die Instanz sieht diese Integration nicht vor |
|
||||
| Zammad findet nichts | Der Suchausdruck passt auf kein Ticket — in Zammad selbst probieren |
|
||||
| Der Bot antwortet nicht | Der Chat ist nicht verbunden, oder der Code war abgelaufen |
|
||||
| Der Spiegel wird abgelehnt | Verschiedene Geheimnisse, oder die Uhren laufen mehr als fünf Minuten auseinander |
|
||||
|
||||
---
|
||||
|
||||
Zurück zum [Handbuch](README.md).
|
||||
@@ -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.
|
||||
*
|
||||
|
||||
@@ -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, unknown> = {}): 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)
|
||||
})
|
||||
})
|
||||
Generated
+2
-2
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "planer",
|
||||
"version": "0.5.0",
|
||||
"version": "0.6.0",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "planer",
|
||||
"version": "0.5.0",
|
||||
"version": "0.6.0",
|
||||
"dependencies": {
|
||||
"@auth/prisma-adapter": "2.11.3",
|
||||
"@date-fns/tz": "1.5.0",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "planer",
|
||||
"version": "0.5.0",
|
||||
"version": "0.6.0",
|
||||
"private": true,
|
||||
"description": "Aufgaben, Ideen, Projekte und Zeitblöcke mit Anbindung an Microsoft 365 und Google Kalender",
|
||||
"type": "module",
|
||||
|
||||
@@ -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,
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
@@ -429,6 +429,7 @@ async function main(): Promise<void> {
|
||||
anlaesse: 'tagesueberblick,faelligkeit,zeitblock',
|
||||
perPush: true,
|
||||
perMail: true,
|
||||
perTelegram: true,
|
||||
ueberblickUm: 7 * 60,
|
||||
ruheVon: 20 * 60,
|
||||
ruheBis: 7 * 60,
|
||||
@@ -442,6 +443,52 @@ async function main(): Promise<void> {
|
||||
// nicht lesen kann. Ein erfundener Eintrag verschwände beim ersten Lauf
|
||||
// wieder — die Bilder zeigen deshalb den Zustand vor der ersten Anmeldung.
|
||||
|
||||
// --- Integrationen --------------------------------------------------------
|
||||
await db.integrationszustand.deleteMany({})
|
||||
await db.integrationszustand.create({
|
||||
data: {
|
||||
quelle: 'TELEGRAM',
|
||||
merker: '4711',
|
||||
letzterLauf: new Date(Date.UTC(2026, 2, 17, 8, 18)),
|
||||
letzterErfolg: new Date(Date.UTC(2026, 2, 17, 8, 18)),
|
||||
},
|
||||
})
|
||||
await db.integrationszustand.create({
|
||||
data: {
|
||||
quelle: 'SPIEGEL',
|
||||
letzterLauf: new Date(Date.UTC(2026, 2, 17, 8, 15)),
|
||||
letzterErfolg: new Date(Date.UTC(2026, 2, 17, 8, 15)),
|
||||
},
|
||||
})
|
||||
|
||||
await db.telegramChat.deleteMany({})
|
||||
await db.telegramChat.create({
|
||||
data: {
|
||||
// Erfunden. Der Bot ist ohnehin abgeschaltet, solange DEMO_MODUS gilt.
|
||||
chatId: BigInt(147258369),
|
||||
benutzerId: benutzer.id,
|
||||
bezeichnung: 'Martina',
|
||||
erstelltAm: new Date(Date.UTC(2026, 1, 3, 8, 25)),
|
||||
zuletztBenutzt: new Date(Date.UTC(2026, 2, 17, 6, 40)),
|
||||
},
|
||||
})
|
||||
|
||||
// Dienstliche Belegung, wie sie aus der Firma hereinkaeme: ohne Titel.
|
||||
await db.spiegelbelegung.deleteMany({})
|
||||
for (const [tag, stunde, dauer] of [
|
||||
[17, 9, 2],
|
||||
[18, 13, 3],
|
||||
[19, 8, 1],
|
||||
] as const) {
|
||||
await db.spiegelbelegung.create({
|
||||
data: {
|
||||
quelleRef: `demo-spiegel-${tag}-${stunde}`,
|
||||
beginn: new Date(Date.UTC(2026, 2, tag, stunde - 1, 0)),
|
||||
ende: new Date(Date.UTC(2026, 2, tag, stunde - 1 + dauer, 0)),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
console.log(`Demo-Daten stehen bereit. Anmeldung: ${DEMO_EMAIL}`)
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
@@ -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");
|
||||
+93
-3
@@ -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")
|
||||
}
|
||||
|
||||
@@ -43,6 +43,7 @@ const AUFNAHMEN: Aufnahme[] = [
|
||||
{ name: 'ideen', pfad: '/ideen' },
|
||||
{ name: 'bereiche', pfad: '/bereiche' },
|
||||
{ name: 'kalenderkonten', pfad: '/kalenderkonten' },
|
||||
{ name: 'integrationen', pfad: '/integrationen' },
|
||||
{ name: 'einstellungen', pfad: '/einstellungen' },
|
||||
{
|
||||
name: 'benachrichtigungen',
|
||||
|
||||
@@ -41,6 +41,9 @@ async function scheitert(name: string, tun: () => Promise<unknown>): Promise<voi
|
||||
}
|
||||
|
||||
const kennung = `zzz-test-${Date.now()}`
|
||||
// Eigene Chatkennung je Lauf, damit das Aufraeumen genau diese Zeile trifft
|
||||
// und nicht irgendeine, die zufaellig aehnlich aussieht.
|
||||
const testChatId = BigInt(Date.now())
|
||||
const testEmail = `${kennung}@example.invalid`
|
||||
|
||||
async function aufraeumen(): Promise<void> {
|
||||
@@ -58,6 +61,12 @@ async function aufraeumen(): Promise<void> {
|
||||
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<void> {
|
||||
@@ -316,6 +325,76 @@ async function main(): Promise<void> {
|
||||
).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<void> {
|
||||
'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({
|
||||
|
||||
@@ -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<Record<string, string | string[] | undefined>>
|
||||
}) {
|
||||
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({
|
||||
</CardInhalt>
|
||||
</Card>
|
||||
|
||||
{/* Nur wo auch gespiegelt wird, hat der Schalter einen Sinn. */}
|
||||
<AufgabenListe
|
||||
aufgaben={aufgaben}
|
||||
bereiche={bereiche}
|
||||
projekte={projekte}
|
||||
leerText="Keine Aufgabe passt zu diesen Filtern."
|
||||
mitSpiegeln={spiegelt}
|
||||
/>
|
||||
</div>
|
||||
)
|
||||
|
||||
@@ -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({
|
||||
)}
|
||||
</span>
|
||||
</label>
|
||||
|
||||
<label className="flex items-center gap-3">
|
||||
<input
|
||||
type="checkbox"
|
||||
name="perTelegram"
|
||||
defaultChecked={einstellung.perTelegram}
|
||||
className="accent-betont size-4"
|
||||
/>
|
||||
<span className="text-sm">
|
||||
Telegram
|
||||
{!telegramMoeglich ? (
|
||||
<span className="text-gedaempft-vordergrund">
|
||||
{' '}
|
||||
— auf diesem Server nicht eingerichtet
|
||||
</span>
|
||||
) : telegramChats === 0 ? (
|
||||
<span className="text-gedaempft-vordergrund">
|
||||
{' '}
|
||||
— noch kein Chat eingetragen
|
||||
</span>
|
||||
) : (
|
||||
<span className="text-gedaempft-vordergrund">
|
||||
{' '}
|
||||
— an {telegramChats} Chat{telegramChats === 1 ? '' : 's'}, mit Knopf zum
|
||||
Abhaken
|
||||
</span>
|
||||
)}
|
||||
</span>
|
||||
</label>
|
||||
</fieldset>
|
||||
|
||||
<div className="grid gap-4 sm:grid-cols-2">
|
||||
|
||||
@@ -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() {
|
||||
<Benachrichtigungen
|
||||
pushMoeglich={einst.pushAktiv}
|
||||
mailMoeglich={einst.mailAktiv}
|
||||
telegramMoeglich={einst.telegramAktiv}
|
||||
telegramChats={telegramChats}
|
||||
einstellung={{
|
||||
anlaesse: [...einstellung.anlaesse],
|
||||
perPush: einstellung.perPush,
|
||||
perMail: einstellung.perMail,
|
||||
perTelegram: einstellung.perTelegram,
|
||||
ueberblickUm: alsUhrzeit(einstellung.ueberblickUm),
|
||||
ruheVon: alsUhrzeit(einstellung.ruheVon),
|
||||
ruheBis: alsUhrzeit(einstellung.ruheBis),
|
||||
|
||||
@@ -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 (
|
||||
<Button
|
||||
art="umriss"
|
||||
disabled={laeuft}
|
||||
onClick={() => {
|
||||
starte(async () => {
|
||||
const daten = new FormData()
|
||||
daten.set('quelle', quelle)
|
||||
const antwort = await laufAnstossen(daten)
|
||||
if (antwort.ok) {
|
||||
toast.success(antwort.meldung)
|
||||
router.refresh()
|
||||
} else {
|
||||
toast.error(antwort.fehler)
|
||||
}
|
||||
})
|
||||
}}
|
||||
>
|
||||
{laeuft ? (
|
||||
<Loader2 className="animate-spin" aria-hidden />
|
||||
) : (
|
||||
<RefreshCw aria-hidden />
|
||||
)}
|
||||
Jetzt abrufen
|
||||
</Button>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,192 @@
|
||||
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,
|
||||
CardBeschreibung,
|
||||
CardInhalt,
|
||||
CardKopf,
|
||||
CardTitel,
|
||||
} from '@/components/ui/card'
|
||||
import { Kennzeichen } from '@/components/ui/kennzeichen'
|
||||
import type { Quelle } from '@/generated/prisma/enums'
|
||||
import { INTEGRATION_FEHLER_AB_VERSUCH } from '@/lib/integration'
|
||||
import { alsDatumUhrzeit } from '@/lib/zeit'
|
||||
import { verlangeAnmeldung } from '@/server/berechtigung'
|
||||
import { db } from '@/server/db'
|
||||
import { umgebung } from '@/server/umgebung'
|
||||
|
||||
export const metadata: Metadata = { title: 'Integrationen' }
|
||||
|
||||
type Zeile = {
|
||||
quelle: Quelle
|
||||
name: string
|
||||
beschreibung: string
|
||||
/** In dieser Instanz überhaupt vorgesehen? */
|
||||
vorgesehen: boolean
|
||||
/** 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() {
|
||||
await verlangeAnmeldung('/integrationen')
|
||||
const einst = umgebung()
|
||||
|
||||
const [zustaende, chats] = await Promise.all([
|
||||
db.integrationszustand.findMany(),
|
||||
db.telegramChat.findMany({
|
||||
orderBy: { erstelltAm: 'asc' },
|
||||
select: {
|
||||
id: true,
|
||||
chatId: true,
|
||||
bezeichnung: true,
|
||||
meldungen: true,
|
||||
erstelltAm: true,
|
||||
zuletztBenutzt: true,
|
||||
},
|
||||
}),
|
||||
])
|
||||
|
||||
const nachQuelle = new Map(zustaende.map((z) => [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.',
|
||||
abrufbar: einst.zammadAktiv,
|
||||
},
|
||||
{
|
||||
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.',
|
||||
abrufbar: einst.telegramAktiv,
|
||||
},
|
||||
{
|
||||
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.',
|
||||
// Die empfangende Seite ruft nichts ab – sie wartet.
|
||||
abrufbar: einst.spiegelSendenAktiv,
|
||||
},
|
||||
]
|
||||
|
||||
return (
|
||||
<div className="flex flex-col gap-6">
|
||||
<div className="flex items-center gap-3">
|
||||
<Plug className="text-gedaempft-vordergrund size-6" aria-hidden />
|
||||
<div>
|
||||
<h1 className="text-2xl font-semibold tracking-tight">Integrationen</h1>
|
||||
<p className="text-gedaempft-vordergrund text-sm">
|
||||
Was von außen hereinkommt — und was diese Instanz hinausgibt.
|
||||
</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div className="flex flex-col gap-4">
|
||||
{zeilen.map((zeile) => {
|
||||
const zustand = nachQuelle.get(zeile.quelle)
|
||||
const gestoert = (zustand?.fehlversuche ?? 0) >= INTEGRATION_FEHLER_AB_VERSUCH
|
||||
|
||||
return (
|
||||
<Card key={zeile.quelle} className={zeile.vorgesehen ? '' : 'opacity-60'}>
|
||||
<CardKopf>
|
||||
<div className="flex flex-wrap items-center gap-2">
|
||||
<CardTitel className="text-base">{zeile.name}</CardTitel>
|
||||
{!zeile.vorgesehen ? (
|
||||
<Kennzeichen art="neutral">
|
||||
In dieser Instanz nicht vorgesehen
|
||||
</Kennzeichen>
|
||||
) : gestoert ? (
|
||||
<Kennzeichen art="gefahr">Gestört</Kennzeichen>
|
||||
) : zeile.aktiv ? (
|
||||
<Kennzeichen art="erfolg">Läuft</Kennzeichen>
|
||||
) : (
|
||||
<Kennzeichen art="warnung">Nicht eingerichtet</Kennzeichen>
|
||||
)}
|
||||
</div>
|
||||
<CardBeschreibung>{zeile.beschreibung}</CardBeschreibung>
|
||||
</CardKopf>
|
||||
|
||||
<CardInhalt className="text-gedaempft-vordergrund flex flex-col gap-1 text-sm">
|
||||
{zeile.vorgesehen && !zeile.aktiv && <p>{zeile.hinweis}</p>}
|
||||
|
||||
{zustand?.letzterErfolg && (
|
||||
<p>Zuletzt geglückt: {alsDatumUhrzeit(zustand.letzterErfolg)}</p>
|
||||
)}
|
||||
{zustand?.letzterFehler && (
|
||||
<p className="text-gefahr">
|
||||
Letzter Fehler: {zustand.letzterFehler}
|
||||
{zustand.fehlversuche > 1 && ` (${zustand.fehlversuche}× in Folge)`}
|
||||
</p>
|
||||
)}
|
||||
{!zustand && zeile.aktiv && <p>Noch kein Lauf.</p>}
|
||||
|
||||
{zeile.abrufbar && (
|
||||
<div className="pt-2">
|
||||
<LaufKnopf quelle={zeile.quelle} />
|
||||
</div>
|
||||
)}
|
||||
</CardInhalt>
|
||||
</Card>
|
||||
)
|
||||
})}
|
||||
</div>
|
||||
|
||||
{einst.telegramAktiv && (
|
||||
<Card>
|
||||
<CardKopf>
|
||||
<CardTitel className="text-base">Telegram-Chats</CardTitel>
|
||||
<CardBeschreibung>
|
||||
Nur wer hier steht, darf mit dem Bot reden — und nur diese Chats bekommen
|
||||
Meldungen. Alles andere wird verworfen, ohne zu antworten. Zum Verbinden
|
||||
holst du dir hier einen Code und schickst ihn dem Bot; er gilt zehn Minuten
|
||||
und genau einmal.
|
||||
</CardBeschreibung>
|
||||
</CardKopf>
|
||||
<CardInhalt>
|
||||
<TelegramChats
|
||||
chats={chats.map((c) => ({
|
||||
id: c.id,
|
||||
chatId: c.chatId.toString(),
|
||||
bezeichnung: c.bezeichnung,
|
||||
meldungen: c.meldungen,
|
||||
erstelltAm: alsDatumUhrzeit(c.erstelltAm),
|
||||
zuletztBenutzt: c.zuletztBenutzt
|
||||
? alsDatumUhrzeit(c.zuletztBenutzt)
|
||||
: null,
|
||||
}))}
|
||||
/>
|
||||
</CardInhalt>
|
||||
</Card>
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -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 (
|
||||
<div className="flex flex-col gap-4">
|
||||
{chats.length === 0 ? (
|
||||
<p className="text-gedaempft-vordergrund text-sm">
|
||||
Noch kein Chat verbunden. Ohne Verbindung nimmt der Bot nichts an.
|
||||
</p>
|
||||
) : (
|
||||
<ul className="divide-rand divide-y">
|
||||
{chats.map((chat) => (
|
||||
<li key={chat.id} className="flex items-center gap-3 py-2">
|
||||
<div className="min-w-0 flex-1">
|
||||
<p className="text-sm">{chat.bezeichnung ?? `Chat ${chat.chatId}`}</p>
|
||||
<p className="text-gedaempft-vordergrund text-xs">
|
||||
Verbunden {chat.erstelltAm}
|
||||
{chat.zuletztBenutzt
|
||||
? ` · zuletzt benutzt ${chat.zuletztBenutzt}`
|
||||
: ' · noch nichts geschickt'}
|
||||
</p>
|
||||
</div>
|
||||
|
||||
<Button
|
||||
art="leise"
|
||||
groesse="quadrat"
|
||||
title={
|
||||
chat.meldungen ? 'Keine Meldungen mehr hierher' : 'Meldungen hierher'
|
||||
}
|
||||
disabled={laeuft}
|
||||
onClick={() => {
|
||||
const daten = new FormData()
|
||||
daten.set('id', chat.id)
|
||||
mitRueckmeldung(() => chatMeldungenUmschalten(daten))
|
||||
}}
|
||||
>
|
||||
{chat.meldungen ? (
|
||||
<Bell className="text-erfolg" aria-hidden />
|
||||
) : (
|
||||
<BellOff aria-hidden />
|
||||
)}
|
||||
<span className="sr-only">Meldungen umschalten</span>
|
||||
</Button>
|
||||
|
||||
<Button
|
||||
art="leise"
|
||||
groesse="quadrat"
|
||||
title="Chat trennen"
|
||||
disabled={laeuft}
|
||||
onClick={() => {
|
||||
const daten = new FormData()
|
||||
daten.set('id', chat.id)
|
||||
mitRueckmeldung(() => chatEntfernen(daten))
|
||||
}}
|
||||
>
|
||||
<Trash2 aria-hidden />
|
||||
<span className="sr-only">Trennen</span>
|
||||
</Button>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
)}
|
||||
|
||||
{code ? (
|
||||
<div className="border-rand rounded-md border p-3">
|
||||
<p className="text-sm">
|
||||
Schick dem Bot jetzt diesen Code — als Nachricht oder als{' '}
|
||||
<code className="text-xs">/start {code.code}</code>:
|
||||
</p>
|
||||
<p className="my-2 font-mono text-2xl tracking-widest">{code.code}</p>
|
||||
<p className="text-gedaempft-vordergrund text-xs">
|
||||
Gültig für {code.minuten} Minuten und nur ein einziges Mal. Danach erscheint
|
||||
der Chat hier — spätestens nach dem nächsten Abholen.
|
||||
</p>
|
||||
</div>
|
||||
) : (
|
||||
<div>
|
||||
<Button art="umriss" disabled={laeuft} onClick={anfordern}>
|
||||
{laeuft ? (
|
||||
<Loader2 className="animate-spin" aria-hidden />
|
||||
) : (
|
||||
<Link2 aria-hidden />
|
||||
)}
|
||||
Chat verbinden
|
||||
</Button>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -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,
|
||||
@@ -205,7 +206,8 @@ export default async function WocheSeite({
|
||||
<p className="text-gedaempft-vordergrund text-xs">
|
||||
Aufgabe aus der linken Spalte in ein Zeitfenster ziehen, um sie einzuplanen. Ein
|
||||
Zeitblock lässt sich am Griff verschieben; das Kreuz plant ihn wieder aus. Graue
|
||||
Balken sind Termine aus dem Kalender — sie lassen sich hier nicht verschieben.
|
||||
Balken sind Termine aus dem Kalender, gestreifte kommen aus der anderen Instanz
|
||||
— beide lassen sich hier nicht verschieben.
|
||||
</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
@@ -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}`
|
||||
}
|
||||
>
|
||||
<span className="line-clamp-2">
|
||||
{eintrag.betreff ?? 'Termin'}
|
||||
{eintrag.gespiegelt
|
||||
? 'Dienstlich belegt'
|
||||
: (eintrag.betreff ?? 'Termin')}
|
||||
</span>
|
||||
</div>
|
||||
)
|
||||
|
||||
@@ -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 })
|
||||
}
|
||||
@@ -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<string | null>(null)
|
||||
@@ -60,6 +63,7 @@ export function AufgabenListe({
|
||||
bereiche={bereiche}
|
||||
mitEinsortieren={mitEinsortieren}
|
||||
mitUebernehmen={mitUebernehmen}
|
||||
mitSpiegeln={mitSpiegeln}
|
||||
{...(mitBearbeiten
|
||||
? { onBearbeiten: () => setBearbeitet(aufgabe.id) }
|
||||
: {})}
|
||||
|
||||
@@ -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({
|
||||
</div>
|
||||
|
||||
<div className="flex shrink-0 items-center gap-1">
|
||||
{mitSpiegeln && (
|
||||
<Button
|
||||
art="leise"
|
||||
groesse="quadrat"
|
||||
title={
|
||||
aufgabe.spiegeln
|
||||
? 'Geht mit nach Hause – hier abschalten'
|
||||
: 'Mit nach Hause spiegeln'
|
||||
}
|
||||
disabled={laeuft}
|
||||
onClick={() => {
|
||||
const daten = new FormData()
|
||||
daten.set('id', aufgabe.id)
|
||||
mitRueckmeldung(() => spiegelnUmschalten(daten))
|
||||
}}
|
||||
>
|
||||
<Share2
|
||||
className={aufgabe.spiegeln ? 'text-betont' : undefined}
|
||||
aria-hidden
|
||||
/>
|
||||
<span className="sr-only">Spiegeln</span>
|
||||
</Button>
|
||||
)}
|
||||
{onBearbeiten && (
|
||||
<Button
|
||||
art="leise"
|
||||
|
||||
@@ -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 },
|
||||
]
|
||||
@@ -49,7 +50,13 @@ export function Kopfleiste({
|
||||
Navigation waagerecht, statt umzubrechen und den Namen der Anwendung in
|
||||
die zweite Zeile zu drängen.
|
||||
*/}
|
||||
<div className="mx-auto flex w-full max-w-5xl items-center gap-3 px-4 py-3 sm:gap-6">
|
||||
{/*
|
||||
Breiter als die Inhaltsspalte (max-w-5xl): Mit dem elften Eintrag
|
||||
passte die Leiste dort nicht mehr, und "Einstellungen" verschwand
|
||||
stillschweigend am rechten Rand. Eine Leiste, die Punkte verschluckt,
|
||||
ist schlimmer als eine, die nicht buendig mit dem Text steht.
|
||||
*/}
|
||||
<div className="mx-auto flex w-full max-w-7xl items-center gap-3 px-4 py-3 sm:gap-5">
|
||||
<Link href="/" className="shrink-0 text-base font-semibold tracking-tight">
|
||||
Planer
|
||||
</Link>
|
||||
|
||||
@@ -16,6 +16,7 @@ function roh(teil: Partial<AufgabeRoh> = {}): AufgabeRoh {
|
||||
faelligAm: null,
|
||||
quelle: 'MANUELL',
|
||||
quelleUrl: null,
|
||||
spiegeln: false,
|
||||
bereich: null,
|
||||
projekt: null,
|
||||
...teil,
|
||||
|
||||
@@ -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,
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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> = {}): Fund {
|
||||
return { ref: 'T-1', titel: 'Drucker klemmt', ...teile }
|
||||
}
|
||||
|
||||
function bestand(teile: Partial<Bestand> = {}): 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)
|
||||
})
|
||||
})
|
||||
@@ -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<Bestand> }
|
||||
| { 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<Bestand> = {}
|
||||
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<typeof spiegelSendung>
|
||||
|
||||
/**
|
||||
* 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
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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<WocheDaten> {
|
||||
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()),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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<Rueckmeldung> {
|
||||
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<Rueckmeldung> {
|
||||
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<Rueckmeldung> {
|
||||
const geprueft = await akteurOder((fehler) => ({ ok: false, fehler }))
|
||||
|
||||
@@ -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<Rueckmeldun
|
||||
anlaesse: daten.getAll('anlaesse'),
|
||||
perPush: daten.get('perPush') !== null,
|
||||
perMail: daten.get('perMail') !== null,
|
||||
perTelegram: daten.get('perTelegram') !== null,
|
||||
ueberblickUm: daten.get('ueberblickUm'),
|
||||
ruheVon: daten.get('ruheVon'),
|
||||
ruheBis: daten.get('ruheBis'),
|
||||
@@ -57,6 +59,7 @@ export async function einstellungSpeichern(daten: FormData): Promise<Rueckmeldun
|
||||
anlaesse: gelesen.data.anlaesse.join(','),
|
||||
perPush: gelesen.data.perPush,
|
||||
perMail: gelesen.data.perMail,
|
||||
perTelegram: gelesen.data.perTelegram,
|
||||
ueberblickUm: gelesen.data.ueberblickUm,
|
||||
ruheVon: gelesen.data.ruheVon,
|
||||
ruheBis: gelesen.data.ruheBis,
|
||||
@@ -79,6 +82,7 @@ export async function einstellungSpeichern(daten: FormData): Promise<Rueckmeldun
|
||||
anlaesse: werte.anlaesse,
|
||||
perPush: werte.perPush,
|
||||
perMail: werte.perMail,
|
||||
perTelegram: werte.perTelegram,
|
||||
},
|
||||
})
|
||||
|
||||
@@ -103,6 +107,7 @@ export async function probeSenden(): Promise<Rueckmeldung> {
|
||||
anlaesse: true,
|
||||
perPush: true,
|
||||
perMail: true,
|
||||
perTelegram: true,
|
||||
ueberblickUm: true,
|
||||
ruheVon: true,
|
||||
ruheBis: true,
|
||||
@@ -112,8 +117,11 @@ export async function probeSenden(): Promise<Rueckmeldung> {
|
||||
})
|
||||
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<Rueckmeldung> {
|
||||
}
|
||||
}
|
||||
|
||||
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',
|
||||
|
||||
@@ -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<Rueckmeldung> {
|
||||
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<Rueckmeldung> {
|
||||
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<Rueckmeldung> {
|
||||
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.',
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<BenutzerMitEinstellung[]> {
|
||||
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<Meldung[]> {
|
||||
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<Record<Quelle, string>> = {
|
||||
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 }
|
||||
|
||||
@@ -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<Aufnahmebericht> {
|
||||
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<string | null> {
|
||||
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<void> {
|
||||
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<number> {
|
||||
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
|
||||
}
|
||||
@@ -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<SpiegelSendung> {
|
||||
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<Empfangsbericht> {
|
||||
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 }
|
||||
}
|
||||
@@ -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<string, unknown>,
|
||||
): Promise<unknown> {
|
||||
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<boolean> {
|
||||
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<number> {
|
||||
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<number> {
|
||||
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<string> {
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -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<typeof ticket>
|
||||
|
||||
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<Fund[]> {
|
||||
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<Aufnahmebericht> {
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -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<void> {
|
||||
const zeitpunkt = jetzt()
|
||||
@@ -87,11 +109,58 @@ export function jobsStarten(): void {
|
||||
})
|
||||
})
|
||||
|
||||
const einst = umgebung()
|
||||
|
||||
// Die Demo-Instanz redet mit niemandem. Sie ist mit erfundenen Daten
|
||||
// gefuellt und steht nur fuer Bilder – ein Aufruf nach draussen waere
|
||||
// bestenfalls sinnlos und schlimmstenfalls peinlich.
|
||||
const nachDraussen = !einst.DEMO_MODUS
|
||||
|
||||
if (einst.zammadAktiv && nachDraussen) {
|
||||
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 && nachDraussen) {
|
||||
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 && nachDraussen) {
|
||||
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) => {
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user